%javamethodmodifiers getLibSBMLVersion " /** * Returns the libSBML version as an integer: version 1.2.3 becomes 10203. *

* @return the libSBML version as an integer: version 1.2.3 becomes 10203. */ public"; %javamethodmodifiers getLibSBMLDottedVersion " /** * Returns the libSBML version as a string of the form \'1.2.3\'. *

* @return the libSBML version as a string of the form \'1.2.3\'. */ public"; %javamethodmodifiers getLibSBMLVersionString " /** * Returns the libSBML version as a string: version 1.2.3 becomes \'10203\'. *

* @return the libSBML version as a string: version 1.2.3 becomes \'10203\'. */ public"; %typemap(javaimports) SBMLReader " /** * Methods for reading SBML from files and text strings. *

* This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. *

* The {@link SBMLReader} class provides the main interface for reading SBML * content from files and strings. The methods for reading SBML all return * an {@link SBMLDocument} object representing the results. *

* In the case of failures (such as if the SBML contains errors or a file * cannot be read), the errors will be recorded with the {@link SBMLErrorLog} object * kept in the {@link SBMLDocument} returned by {@link SBMLReader}. Callers should check * for errors and warnings using the methods for this purpose provided on * {@link SBMLDocument}. *

* For convenience as well as easy access from other languages besides C++, * this file also defines two global functions, readSBML() and * readSBMLFromString(). They are equivalent to creating an {@link SBMLReader} * object and then calling * the {@link SBMLReader#readSBML(String filename)} or * {@link SBMLReader#readSBMLFromString(String xml)} methods, respectively. */ " %javamethodmodifiers SBMLReader::SBMLReader " /** * Creates a new {@link SBMLReader} and returns it. */ public"; %javamethodmodifiers SBMLReader::readSBML(const std::string& filename) " /** * Reads an SBML document from a file. *

* If the file named filename does not exist or its content is not * valid SBML, one or more errors will be logged with the {@link SBMLDocument} * object returned by this method. Callers can use the methods on * {@link SBMLDocument} such as SBMLDocument.getNumErrors() and * {@link SBMLDocument#getError(long n)} to get the errors. The object returned by * {@link SBMLDocument#getError(long n)} is an {@link SBMLError} object, and it has methods to * get the error code, category, and severity level of the problem, as * well as a textual description of the problem. The possible severity * levels range from informational messages to fatal errors; see the * documentation for {@link SBMLError} for more information. *

* If the file filename could not be read, the file-reading error will * appear first. The error code can provide a clue about what happened. * For example, a file might be unreadable (either because it does not * actually exist or because the user does not have the necessary access * priviledges to read it) or some sort of file operation error may have * bee reported by the underlying operating system. Callers can check * for these situations using code such as the following: *

   * {@link SBMLReader}  reader = new {@link SBMLReader}();
   * {@link SBMLDocument}  doc  = reader.readSBML(filename);
   * 
   * if (doc->getNumErrors() > 0)
   * {
   *   if (doc->getError(0)->getId() == XMLError.FileUnreadable)
   *   {
   *     // Handle case of unreadable file here.
   *   } 
   *   else if (doc->getError(0)->getId() == XMLError.FileOperationError)
   *   {
   *     // Handle case of other file error here.
   *   }
   *   else
   *   {
   *     // Handle other cases -- see error codes defined in XMLErrorCode_t
   *     // for other possible cases to check.
   *   }
   * }

* If the given filename ends with the suffix \'.gz\' (for example, * \'myfile.xml.gz\'), the file is assumed to be compressed in gzip * format and will be automatically decompressed upon reading. * Similarly, if the given filename ends with \'.zip\' or \'.bz2\', the * file is assumed to be compressed in zip or bzip2 format * (respectively). Files whose names lack these suffixes will be read * uncompressed. Note that if the file is in zip format but the * archive contains more than one file, only the first file in the * archive will be read and the rest ignored. *

* @param filename the name or full pathname of the file to be read. *

* @return a pointer to the {@link SBMLDocument} created from the SBML content. *

* @see SBMLError *

* @note LibSBML versions 2.x and 3.x behave differently in error * handling in several respects. One difference is how early some errors * are caught and whether libSBML continues processing a file in the face * of some early errors. In general, libSBML 3.x stops parsing SBML * inputs sooner than libSBML 2.x in the face of XML errors because the * errors may invalidate any further SBML content. For example, a * missing XML declaration at the beginning of the file was ignored by * libSBML 2.x but in version 3.x, it will cause libSBML to stop parsing * the rest of the input altogether. While this behavior may seem more * severe and intolerant, it was necessary in order to provide uniform * behavior regardless of which underlying XML parser (Expat, Xerces, * libxml2) is being used by libSBML. The XML parsers themselves behave * differently in their error reporting, and sometimes libSBML has to * resort to the lowest common denominator. *

* @note To read a gzip/zip file, libSBML needs to be configured and * linked with the zlib library at * compile time. It also needs to be linked with the bzip2 library to read files in bzip2 format. (Both of * these are the default configurations for libSBML.) Errors about * unreadable files will be logged if a compressed filename is given and * libSBML was not linked with the corresponding required library. *

* @note SBMLReader.hasZlib() and SBMLReader.hasBzip2() can be used to * check whether libSBML has been linked with each library. */ public"; %javamethodmodifiers SBMLReader::readSBMLFromString(const std::string& xml) " /** * Reads an SBML document from the given XML string. *

* This method is flexible with respect to the presence of an XML * declaration at the beginning of the string. In particular, if the * string in xml does not begin with the XML declaration * <?xml version=\'1.0\' encoding=\'UTF-8\'?>, then this * method will automatically prepend the declaration to xml. *

* This method will log a fatal error if the content given in the * parameter xml is not SBML. See the method documentation for * {@link SBMLReader#readSBML(String filename)} for an example of code for testing the returned * error code. *

* @param xml a string containing a full SBML model *

* @return a pointer to the {@link SBMLDocument} created from the SBML content. *

* @see SBMLReader#readSBML(String filename) */ public"; %javamethodmodifiers SBMLReader::hasZlib " /** * Predicate returning true or false depending on whether * libSBML is linked with zlib at compile time. *

* @return true if zlib is linked, false otherwise. */ public"; %javamethodmodifiers SBMLReader::hasBzip2 " /** * Predicate returning true or false depending on whether * libSBML is linked with bzip2 at compile time. *

* @return true if bzip2 is linked, false otherwise. */ public"; %javamethodmodifiers SBMLReader::readInternal(const char* content, bool isFile = true) " /** * Used by readSBML() and readSBMLFromString(). *

* @deprecated libSBML internal */ public"; %javamethodmodifiers readSBML(const char *filename) " /** * Reads an SBML document from the given file filename. *

* If filename does not exist, or it is not an SBML file, an error will * be logged in the error log of the {@link SBMLDocument} object returned by this * method. Calling programs can inspect this error log to determine * the nature of the problem. Please refer to the definition of * {@link SBMLDocument} for more information about the error reporting mechanism. *

* @return a pointer to the {@link SBMLDocument} read. */ public"; %javamethodmodifiers readSBMLFromString(const char *xml) " /** * Reads an SBML document from a string assumed to be in XML format. *

* If the string does not begin with XML declaration, *

<?xml version=\'1.0\' encoding=\'UTF-8\'?>

* an XML declaration string will be prepended. *

* This method will report an error if the given string xml is not SBML. * The error will be logged in the error log of the {@link SBMLDocument} object * returned by this method. Calling programs can inspect this error log to * determine the nature of the problem. Please refer to the definition of * {@link SBMLDocument} for more information about the error reporting mechanism. *

* @return a pointer to the {@link SBMLDocument} read. */ public"; %typemap(javaimports) SBMLWriter " /** * Methods for writing SBML to files and text strings. *

* The {@link SBMLWriter} class is the converse of {@link SBMLReader}, and provides the * main interface for serializing SBML models into XML and writing the * result to files and text strings. The methods for writing SBML all take * an {@link SBMLDocument} object and a destination. They return a boolean value * to indicate success or failure. */ " %javamethodmodifiers SBMLWriter::SBMLWriter " /** * Creates a new {@link SBMLWriter}. */ public"; %javamethodmodifiers SBMLWriter::setProgramName(const std::string& name) " /** * Sets the name of this program, i.e., the program that is about to * write out the {@link SBMLDocument}. *

* If the program name and version are set (setProgramVersion()), the * following XML comment, intended for human consumption, will be written * at the beginning of the document: *

   <!-- Created by <program name> version <program version>
   on yyyy-MM-dd HH:mm with libsbml version <libsbml version>. -->

* @param name the name of this program (where \'this program\' refers to * program in which libSBML is embedded, not libSBML itself!) *

* @see #setProgramVersion(String version) */ public"; %javamethodmodifiers SBMLWriter::setProgramVersion(const std::string& version) " /** * Sets the version of this program, i.e., the program that is about to * write out the {@link SBMLDocument}. *

* If the program version and name are set (setProgramName()), the * following XML comment, intended for human consumption, will be written * at the beginning of the document: *

   <!-- Created by <program name> version <program version>
   on yyyy-MM-dd HH:mm with libsbml version <libsbml version>. -->

* @param version the version of this program (where \'this program\' * refers to program in which libSBML is embedded, not libSBML itself!) *

* @see #setProgramName(String name) */ public"; %javamethodmodifiers SBMLWriter::writeSBML(const SBMLDocument* d, const std::string& filename) " /** * Writes the given SBML document to filename. *

* If the given filename ends with the suffix \'.gz\' (for example, * \'myfile.xml.gz\'), libSBML assumes the caller wants the file to be * written compressed in gzip. Similarly, if the given filename ends * with \'.zip\' or \'.bz2\', libSBML assumes the caller wants the file * to be compressed in zip or bzip2 format (respectively). Files * whose names lack these suffixes will be written uncompressed. * Special considerations for the zip format: If the given * filename ends with \'.zip\', the file placed in the zip archive will * have the suffix \'.xml\' or \'.sbml\'. For example, the file in * the zip archive will be named \'test.xml\' if the given filename is * \'test.xml.zip\' or \'test.zip\'. Similarly, the filename in the * archive will be \'test.sbml\' if the given filename is * \'test.sbml.zip\'. *

* @note To write a gzip/zip file, libSBML needs to be configured and * linked with the zlib library at * compile time. It also needs to be linked with the bzip2 library to write files in bzip2 format. (Both * of these are the default configurations for libSBML.) Errors about * unreadable files will be logged and this method will return false * if a compressed filename is given and libSBML was not linked with * the corresponding required library. *

* @note SBMLReader.hasZlib() and SBMLReader.hasBzip2() can be used to * check whether libSBML has been linked with each library. *

* @param d the SBML document to be written *

* @param filename the name or full pathname of the file where the SBML * is to be written. *

* @return true on success and false if the filename could not be * opened for writing. */ public"; %javamethodmodifiers SBMLWriter::writeSBML(const SBMLDocument* d, std::ostream& stream) " /** * Writes the given SBML document to the output stream. *

* @param d the SBML document to be written *

* @param stream the stream object where the SBML is to be written. *

* @return true on success and false if one of the underlying * parser components fail (rare). */ public"; %javamethodmodifiers SBMLWriter::writeToString(const SBMLDocument* d) " /** * Writes the given SBML document to an in-memory string and returns a * pointer to it. *

* The string is owned by the caller and should be freed (with free()) * when no longer needed. *

* @param d the SBML document to be written *

* @return the string on success and 0 if one of the underlying parser * components fail. */ public"; %javamethodmodifiers SBMLWriter::hasZlib " /** * Predicate returning true or false depending on whether * underlying libSBML is linked with zlib. *

* LibSBML supports reading and writing files compressed with either * bzip2 or zip/gzip compression. The facility depends on libSBML having * been compiled with the necessary support libraries. This method * allows a calling program to inquire whether that is the case for the * copy of libSBML it is running. *

* @return true if libSBML is linked with zlib, false otherwise. */ public"; %javamethodmodifiers SBMLWriter::hasBzip2 " /** * Predicate returning true or false depending on whether * underlying libSBML is linked with bzip2. *

* @return true if libSBML is linked with bzip2, false otherwise. */ public"; %javamethodmodifiers SBMLWriter::hasBzip2 " /** * Predicate returning true or false depending on whether * underlying libSBML is linked with bzip2. *

* @return true if libSBML is linked with bzip2, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLWriter::hasBzip2 " /** * Predicate returning true or false depending on whether * underlying libSBML is linked with bzip2. *

* @return true if libSBML is linked with bzip2, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers writeSBML(const SBMLDocument_t *d, const char *filename) " /** * Writes the given SBML document to filename. This convenience function * is functionally equivalent to: *

* SBMLWriter_writeSBML(SBMLWriter_create(), d, filename); *

* @return non-zero on success and zero if the filename could not be opened * for writing. */ public"; %javamethodmodifiers writeSBMLToString(const SBMLDocument_t *d) " /** * Writes the given SBML document to an in-memory string and returns a * pointer to it. The string is owned by the caller and should be freed * (with free()) when no longer needed. This convenience function is * functionally equivalent to: *

* SBMLWriter_writeSBMLToString(SBMLWriter_create(), d); *

* @return the string on success and NULL if one of the underlying parser * components fail (rare). */ public"; %javamethodmodifiers SBMLTypeCode_toString(SBMLTypeCode_t tc) " /** * This method takes an SBML type code and returns a string representing * the code. *

* LibSBML attaches an * identifying code to every kind of SBML object. These are known as * SBML type codes. In other languages, the set of type codes * is stored in an enumeration; in the Java language interface for * libSBML, the type codes are defined as static integer constants in * interface class {@link libsbmlConstants}. The names of the type codes * all begin with the characters SBML_. * This method takes a type code as argument, and returns a string name * corresponding to that code. For example, passing it the type code * SBML_COMPARTMENT will return the string * \'{@link Compartment}\'. *

* @return a human readable name for the given SBMLTypeCode_t. *

* @note The caller does not own the returned string and is therefore not * allowed to modify it. */ public"; %typemap(javaimports) SBase " /** * LibSBML implementation of SBase, the base class of all SBML objects. *

* Most components in SBML are derived from a single abstract base type, * {@link SBase}. In addition to serving as the parent class for most other * classes of objects in SBML, this base type is designed to allow a * modeler or a software package to attach arbitrary information to each * major element or list in an SBML model. *

* {@link SBase} has an optional subelement called \'notes\'. It is intended to * serve 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. There are certain conditions on the XHTML content * permitted inside the \'notes\' element; these are described separately * below. *

* {@link SBase} has another optional subelement called \'annotation\'. Whereas the * \'notes\' element described above 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. The * element\'s content type is XML type any, allowing essentially * arbitrary data content. SBML places only a few restrictions on the * organization of the content; these are intended to help software tools * read and write the data as well as help reduce conflicts between * annotations added by different tools. They are described separately * below. *

* It is worth pointing out that the \'annotation\' element in the definition * of {@link SBase} exists in order that software developers may attach optional * application-specific data to the elements in an SBML model. However, it * is important that this facility not be misused. In particular, it is * critical that data essential to a model definition or that can * be encoded in existing SBML elements is not stored in * \'annotation\'. {@link Parameter} values, functional dependencies between model * elements, etc., should not be recorded as annotations. It is crucial to * keep in mind the fact that data placed in annotations can be freely * ignored by software applications. If such data affects the * interpretation of a model, then software interoperability is greatly * impeded. *

* Beginning with SBML Level 2, {@link SBase} also has an optional attribute named * \'metaid\' 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. (Importantly, this uniqueness criterion * applies across any attribute with type * XML ID, 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 XML ID.) * The \'metaid\' value serves to identify a model * component for purposes such as referencing that component from metadata * placed within \'annotation\' subelements. *

* Beginning with SBML Level 2 Version 3, {@link SBase} also has 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 {@link SBase} has * data type int, and {@link SBO} identifiers are stored simply as integers. * {@link SBO} terms are a type of optional annotation, and each different class of * SBML object derived from {@link 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 {@link SBO} and the * \'sboTerm\' attribute. *

* Finally, note that, in the list of methods on {@link SBase}, there is no public * constructor because {@link SBase} is an abstract class. The constructors reside * in the subclasses derived from {@link SBase}. *

Requirements for the content of the \'notes\' subelement

* The content of \'notes\' elements must be in XHTML 1.0 format. (Plain * HTML would not be usable because whatever appears inside the \'notes\' * element must be compatible with XML, which HTML is not, and in any case, * the requirement for using XHTML does not prevent users from entering * plain-text content ,which they can do using the standard <pre> * ... </pre> elements of [X]HTML.) *

* The XML content of a \'notes\' subelement must declare the use of the * XHTML XML namespace. This can be done in multiple ways. One way is to * place a namespace declaration for the appropriate namespace URI (which * for XHTML is \'http://www.w3.org/1999/xhtml\') on the top-level * sbml element and then reference the namespace in the * \'notes\' element content using a prefix. The following example * illustrates this approach: *

<sbml xmlns=\'http://www.sbml.org/sbml/level2/version4\' level=\'2\' version=\'4\'
      xmlns:xhtml=\'http://www.w3.org/1999/xhtml\'>
  ...
  <notes>
    <xhtml:body>
      <xhtml:center><xhtml:h2>A Simple Mitotic Oscillator</xhtml:h2></xhtml:center>
      <xhtml:p>A minimal cascade model for the mitotic oscillator
      involving cyclin and cdc2 kinase</xhtml:p>
    </xhtml:body>
  </notes>
  ...

* Another approach is to declare the XHTML namespace within the \'notes\' * element content itself, as in the following example: *

...
<notes>
  <body xmlns=\'http://www.w3.org/1999/xhtml\'>

    <center><h2>A Simple Mitotic Oscillator</h2></center>

    A minimal cascade model for the mitotic oscillator
    involving cyclin and cdc2 kinase</p>

  </body>
</notes>
...

* The xmlns=\'http://www.w3.org/1999/xhtml\' declaration on * body as shown above changes the default XML namespace within it, such * that all of its content is by default in the XHTML namespace. This is a * particularly convenient approach because it obviates the need to prefix * every element with a namespace prefix (i.e., xhtml: * in the previous case). Other approaches are also possible. *

* SBML does not require the content of the \'notes\' subelement to be any * particular XHTML element; the content can be almost any well-formed * XHTML content. SBML Level 2 Versions 2, 3 and 4 added some small * restrictions and clarifications for the allowable content in order to * promote greater interoperability between software tools. The first * restriction comes from the requirements of XML: the \'notes\' * element must not contain an XML declaration nor a DOCTYPE declaration. * That is, \'notes\' must not contain *

<?xml version=\'1.0\' encoding=\'UTF-8\'?>

* nor (where the following is only one specific example of a DOCTYPE * declaration) *

<!DOCTYPE html PUBLIC \'-//W3C//DTD XHTML 1.0 Strict//EN\'
      \'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\'>

* The second restriction is intended to balance freedom of content with * the complexity of implementing software that can interpret the content. * The content of the \'notes\' subelement in SBML can consist only of the * following possibilities: *

A complete XHTML document (minus the XML and DOCTYPE declarations, * of course), that is, XHTML content beginning with the html tag. *
```
<notes>
  <html xmlns=\'http://www.w3.org/1999/xhtml\'>
     ...
  </html>
</notes>
```
*
*

The body element from an XHTML document. The following is an * example skeleton: *

<notes>
    <body xmlns=\'http://www.w3.org/1999/xhtml\'>
      ...
    </body>
</notes>

Any XHTML content that would be permitted within a body element. * If this consists of multiple elements, each one must declare the XML * namespace separately. The following is an example fragment: *
```
<notes>
    <p xmlns=\'http://www.w3.org/1999/xhtml\'>
      ...
    </p>
    <p xmlns=\'http://www.w3.org/1999/xhtml\'>
      ...
    </p>
</notes>
```
*

* Another way to summarize the restrictions above is simply to say that * the content of an SBML \'notes\' element can be only be a complete html * element, a body element, or whatever is permitted inside a body * element. In practice, this does not limit in any meaningful way what * can be placed inside a \'notes\' element; for example, if an application * or modeler wants to put a complete XHTML page, including a head * element, it can be done by putting in everything starting with the * html container. However, the restrictions above do make it somewhat * simpler to write software that can read and write the \'notes\' content. *

Requirements for the content of the \'annotation\' subelement

* At the outset, software developers should keep in mind that multiple * software tools may attempt to read and write annotation content. To * reduce the potential for collisions between annotations written by * different applications, SBML Level 2 stipulates that tools must use XML * namespaces to specify the intended vocabulary of every annotation. The * application\'s developers must choose a URI (Universal Resource * Identifier) reference that uniquely identifies the vocabulary the * application will use, and a prefix string for the annotations. *

* A important requirement is that application-specific annotation data is * entirely contained inside a single top-level element within the * SBML \'annotation\' subelement. SBML Level 2 Versions 2, 3 and 4 place the * following restrictions on annotations: *

Within a given SBML \'annotation\' element, there can only be one * top-level element using a given namespace. An annotation element can * contain multiple top-level elements but each must be in a different * namespace. *
*
No top-level element in an \'annotation\' may use an SBML XML * namespace, either explicitly by referencing one of the SBML XML * namespace URIs or implicitly by failing to specify any namespace on the * annotation. *
*
The ordering of top-level elements within a given \'annotation\' * element is not significant. An application should not expect * that its annotation content appears first in the \'annotation\' element, * nor in any other particular location. Moreover, the ordering of * top-level annotation elements may be changed by different applications * as they read and write the same SBML file. *

* The use of XML namespaces in this manner is intended to improve the * ability of multiple applications to place annotations on SBML model * elements with reduced risks of interference or name collisions. * Annotations stored by different simulation packages can therefore * coexist in the same model definition. The rules governing the content * of \'annotation\' elements are designed to enable applications to easily * add, change, and remove their annotations from SBML elements while * simultaneously preserving annotations inserted by other applications * when mapping SBML from input to output. *

* As a further simplification for developers of software and to improve * software interoperability, applications are only required to preserve * other annotations (i.e., annotations they do not recognize) when those * annotations are self-contained entirely within \'annotation\', complete * with namespace declarations. The following is an example: *

<annotation>
    <topLevelElement xmlns:\'URI\'>
       ... content in the namespace identified by \'URI\' ...
    </topLevelElement>
</annotation>

* Some more examples hopefully will make these points more clear. The * next example is invalid because it contains a top-level element in the * SBML XML namespace—this happens because no namespace is declared * for the <cytoplasm> element, which means by default it * falls into the enclosing SBML namespace: *

<annotation>
    <cytoplasm/>
</annotation>

* The following example is also invalid, this time because it contains two * top-level elements using the same XML namespace. Note that it does not * matter that these are two different top-level elements * (<nodecolors> and <textcolors>); * what matters is that these separate elements are both in the same * namespace rather than having been collected and placed inside one * overall container element for that namespace. *

<annotation>
    <mysim:nodecolors xmlns:mysim=\'http://www.mysim.org/ns\'
        mysim:bgcolor=\'green\' mysim:fgcolor=\'white\'/>
    <mysim:textcolors xmlns:mysim=\'http://www.mysim.org/ns\'
        mysim:bgcolor=\'green\' mysim:fgcolor=\'white\'/>
</annotation>

* On the other hand, the following example is valid: *

<annotation>
    <mysim:geometry xmlns:mysim=\'http://www.mysim.org/ns\'
             mysim:bgcolor=\'green\' mysim:fgcolor=\'white\'>
        <graph:node xmlns:graph=\'http://www.graph.org/ns\' 
             graph:x=\'4\' graph:y=\'5\' />
    </mysim:geometry>
    <othersim:icon xmlns:othersim=\'http://www.othersim.com/\'>
        WS2002
    </othersim:icon>
</annotation>

* It is worth keeping in mind that although XML namespace names must be * URIs, they are (like all XML namespace names) not required to * be directly usable in the sense of identifying an actual, retrieval * document or resource on the Internet. URIs such as * \'http://www.mysim.org/\' may appear as though they are * (e.g.) Internet addresses, but there are not the same thing. This * style of URI strings, using a domain name and other parts, is only a * simple and commonly-used way of creating a unique name string. *

Standard format for annotations linking data resources

* SBML Level 2 Versions 2, 3 and 4 define a proposed regular format for * encoding two particular categories of annotations: (a) references to * controlled vocabulary terms and database identifiers which define and * describe biological and biochemical entities in a model; and (b) * descriptions of the provenance of a model, including its author(s) and * modification history. */ " %javamethodmodifiers SBase::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link SBase}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers SBase::clone() const " /** * Creates and returns a deep copy of this {@link SBase} object. *

* @return a (deep) copy of this {@link SBase} object */ public"; %javamethodmodifiers SBase::getMetaId() const " /** * 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. (Importantly, this uniqueness criterion * applies across any attribute with type XML ID, 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 XML ID.) * The \'metaid\' value serves to identify a model * component for purposes such as referencing that component from * metadata placed within \'annotation\' subelements. *

* @return the metaid of this SBML object. *

* @see #isSetMetaId() * @see #setMetaId(String metaid) */ public"; %javamethodmodifiers SBase::getMetaId " /** * Returns the value of the \'metaid\' attribute of this object. *

* @return the metaid of this SBML object. *

* @see #isSetMetaId() * @see #setMetaId(String metaid) */ public"; %javamethodmodifiers SBase::getId() const " /** * Returns the value of the \'id\' attribute of this object, if it has one. *

* 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. The * data type of \'id\' is always either Sid or * UnitSId, depending on the object in question. Both * data types are defined as follows: *

   *   letter .= \'a\'..\'z\',\'A\'..\'Z\'
   *   digit  .= \'0\'..\'9\'
   *   idChar .= letter | digit | \'_\'
   *   SId    .= ( letter | \'_\' ) idChar

* The equality of SId and UnitSId type values * in SBML is determined by an exact character sequence match; i.e., * comparisons of these identifiers must be performed in a case-sensitive * manner. This applies to all uses of SId and * UnitSId. *

* @return the id of this SBML object. *

* @note The fact that the value of attribute \'id\' is defined on the * {@link SBase} parent class object is a convenience provided by libSBML, and * does not strictly follow SBML specifications. This libSBML * implementation of {@link SBase} allows client applications to use more * generalized code in some situations (for instance, when manipulating * objects that are all known to have identifiers), but beware that not * all SBML object classes provide an \'id\' attribute. LibSBML will allow * the identifier to be set, but it will not read nor write \'id\' * attributes for objects that do not possess them according to the SBML * specification for the Level and Version in use. *

* @see #setId(String sid) * @see #isSetId() * @see #unsetId() */ public"; %javamethodmodifiers SBase::getName() const " /** * Returns the value of the \'name\' attribute of this object, if it has one. *

* Most (but not all) objects in SBML include two common attributes: \'id\' * and \'name\'. In contrast to the \'id\' attribute, the \'name\' attribute is * optional and is not intended to be used for cross-referencing purposes * within a model. Its purpose instead is to provide a human-readable * label for the component. The data type of \'name\' is the type * string defined in XML Schema. SBML imposes no * restrictions as to the content of \'name\' attributes beyond those * restrictions defined by the string type in XML Schema. *

* The recommended practice for handling \'name\' is as follows. If a * software tool has the capability for displaying the content of \'name\' * attributes, it should display this content to the user as a * component\'s label instead of the component\'s \'id\'. If the user * interface does not have this capability (e.g., because it cannot * display or use special characters in symbol names), or if the \'name\' * attribute is missing on a given component, then the user interface * should display the value of the \'id\' attribute instead. (Script * language interpreters are especially likely to display \'id\' instead of * \'name\'.) *

* As a consequence of the above, authors of systems that automatically * generate the values of \'id\' attributes should be aware some systems * may display the \'id\'\'s to the user. Authors therefore may wish to * take some care to have their software create \'id\' values that are: (a) * reasonably easy for humans to type and read; and (b) likely to be * meaningful, for example by making the \'id\' attribute be an abbreviated * form of the name attribute value. *

* An additional point worth mentioning is although there are * restrictions on the uniqueness of \'id\' values, there are no * restrictions on the uniqueness of \'name\' values in a model. This * allows software packages leeway in assigning component identifiers. *

* @return the name of this SBML object. *

* @note The fact that the \'name\' attribute is defined on the {@link SBase} parent * class object is a convenience provided by libSBML, and does not * strictly follow SBML specifications. This libSBML implementation * of {@link SBase} allows client applications to use more generalized code in * some situations (for instance, when manipulating objects that are all * known to have identifiers), but beware that not all SBML object * classes provide an \'id\' attribute. LibSBML will allow the identifier * to be set, but it will not read nor write \'id\' attributes for objects * that do not possess them according to the SBML specification for the * Level and Version in use. *

* @see #isSetName() * @see #setName(String name) * @see #unsetName() */ public"; %javamethodmodifiers SBase::getNotes " /** * Returns the content of the \'notes\' subelement of this object as * a tree of XML nodes. *

* The optional 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 * {@link 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. The SBML * Level 2 specification has considerable detail about how * \'notes\' element content must be handled; please refer to the * specifications. *

* 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 {@link XMLNode} and related * objects. *

* @return the content of the \'notes\' subelement of this SBML object. *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::getNotesString " /** * Returns the content of the \'notes\' subelement of this object as a * string. *

* @return the content of the \'notes\' subelement of this SBML object. *

* @see #getNotes() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::getAnnotation " /** * Returns the content of the \'annotation\' subelement of this object as * an XML node tree. *

* Whereas the {@link 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 {@link 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 {@link ModelHistory}, {@link CVTerm} and RDFAnnotationParser classes * for more information about the facilities available. *

* @return the annotation of this SBML object as an {@link XMLNode} *

* @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::getAnnotationString " /** * Returns the content of the \'annotation\' subelement of this object as a * character string. *

* The annotations returned by this method will be in string form. *

* @return the annotation string of this SBML object. *

* @see #getAnnotation() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::getNamespaces() const " /** * Returns a list of the XML Namespaces declared on this SBML document. *

* @return the XML Namespaces associated with this SBML object */ public"; %javamethodmodifiers SBase::getSBMLDocument() const " /** * Returns the parent {@link SBMLDocument} object. *

* LibSBML uses the class {@link 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 * {@link SBMLDocument} object. {@link SBMLDocument} corresponds roughly to the class * Sbml defined in the SBML Level 2 specification, 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 or * Level 2.) *

* This method allows the {@link SBMLDocument} for the current object to be * retrieved. *

* @return the parent {@link SBMLDocument} object of this SBML object. */ public"; %javamethodmodifiers SBase::getSBMLDocument " /** * Returns the parent {@link SBMLDocument} object. *

* This method allows the {@link SBMLDocument} for the current object to be * retrieved. *

* @return the parent {@link SBMLDocument} object of this SBML object. */ public"; %javamethodmodifiers SBase::getParentSBMLObject " /** * Returns the parent SBML object. *

* This method is convenient when holding an object nested inside * other objects in an SBML model. It allows direct access to the * <model> element containing it. *

* @return the parent SBML object of this SBML object. */ public"; %javamethodmodifiers SBase::getAncestorOfType(SBMLTypeCode_t type) " /** * Returns the ancestor SBML object that corresponds to the * given SBMLTypeCode_t. *

* This function allows any object to determine its exact * location/function within a model. For example a {@link StoichiometryMath} * object has ancestors of type {@link SpeciesReference}, * ListOfProducts/ListOfReactants/ListOfModifiers, {@link Reaction}, * {@link ListOfReactions} and {@link Model}; any of which can be accessed via this * function. *

* @param type the SBMLTypeCode_t of the ancestor to be returned. *

* @return the ancestor SBML object of this SBML object, that * corresponds to the given SBMLTypeCode_t, NULL if none exists. */ public"; %javamethodmodifiers SBase::getSBOTerm() const " /** * Returns the integer portion of the value of the \'sboTerm\' attribute of * this object. *

* In SBML Level 2 Versions 2, 3 and 4, 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 * {@link SBase} has data type int, and {@link SBO} identifiers are stored simply as * integers. {@link SBO} terms are a type of optional annotation, and each * different class of SBML object derived from {@link 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 {@link SBO} and the \'sboTerm\' attribute. *

* @return the value of the \'sboTerm\' attribute as an integer, or -1 * if the value is not set. */ public"; %javamethodmodifiers SBase::getSBOTermID() const " /** * Returns the string representation of the \'sboTerm\' attribute of * this object. *

* In SBML Level 2 Versions 2, 3 and 4, 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 * {@link SBase} has data type int, and {@link SBO} identifiers are stored simply as * integers. This function recreates the string representation from the * stored value. {@link SBO} terms are a type of optional annotation, and each * different class of SBML object derived from {@link 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 {@link SBO} and the \'sboTerm\' attribute. *

* @return the value of the \'sboTerm\' attribute as a string of the form * SBO:NNNNNNN, or an empty string * if the value is not set. */ public"; %javamethodmodifiers SBase::getLine() const " /** * Returns the line number on which this object first appears in the XML * representation of the SBML document. *

* @return the line number of this SBML object. *

* @see #getColumn() */ public"; %javamethodmodifiers SBase::getColumn() const " /** * Returns the column number on which this object first appears in the XML * representation of the SBML document. *

* @return the column number of this SBML object. *

* @see #getLine() */ public"; %javamethodmodifiers SBase::isSetMetaId() const " /** * Predicate returning true or false depending on whether this * object\'s \'metaid\' attribute has been set. *

* Some words of explanation about the set/unset/isSet methods: SBML Levels 1 and 2 define certain attributes on some classes of objects as optional. This requires an application to be careful about the distinction between two cases: (1) a given attribute has never been set to a value, and therefore should be assumed to have the SBML-defined default value, and (2) a given attribute has been set to a value, but the value happens to be an empty string. LibSBML supports these distinctions by providing methods to set, unset, and query the status of attributes that are optional. The methods have names of the form setAttribute(...), unsetAttribute(), and isSetAttribute(), where Attribute is the the name of the optional attribute in question. *

* @return true if the \'metaid\' attribute of this SBML object has been * set, false otherwise. *

* @see #getMetaId() * @see #setMetaId(String metaid) */ public"; %javamethodmodifiers SBase::isSetId() const " /** * Predicate returning true or false depending on whether this * object\'s \'id\' attribute has been set. *

   *   letter .= \'a\'..\'z\',\'A\'..\'Z\'
   *   digit  .= \'0\'..\'9\'
   *   idChar .= letter | digit | \'_\'
   *   SId    .= ( letter | \'_\' ) idChar

* @return true if the \'id\' attribute of this SBML object has been * set, false otherwise. *

* @see #getId() * @see #setId(String sid) * @see #unsetId() */ public"; %javamethodmodifiers SBase::isSetName() const " /** * Predicate returning true or false depending on whether this * object\'s \'name\' attribute has been set. *

* @return true if the \'name\' attribute of this SBML object has been * set, false otherwise. *

* @see #getName() * @see #setName(String name) * @see #unsetName() */ public"; %javamethodmodifiers SBase::isSetNotes() const " /** * Predicate returning true or false depending on whether this * object\'s \'notes\' subelement exists and has content. *

* @return true if a \'notes\' subelement exists, false otherwise. *

* @see #getNotes() * @see #getNotesString() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::isSetAnnotation() const " /** * Predicate returning true or false depending on whether this * object\'s \'annotation\' subelement exists and has content. *

* @return true if a \'annotation\' subelement exists, false * otherwise. *

* @see #getAnnotation() * @see #getAnnotationString() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::isSetSBOTerm() const " /** * Predicate returning true or false depending on whether this * object\'s \'sboTerm\' attribute has been set. *

* @return true if the \'sboTerm\' attribute of this SBML object has been * set, false otherwise. */ public"; %javamethodmodifiers SBase::setMetaId(const std::string& metaid) " /** * Sets the value of the \'metaid\' attribute of this object. *

* The string metaid is copied. The value of metaid must be an * identifier conforming to the syntax defined by the XML 1.0 data type * ID. Among other * things, this type requires that a value is unique among all the values * of type XML ID in an {@link SBMLDocument}. Although SBML only uses XML ID for the \'metaid\' * attribute, callers 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. *

* @param metaid the identifier string to use as the value of the * \'metaid\' attribute *

* @see #getMetaId() * @see #isSetMetaId() */ public"; %javamethodmodifiers SBase::setId(const std::string& sid) " /** * Sets the value of the \'id\' attribute of this SBML object to a copy * of id. *

* The string sid is copied. Note that SBML has strict requirements * for the syntax of identifiers. The following is summary of the * definition of the SBML identifier type SId (here expressed in an * extended form of BNF notation): *

   *   letter .= \'a\'..\'z\',\'A\'..\'Z\'
   *   digit  .= \'0\'..\'9\'
   *   idChar .= letter | digit | \'_\'
   *   SId    .= ( letter | \'_\' ) idChar

* 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 formulations. *

* @param sid the string to use as the identifier of this object *

* @see #isSetId() * @see #getId() * @see #unsetId() */ public"; %javamethodmodifiers SBase::setName(const std::string& name) " /** * Sets the value of the \'name\' attribute of this SBML object to a copy * of name. *

* @param name the new name for the object; the string will be copied *

* @see #getName() * @see #isSetName() * @see #unsetName() */ public"; %javamethodmodifiers SBase::setAnnotation(const XMLNode* annotation) " /** * Resets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation. *

* 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 {@link SBase#appendAnnotation(XMLNode annotation)} or * {@link SBase#appendAnnotation(String annotation)}. *

* @param annotation an XML structure that is to be used as the new content * of the \'annotation\' subelement of this object *

* @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::setAnnotation(const std::string& annotation) " /** * Sets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation given as a character string. *

* @param annotation an XML string that is to be used as the content * of the \'annotation\' subelement of this object *

* @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::appendAnnotation(const XMLNode* annotation) " /** * Appends the annotation content given by annotation to any existing * content in the \'annotation\' subelement of this object. *

* Unlike {@link SBase#setAnnotation(XMLNode annotation)} or * {@link SBase#setAnnotation(String annotation)}, this method * allows other annotations to be preserved when an application adds its * own data. *

* @param annotation an XML structure that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(String annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::appendAnnotation(const std::string& annotation) " /** * Appends the annotation content given by annotation to any existing * content in the \'annotation\' subelement of this object. *

* @param annotation an XML string that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #unsetAnnotation() */ public"; %javamethodmodifiers SBase::setNotes(const XMLNode* notes) " /** * Sets the value of the \'notes\' subelement of this SBML object to a copy * of the XML structure given by notes. *

* Any existing content of the \'notes\' subelement is discarded. *

* @param notes an XML structure that is to be used as the content of the * \'notes\' subelement of this object *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::setNotes(const std::string& notes) " /** * Sets the value of the \'notes\' subelement of this SBML object to a copy * of the string notes. *

* Any existing content of the \'notes\' subelement is discarded. *

* @param notes an XML string that is to be used as the content of the * \'notes\' subelement of this object *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::appendNotes(const XMLNode* notes) " /** * Appends notes content to the \'notes\' element attached to this * object. *

* The content in notes is copied. *

* @param notes an XML node structure that is to appended to the content * of the \'notes\' subelement of this object *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(String notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::appendNotes(const std::string& notes) " /** * Appends notes content to the \'notes\' element attached to this * object. *

* The content in notes is copied. *

* @param notes an XML string that is to appended to the content of * the \'notes\' subelement of this object *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #unsetNotes() */ public"; %javamethodmodifiers SBase::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::setSBOTerm(int value) " /** * Sets the value of the \'sboTerm\' attribute. *

* In SBML Level 2 Versions 2, 3 and 4, the data type of the SBML \'sboTerm\' * 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 {@link SBase} has data type int, and {@link SBO} identifiers * are stored simply as integers. {@link SBO} terms are a type of optional * annotation, and each different class of SBML object derived from {@link 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 {@link SBO} and the \'sboTerm\' attribute. *

* @param value the NNNNNNN integer portion of the {@link SBO} identifier */ public"; %javamethodmodifiers SBase::setNamespaces(XMLNamespaces* xmlns) " /** * Sets the namespaces relevant of this SBML object. *

* @param xmlns the namespaces to set */ public"; %javamethodmodifiers SBase::unsetMetaId " /** * Unsets the value of the \'metaid\' attribute of this SBML object. *

   *   letter .= \'a\'..\'z\',\'A\'..\'Z\'
   *   digit  .= \'0\'..\'9\'
   *   idChar .= letter | digit | \'_\'
   *   SId    .= ( letter | \'_\' ) idChar

* @see #setId(String sid) * @see #getId() * @see #isSetId() */ public"; %javamethodmodifiers SBase::unsetName " /** * Unsets the value of the \'name\' attribute of this SBML object. *

* @see #isSetName() * @see #setName(String name) * @see #getName() */ public"; %javamethodmodifiers SBase::unsetNotes " /** * Unsets the value of the \'notes\' subelement of this SBML object. *

* @see #getNotesString() * @see #isSetNotes() * @see #setNotes(XMLNode notes) * @see #setNotes(String notes) * @see #appendNotes(XMLNode notes) * @see #appendNotes(String notes) */ public"; %javamethodmodifiers SBase::unsetAnnotation " /** * Unsets the value of the \'annotation\' subelement of this SBML object. *

* @see #getAnnotation() * @see #getAnnotationString() * @see #isSetAnnotation() * @see #setAnnotation(XMLNode annotation) * @see #setAnnotation(String annotation) * @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) */ public"; %javamethodmodifiers SBase::unsetSBOTerm " /** * Unsets the value of the \'sboTerm\' attribute of this SBML object. *

* @param term the {@link CVTerm} to assign *

* @note Since the CV Term uses the metaid of the object as a * reference, if the object has no metaid set the {@link CVTerm} will * not be added. *

* @warning 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 in this object. Changes * made to the original object instance (such as resetting attribute * values) will not affect the instance added here. 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. */ public"; %javamethodmodifiers SBase::getCVTerms " /** * Returns a list of {@link CVTerm} objects in the annotations of this SBML * object. *

* @return the list of CVTerms for this SBML object. */ public"; %javamethodmodifiers SBase::getCVTerms() const " /** * Returns a list of {@link CVTerm} objects in the annotations of this SBML * object. *

* @return the list of CVTerms for this SBML object. */ public"; %javamethodmodifiers SBase::getNumCVTerms " /** * Returns the number of {@link CVTerm} objects in the annotations of this SBML * object. *

* @return the number of CVTerms for this SBML object. */ public"; %javamethodmodifiers SBase::getCVTerm(unsigned int n) " /** * Returns the nth {@link CVTerm} in the list of CVTerms of this SBML * object. *

* @param n long the index of the {@link CVTerm} to retrieve *

* @return the nth {@link CVTerm} in the list of CVTerms for this SBML object. */ public"; %javamethodmodifiers SBase::unsetCVTerms " /** * Clears the list of CVTerms of this SBML * object. */ public"; %javamethodmodifiers SBase::getResourceBiologicalQualifier(std::string resource) " /** * Returns the BiologicalQualifier associated with this resource, * or BQB_UNKNOWN if the resource does not exist. *

* @param resource string representing the resource; e.g., * \'http://www.geneontology.org/#GO:0005892\' *

* @return the #BiolQualifierType_t value associated with the resource */ public"; %javamethodmodifiers SBase::getResourceModelQualifier(std::string resource) " /** * Returns the ModelQualifier associated with this resource, * or BQM_UNKNOWN if the resource does not exist. *

* @param resource string representing the resource; e.g., * \'http://www.geneontology.org/#GO:0005892\' *

* @return the #ModelQualifierType_t value associated with the resource */ public"; %javamethodmodifiers SBase::getModel() const " /** * Returns the {@link Model} object in which the current object is located. *

* @return the parent {@link Model} of this SBML object. */ public"; %javamethodmodifiers SBase::getLevel() const " /** * Returns the SBML Level of the overall SBML document. *

* @return the SBML level of this SBML object. *

* @see #getVersion() */ public"; %javamethodmodifiers SBase::getVersion() const " /** * Returns the Version within the SBML Level of the overall SBML document. *

* @return the SBML version of this SBML object. *

* @see #getLevel() */ public"; %javamethodmodifiers SBase::getTypeCode() const " /** * Returns the libSBML type code for this object. *

* This method MAY return the typecode of this SBML object or it MAY * return SBML_UNKNOWN. That is, subclasses of {@link SBase} are not required to * implement this method to return a typecode. This method is meant * primarily for the LibSBML C interface where class and subclass * information is not readily available. *

* @return the #SBMLTypeCode_t value of this SBML object or SBML_UNKNOWN * (default). *

* @see #getElementName() */ public"; %javamethodmodifiers SBase::getElementName() const " /** * Returns the XML element name of this object. *

* This is overridden by subclasses to return a string appropriate to the * SBML component. For example, {@link Model} defines it as returning \'model\', * {@link CompartmentType} defines it as returning \'compartmentType\', etc. */ public"; %javamethodmodifiers SBase::toSBML " /** * Returns a string that consists of the partial SBML describing this * object. This is primarily provided for testing and debugging * purposes. It may be removed in a future version of libSBML. *

* @return the partial SBML that describes this SBML object. */ public"; %javamethodmodifiers SBase::read(XMLInputStream& stream) " /** * Reads (initializes) this SBML object by reading from XMLInputStream.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::write(XMLOutputStream& stream) const " /** * Writes (serializes) this SBML object by writing it to XMLOutputStream.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well. For example: *

* {@link SBase#writeElements(stream)}; * mReactans.write(stream); * mProducts.write(stream); * ...

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::removeDuplicateAnnotations " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well. For example: *

* {@link SBase#writeElements(stream)}; * mReactans.write(stream); * mProducts.write(stream); * ...

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::SBase(const std::string& id = "", const std::string& name = "", int sboTerm = -1) " /** * Only subclasses may create {@link SBase} objects. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::SBase(int sboTerm) " /** * Creates a new {@link SBase} object with the given sboTerm. * Only subclasses may create {@link SBase} objects.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::SBase(const SBase& orig) " /** * Copy constructor. Creates a copy of this {@link SBase} object.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::createObject(XMLInputStream& stream) " /** * Subclasses should override this method to create, store, and then * return an SBML object corresponding to the next {@link XMLToken} in the * XMLInputStream. *

* @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::getElementPosition() const " /** * The SBML XML Schema is written such that the order of child elements * is significant. LibSBML can read elements out of order. If you * override this method to indicate the ordinal position of element with * respect to its siblings, libSBML will log an error if the element is * read out of order. *

* @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::getErrorLog " /** * @return the {@link SBMLErrorLog} used to log errors during while reading and * validating SBML.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::logError( unsigned int id , const unsigned int level = 2 , const unsigned int version = 3 , const std::string& details = "" ) " /** * Convenience method for easily logging problems from within method * implementations. *

* This is essentially a short form of getErrorLog()->logError(...) *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::logUnknownAttribute( std::string attribute, const unsigned int level, const unsigned int version, const std::string element ) " /** * Helper to log a common type of error.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::logUnknownElement( const std::string element, const unsigned int level, const unsigned int version ) " /** * Helper to log a common type of error.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::logEmptyString( std::string attribute, const unsigned int level, const unsigned int version, std::string element) " /** * Helper to log a common type of error.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well. For example: *

* {@link SBase#writeAttributes(stream)}; * stream.writeAttribute( \'id\' , mId ); * stream.writeAttribute( \'name\', mName ); * ...

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::syncAnnotation " /** * Synchronizes the annotation of this SBML object. *

* Annotation element (XMLNode mAnnotation) is synchronized with the * current {@link CVTerm} objects (List mCVTerm). * Currently, this method is called in getAnnotation, isSetAnnotation, * and writeElements methods. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkOrderAndLogError(SBase* object, int expected) " /** * Checks that SBML element has been read in the proper order. If object * is not in the expected position, an error is logged.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkListOfPopulated(SBase* object) " /** * Checks that an SBML {@link ListOf} element has been populated. * If a listOf element has been declared with no elements, * an error is logged.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkMetaIdSyntax " /** * Checks the syntax of a metaid attribute. *

* If the syntax of the metaid attribute of this object is incorrect, * this method logs an error in the {@link SBMLDocument}\'s error log.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkIdSyntax " /** * Checks the syntax of the id attribute. * The syntax of an id is of type SId which is defined as: *

* - letter .= \'a\'..\'z\',\'A\'..\'Z\' * - digit .= \'0\'..\'9\' * - idChar .= letter | digit | \'_\' * - SId .= ( letter | \'_\' ) idChar* *

* If the syntax of the id attribute of this object is incorrect, * an error is logged

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkUnitSyntax(unsigned int flag = 0) " /** * Checks the syntax of the unit attribute. * The syntax of an unit is of type UnitSId which is defined as: *

* - letter .= \'a\'..\'z\',\'A\'..\'Z\' * - digit .= \'0\'..\'9\' * - idChar .= letter | digit | \'_\' * - UnitSId .= ( letter | \'_\' ) idChar* *

* If the syntax of the unit attribute of this object is incorrect, * an error is logged *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkAnnotation " /** * Checks the annotation does not declare an sbml namespace. * If the annotation declares an sbml namespace an error is logged.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::checkXHTML(const XMLNode *) " /** * Checks that the XHTML is valid. * If the xhtml does not conform to the specification of valid xhtml within * an sbml document, an error is logged.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::isUnicodeLetter(std::string::iterator, unsigned int) " /** * Checks if a character is part of the Unicode Letter set. * @return true if the character is a part of the set, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::isUnicodeDigit(std::string::iterator, unsigned int) " /** * Checks if a character is part of the Unicode Digit set. * @return true if the character is a part of the set, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::isCombiningChar(std::string::iterator, unsigned int) " /** * Checks if a character is part of the Unicode CombiningChar set. * @return true if the character is a part of the set, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::isExtender(std::string::iterator, unsigned int) " /** * Checks if a character is part of the Unicode Extender set. * @return true if the character is a part of the set, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::setSBaseFields(const XMLToken& element) " /** * Stores the location (line and column) and any XML namespaces (for * roundtripping) declared on this SBML (XML) element.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::readAnnotation(XMLInputStream& stream) " /** * @return true if read an element from the stream

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::readNotes(XMLInputStream& stream) " /** * @return true if read a element from the stream

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBase::getHasBeenDeleted " /** * @return true if read a element from the stream

* @deprecated libSBML internal */ public"; %typemap(javaimports) ListOf " /** * Parent class for the various SBML \'ListOfXYZ\' classes. *

*/ " %javamethodmodifiers ListOf::ListOf " /** * Creates a new {@link ListOf}. */ public"; %javamethodmodifiers ListOf::ListOf(const ListOf& orig) " /** * Copy constructor. Creates a copy of this {@link ListOf}. */ public"; %javamethodmodifiers ListOf::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next item in the * list. */ public"; %javamethodmodifiers ListOf::clone() const " /** * Creates and returns a deep copy of this {@link ListOf}. *

* @return a (deep) copy of this {@link ListOf}. */ public"; %javamethodmodifiers ListOf::append(const SBase* item) " /** * Adds item to the end of this {@link ListOf}. *

* This variant of the method makes a clone of the item handed to it. * This means that when the {@link ListOf} is destroyed, the original items will * not be destroyed. *

* @param item the item to be added to the list. *

* @see #appendAndOwn(SBase item) */ public"; %javamethodmodifiers ListOf::appendAndOwn(SBase* item) " /** * Adds item to the end of this {@link ListOf}. *

* This variant of the method does not clone the item handed to it; * instead, it assumes ownership of it. This means that when the {@link ListOf} * is destroyed, the item will be destroyed along with it. *

* @param item the item to be added to the list. *

* @see #append(SBase item) */ public"; %javamethodmodifiers ListOf::get " /** * Get an item from the list. *

* @param n the index number of the item to get. *

* @return the nth item in this {@link ListOf} items. *

* @see #size() */ public"; %javamethodmodifiers ListOf::get(unsigned int n) " /** * Get an item from the list. *

* @param n the index number of the item to get. *

* @return the nth item in this {@link ListOf} items. *

* @see #size() */ public"; %javamethodmodifiers ListOf::get(const std::string& sid) const " /** * Get an item from the list based on its identifier. *

* @param sid a string representing the the identifier of the item to get. *

* @return item in this {@link ListOf} items with the given id or NULL if no such * item exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOf::get(const std::string& sid) " /** * Get an item from the list based on its identifier. *

* @param sid a string representing the the identifier of the item to get. *

* @return item in this {@link ListOf} items with the given id or NULL if no such * item exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOf::clear(bool doDelete = true) " /** * Removes all items in this {@link ListOf} object. *

* If doDelete is true (default), all items in this {@link ListOf} object are deleted * and cleared, and thus the caller doesn\'t have to delete those items. * Otherwise, all items are just cleared from this {@link ListOf} object and the caller * is responsible for deleting all items (In this case, pointers to all items * should be stored elsewhere before calling this function by the caller). *

* @param doDelete if true (default), all items are deleted and cleared. * Otherwise, all items are just cleared and not deleted. */ public"; %javamethodmodifiers ListOf::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOf} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOf::remove(const std::string& sid) " /** * Removes item in this {@link ListOf} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOf::size() const " /** * Get the size of this {@link ListOf}. *

* @return the number of items in this {@link ListOf} items. */ public"; %javamethodmodifiers ListOf::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} that should become the parent of this * {@link ListOf}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOf::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOf::getTypeCode() const " /** * Returns the libSBML type code for this object, namely, * SBML_LIST_OF. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOf::getItemTypeCode() const " /** * Get the type code of the objects contained in this {@link ListOf}. *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). */ public"; %javamethodmodifiers ListOf::getElementName() const " /** * Returns the XML element name of this object, which for {@link ListOf}, is * always \'listOf\'. *

* @return the XML name of this element. */ public"; %javamethodmodifiers ListOf::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOf::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOf::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well. For example: *

* {@link SBase#writeAttributes(stream)}; * stream.writeAttribute( \'id\' , mId ); * stream.writeAttribute( \'name\', mName ); * ...

* @deprecated libSBML internal */ public"; %typemap(javaimports) Model " /** * LibSBML implementation of SBML\'s Model construct. *

* In an SBML model definition, a single object of class {@link Model} serves as * the overall container for the lists of the various model components. * All of the lists are optional, but if a given list container is present * within the model, the list must not be empty; that is, it must have * length one or more. The following are the components and lists * permitted in different Levels and Versions of SBML as of this version * of libSBML (3.3): *

In SBML Level 1, the components are: {@link UnitDefinition}, {@link Compartment}, * {@link Species}, {@link Parameter}, {@link Rule}, and {@link Reaction}. Instances of the classes are * placed inside instances of classes {@link ListOfUnitDefinitions}, * {@link ListOfCompartments}, {@link ListOfSpecies}, {@link ListOfParameters}, {@link ListOfRules}, and * {@link ListOfReactions}. *
*
In SBML Level 2 Version 1, the components are: {@link FunctionDefinition}, * {@link UnitDefinition}, {@link Compartment}, {@link Species}, {@link Parameter}, {@link Rule}, {@link Reaction} and * {@link Event}. Instances of the classes are placed inside instances of classes * {@link ListOfFunctionDefinitions}, {@link ListOfUnitDefinitions}, {@link ListOfCompartments}, * {@link ListOfSpecies}, {@link ListOfParameters}, {@link ListOfRules}, {@link ListOfReactions}, and * {@link ListOfEvents}. *
*
In SBML Level 2 Versions 2, 3 and 4, the components are: * {@link FunctionDefinition}, {@link UnitDefinition}, {@link CompartmentType}, {@link SpeciesType}, * {@link Compartment}, {@link Species}, {@link Parameter}, {@link InitialAssignment}, {@link Rule}, {@link Constraint}, * {@link Reaction} and {@link Event}. Instances of the classes are placed inside * instances of classes {@link ListOfFunctionDefinitions}, {@link ListOfUnitDefinitions}, * {@link ListOfCompartmentTypes}, {@link ListOfSpeciesTypes}, {@link ListOfCompartments}, * {@link ListOfSpecies}, {@link ListOfParameters}, {@link ListOfInitialAssignments}, {@link ListOfRules}, * {@link ListOfConstraints}, {@link ListOfReactions}, and {@link ListOfEvents}. *

* Although all the lists are optional, there are dependencies between SBML * components such that defining some components requires defining others. * An example is that defining a species requires defining a compartment, * and defining a reaction requires defining a species. The dependencies * are explained in more detail in the SBML specifications. *

Approaches to creating objects using the libSBML API

* LibSBML provides two main mechanisms for creating objects: class * constructors (e.g., {@link Species}() ), * and createObject() methods (such as * Model.createSpecies()) provided by certain object classes such as * {@link Model}. These multiple mechanisms are provided by libSBML for * flexibility and to support different use-cases, but they also have * different implications for the overall model structure. *

* In general, the recommended approach is to use the * createObject() methods. These methods both create * an object and link it to the parent in one step. Here is an * example: *

// Create an {@link SBMLDocument} object in Level 2 Version 4 format:

{@link SBMLDocument}  sbmlDoc = new {@link SBMLDocument}(2, 4);

// Create a {@link Model} object inside the {@link SBMLDocument} object and set
// its identifier.  The call returns a pointer to the {@link Model} object
// created, and methods called on that object affect the attributes
// of the object attached to the model (as expected).

{@link Model}  model = sbmlDoc->createModel();
model->setId(\'MyModel\');

// Create a {@link Species} object inside the {@link Model} and set its identifier.
// Similar to the lines above, this call returns a pointer to the {@link Species}
// object created, and methods called on that object affect the attributes
// of the object attached to the model (as expected).

{@link Species} sp = model->createSpecies();
sp->setId(\'MySpecies\');

* The createObject() methods return a pointer to the * object created, but they also add the object to the relevant list of * object instances contained in the parent. (These lists become the * <listOfObjects> elements in the finished XML * rendition of SBML.) In the example above, Model.createSpecies() adds * the created species directly to the <listOfSpecies gt; * list in the model. Subsequently, methods called on the species change * the species in the model (which is what is expected in most situations). *

* By contrast, the other main way of creating an object and adding it to a * parent makes a copy of the object, and requires more care on the * part of the caller. Here is an example of this alternative approach: *

// Create a {@link Species} object and add it to the model.
// This uses the {@link Species} class constructor:

{@link Species} newsp = {@link Species}(\'MySpecies\');
model->addSpecies(newsp); // Warning! This makes a COPY inside \'model\'.

// addSpecies(...) copies the object, with the result that
// \'newsp\' still refers to the original.  The following may not
// do what is expected:

newsp.setId(\'NewId\');    // Warning -- doesn\'t change the species in \'model\'!

// If \'newsp\' object isn\'t going to be used further, it needs
// to be deleted to avoid a memory leak.

delete newsp;

* The key point of the example above is that, because the {@link Model#addSpecies(Species s)} * call makes a copy of the object handed to it, care is needed both when * attempting to make changes to the object, and when the original object * is no longer needed. *

Consistency and adherence to SBML specifications

* To make it easier for applications to do whatever they need, * libSBML 3.x is relatively lax when it comes to enforcing * correctness and completeness of models during model construction and * editing. Essentially, libSBML will not in most cases check * automatically that a model\'s components have valid attribute values, or * that the overall model is consistent and free of errors—even * obvious errors such as duplication of identifiers. This allows * applications great leeway in how they build their models, but it means * that software authors must take deliberate steps to ensure that the * model will be, in the end, valid SBML. These steps include such things * as keeping track of the identifiers used in a model, manually performing * updates in certain situations where an entity is referenced in more than * one place (e.g., a species that is referenced by multiple * {@link SpeciesReference} objects), and so on. *

* That said, libSBML does provide powerful features for deliberately * performing validation of SBML when an application decides it is time to * do so. The interfaces to these facilities are on the {@link SBMLDocument} * class, in the form of SBMLDocument.checkInternalConsistency() and * SBMLDocument.checkConsistency(). Please refer to the documentation for * {@link SBMLDocument} for more information about this. *

* While applications may play fast and loose and live like free spirits * during the construction and editing of SBML models, they should always * make sure to call SBMLDocument.checkInternalConsistency() and/or * SBMLDocument.checkConsistency() before writing out the final version of * an SBML model. */ " %javamethodmodifiers Model::Model(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link Model}, optionally with a given identifier and * name. *

* @param id a string, the optional identifier of this {@link Model} * @param name a string, the optional name of this {@link Model}. *

* @param level a long integer, the SBML Level to assign to this {@link Model} *

* @param version a long integer, the SBML Version to assign to this * {@link Model} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Model} *

* @note Once a {@link Model} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Model}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* The {@link 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 Core. * A common approach to using this class constructor is to create an * {@link SBMLNamespaces} object somewhere in a program, once, then pass it to * object constructors such as this one when needed. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Model::clone() const " /** * Creates and returns a deep copy of this {@link Model} object. *

* @return a (deep) copy of this {@link Model}. */ public"; %javamethodmodifiers Model::getModelHistory() const " /** * Returns the {@link ModelHistory} of this {@link Model}. *

* @return {@link ModelHistory} of this {@link Model}. */ public"; %javamethodmodifiers Model::getModelHistory " /** * Returns the {@link ModelHistory} of this {@link Model}. *

* @return {@link ModelHistory} of this {@link Model}. */ public"; %javamethodmodifiers Model::isSetModelHistory " /** * Predicate returning true or false depending on whether this * {@link Model}\'s {@link ModelHistory} has been set. *

* @return true if the {@link ModelHistory} of this {@link Model} * has been set, false otherwise. */ public"; %javamethodmodifiers Model::setModelHistory(ModelHistory * history) " /** * Sets the {@link ModelHistory} of this {@link Model}. *

* @param history {@link ModelHistory} of this {@link Model}. */ public"; %javamethodmodifiers Model::unsetModelHistory " /** * Unsets the {@link ModelHistory} of this {@link Model}. *

* @param fd the {@link FunctionDefinition} to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createFunctionDefinition() * for a method that does not lead to these issues. *

* @see #createFunctionDefinition() */ public"; %javamethodmodifiers Model::addUnitDefinition(const UnitDefinition* ud) " /** * Adds a copy of the given {@link UnitDefinition} object to this {@link Model}. *

* @param ud the {@link UnitDefinition} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createUnitDefinition() for * a method that does not lead to these issues. *

* @see #createUnitDefinition() */ public"; %javamethodmodifiers Model::addCompartmentType(const CompartmentType* ct) " /** * Adds a copy of the given {@link CompartmentType} object to this {@link Model}. *

* @param ct the {@link CompartmentType} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createCompartmentType() * for a method that does not lead to these issues. *

* @see #createCompartmentType() */ public"; %javamethodmodifiers Model::addSpeciesType(const SpeciesType* st) " /** * Adds a copy of the given {@link SpeciesType} object to this {@link Model}. *

* @param st the {@link SpeciesType} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createSpeciesType() for a * method that does not lead to these issues. *

* @see #createSpeciesType() */ public"; %javamethodmodifiers Model::addCompartment(const Compartment* c) " /** * Adds a copy of the given {@link Compartment} object to this {@link Model}. *

* @param c the {@link Compartment} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createCompartment() for a * method that does not lead to these issues. *

* @see #createCompartment() */ public"; %javamethodmodifiers Model::addSpecies(const Species* s) " /** * Adds a copy of the given {@link Species} object to this {@link Model}. *

* @param s the {@link Species} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createSpecies() for a * method that does not lead to these issues. *

* @see #createSpecies() */ public"; %javamethodmodifiers Model::addParameter(const Parameter* p) " /** * Adds a copy of the given {@link Parameter} object to this {@link Model}. *

* @param p the {@link Parameter} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createParameter() for a * method that does not lead to these issues. *

* @see #createParameter() */ public"; %javamethodmodifiers Model::addInitialAssignment(const InitialAssignment* ia) " /** * Adds a copy of the given {@link InitialAssignment} object to this {@link Model}. *

* @param ia the {@link InitialAssignment} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createInitialAssignment() * for a method that does not lead to these issues. *

* @see #createInitialAssignment() */ public"; %javamethodmodifiers Model::addRule(const Rule* r) " /** * Adds a copy of the given {@link Rule} object to this {@link Model}. *

* @param r the {@link Rule} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 the methods * Model.createAlgebraicRule(), Model.createAssignmentRule() and * Model.createRateRule() for methods that do not lead to these issues. *

* @see #createAlgebraicRule() * @see #createAssignmentRule() * @see #createRateRule() */ public"; %javamethodmodifiers Model::addConstraint(const Constraint* c) " /** * Adds a copy of the given {@link Constraint} object to this {@link Model}. *

* @param c the {@link Constraint} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createConstraint() for a * method that does not lead to these issues. *

* @see #createConstraint() */ public"; %javamethodmodifiers Model::addReaction(const Reaction* r) " /** * Adds a copy of the given {@link Reaction} object to this {@link Model}. *

* @param r the {@link Reaction} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createReaction() for a * method that does not lead to these issues. *

* @see #createReaction() */ public"; %javamethodmodifiers Model::addEvent(const Event* e) " /** * Adds a copy of the given {@link Event} object to this {@link Model}. *

* @param e the {@link Event} object to add *

* @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 in this {@link Model}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Model}. 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 Model.createEvent() for a method * that does not lead to these issues. *

* @see #createEvent() */ public"; %javamethodmodifiers Model::createFunctionDefinition " /** * Creates a new {@link FunctionDefinition} inside this {@link Model} and returns it. *

* @return the {@link FunctionDefinition} object created *

* @see #addFunctionDefinition(FunctionDefinition fd) */ public"; %javamethodmodifiers Model::createUnitDefinition " /** * Creates a new {@link UnitDefinition} inside this {@link Model} and returns it. *

* @return the {@link UnitDefinition} object created *

* @see #addUnitDefinition(UnitDefinition ud) */ public"; %javamethodmodifiers Model::createUnit " /** * Creates a new {@link Unit} object within the last {@link UnitDefinition} object * created in this model and returns a pointer to it. *

* The mechanism by which the {@link UnitDefinition} was created is not * significant. If a {@link UnitDefinition} object does not exist in this model, * a new {@link Unit} is not created and NULL is returned instead. *

* @return the {@link Unit} object created *

* @see #addUnitDefinition(UnitDefinition ud) */ public"; %javamethodmodifiers Model::createCompartmentType " /** * Creates a new {@link CompartmentType} inside this {@link Model} and returns it. *

* @return the {@link CompartmentType} object created *

* @see #addCompartmentType(CompartmentType ct) */ public"; %javamethodmodifiers Model::createSpeciesType " /** * Creates a new {@link SpeciesType} inside this {@link Model} and returns it. *

* @return the {@link SpeciesType} object created *

* @see #addSpeciesType(SpeciesType st) */ public"; %javamethodmodifiers Model::createCompartment " /** * Creates a new {@link Compartment} inside this {@link Model} and returns it. *

* @return the {@link Compartment} object created *

* @see #addCompartment(Compartment c) */ public"; %javamethodmodifiers Model::createSpecies " /** * Creates a new {@link Species} inside this {@link Model} and returns it. *

* @return the {@link Species} object created *

* @see #addSpecies(Species s) */ public"; %javamethodmodifiers Model::createParameter " /** * Creates a new {@link Parameter} inside this {@link Model} and returns it. *

* @return the {@link Parameter} object created *

* @see #addParameter(Parameter p) */ public"; %javamethodmodifiers Model::createInitialAssignment " /** * Creates a new {@link InitialAssignment} inside this {@link Model} and returns it. *

* @return the {@link InitialAssignment} object created *

* @see #addInitialAssignment(InitialAssignment ia) */ public"; %javamethodmodifiers Model::createAlgebraicRule " /** * Creates a new {@link AlgebraicRule} inside this {@link Model} and returns it. *

* @return the {@link AlgebraicRule} object created *

* @see #addRule(Rule r) */ public"; %javamethodmodifiers Model::createAssignmentRule " /** * Creates a new {@link AssignmentRule} inside this {@link Model} and returns it. *

* @return the {@link AssignmentRule} object created *

* @see #addRule(Rule r) */ public"; %javamethodmodifiers Model::createRateRule " /** * Creates a new {@link RateRule} inside this {@link Model} and returns it. *

* @return the {@link RateRule} object created *

* @see #addRule(Rule r) */ public"; %javamethodmodifiers Model::createConstraint " /** * Creates a new {@link Constraint} inside this {@link Model} and returns it. *

* @return the {@link Constraint} object created *

* @see #addConstraint(Constraint c) */ public"; %javamethodmodifiers Model::createReaction " /** * Creates a new {@link Reaction} inside this {@link Model} and returns it. *

* @return the {@link Reaction} object created *

* @see #addReaction(Reaction r) */ public"; %javamethodmodifiers Model::createReactant " /** * Creates a new {@link SpeciesReference} object for a reactant inside the last * {@link Reaction} object in this {@link Model}, and returns a pointer to it. *

* The mechanism by which the last {@link Reaction} object was created and added * to this {@link Model} is not significant. It could have been created in a * variety of ways, for example using createReaction(). If a {@link Reaction} * does not exist for this model, a new {@link SpeciesReference} is not * created and NULL is returned instead. *

* @return the {@link SpeciesReference} object created */ public"; %javamethodmodifiers Model::createProduct " /** * Creates a new {@link SpeciesReference} object for a product inside the last * {@link Reaction} object in this {@link Model}, and returns a pointer to it. *

* @return the {@link SpeciesReference} object created */ public"; %javamethodmodifiers Model::createModifier " /** * Creates a new {@link ModifierSpeciesReference} object for a modifier species * inside the last {@link Reaction} object in this {@link Model}, and returns a pointer * to it. *

* The mechanism by which the last {@link Reaction} object was created and added * to this {@link Model} is not significant. It could have been created in a * variety of ways, for example using createReaction(). If a {@link Reaction} * does not exist for this model, a new {@link ModifierSpeciesReference} is * not created and NULL is returned instead. *

* @return the {@link SpeciesReference} object created */ public"; %javamethodmodifiers Model::createKineticLaw " /** * Creates a new {@link KineticLaw} inside the last {@link Reaction} object created in * this {@link Model}, and returns a pointer to it. *

* The mechanism by which the last {@link Reaction} object was created and added * to this {@link Model} is not significant. It could have been created in a * variety of ways, for example using createReaction(). If a {@link Reaction} * does not exist for this model, or a {@link Reaction} exists but already has a * {@link KineticLaw}, a new {@link KineticLaw} is not created and NULL is returned * instead. *

* @return the {@link KineticLaw} object created */ public"; %javamethodmodifiers Model::createKineticLawParameter " /** * Creates a new local {@link Parameter} inside the {@link KineticLaw} object of the last * {@link Reaction} created inside this {@link Model}, and returns a pointer to it. *

* The last {@link KineticLaw} object in this {@link Model} could have been created in a * variety of ways. For example, it could have been added using * createKineticLaw(), or it could be the result of using * Reaction.createKineticLaw() on the {@link Reaction} object created by a * createReaction(). If a {@link Reaction} does not exist for this model, or the * last {@link Reaction} does not contain a {@link KineticLaw} object, a new {@link Parameter} is * not created and NULL is returned instead. *

* @return the {@link Parameter} object created */ public"; %javamethodmodifiers Model::createEvent " /** * Creates a new {@link Event} inside this {@link Model} and returns it. *

* @return the {@link Event} object created */ public"; %javamethodmodifiers Model::createEventAssignment " /** * Creates a new {@link EventAssignment} inside the last {@link Event} object created in * this {@link Model}, and returns a pointer to it. *

* The mechanism by which the last {@link Event} object in this model was created * is not significant. It could have been created in a variety of ways, * for example by using createEvent(). If no {@link Event} object exists in this * {@link Model} object, a new {@link EventAssignment} is not created and NULL is * returned instead. *

* @return the {@link EventAssignment} object created */ public"; %javamethodmodifiers Model::createTrigger " /** * Creates a new {@link Trigger} inside the last {@link Event} object created in * this {@link Model}, and returns a pointer to it. *

* The mechanism by which the last {@link Event} object in this model was created * is not significant. It could have been created in a variety of ways, * for example by using createEvent(). If no {@link Event} object exists in this * {@link Model} object, a new {@link Trigger} is not created and NULL is * returned instead. *

* @return the {@link Trigger} object created */ public"; %javamethodmodifiers Model::createDelay " /** * Creates a new {@link Delay} inside the last {@link Event} object created in * this {@link Model}, and returns a pointer to it. *

* The mechanism by which the last {@link Event} object in this model was created * is not significant. It could have been created in a variety of ways, * for example by using createEvent(). If no {@link Event} object exists in this * {@link Model} object, a new {@link Delay} is not created and NULL is * returned instead. *

* @return the {@link Delay} object created */ public"; %javamethodmodifiers Model::setAnnotation(const XMLNode* annotation) " /** * Sets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation. *

* Any existing content of the \'annotation\' subelement is 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 appendAnnotation(). *

* @param annotation an XML structure that is to be used as the content * of the \'annotation\' subelement of this object *

* @see #appendAnnotation(XMLNode annotation) */ public"; %javamethodmodifiers Model::setAnnotation(const std::string& annotation) " /** * Sets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation. *

* @param annotation an XML string that is to be used as the content * of the \'annotation\' subelement of this object *

* @see #appendAnnotation(String annotation) */ public"; %javamethodmodifiers Model::appendAnnotation(const XMLNode* annotation) " /** * Appends annotation content to any existing content in the \'annotation\' * subelement of this object. *

* The content in annotation is copied. Unlike setAnnotation(), this * method allows other annotations to be preserved when an application * adds its own data. *

* @param annotation an XML structure that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #setAnnotation(XMLNode annotation) */ public"; %javamethodmodifiers Model::appendAnnotation(const std::string& annotation) " /** * Appends annotation content to any existing content in the \'annotation\' * subelement of this object. *

* The content in annotation is copied. Unlike setAnnotation(), this * method allows other annotations to be preserved when an application * adds its own data. *

* @param annotation an XML string that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #setAnnotation(String annotation) */ public"; %javamethodmodifiers Model::getListOfFunctionDefinitions() const " /** * Get the {@link ListOfFunctionDefinitions} object in this {@link Model}. *

* @return the list of FunctionDefinitions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfFunctionDefinitions " /** * Get the {@link ListOfFunctionDefinitions} object in this {@link Model}. *

* @return the list of FunctionDefinitions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfUnitDefinitions() const " /** * Get the {@link ListOfUnitDefinitions} object in this {@link Model}. *

* @return the list of UnitDefinitions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfUnitDefinitions " /** * Get the {@link ListOfUnitDefinitions} object in this {@link Model}. *

* @return the list of UnitDefinitions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfCompartmentTypes() const " /** * Get the {@link ListOfCompartmentTypes} object in this {@link Model}. *

* @return the list of CompartmentTypes for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfCompartmentTypes " /** * Get the {@link ListOfCompartmentTypes} object in this {@link Model}. *

* @return the list of CompartmentTypes for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfSpeciesTypes() const " /** * Get the {@link ListOfSpeciesTypes} object in this {@link Model}. *

* @return the list of SpeciesTypes for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfSpeciesTypes " /** * Get the {@link ListOfSpeciesTypes} object in this {@link Model}. *

* @return the list of SpeciesTypes for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfCompartments() const " /** * Get the {@link ListOfCompartments} object in this {@link Model}. *

* @return the list of Compartments for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfCompartments " /** * Get the {@link ListOfCompartments} object in this {@link Model}. *

* @return the list of Compartments for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfSpecies() const " /** * Get the {@link ListOfSpecies} object in this {@link Model}. *

* @return the list of {@link Species} for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfSpecies " /** * Get the {@link ListOfSpecies} object in this {@link Model}. *

* @return the list of {@link Species} for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfParameters() const " /** * Get the {@link ListOfParameters} object in this {@link Model}. *

* @return the list of Parameters for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfParameters " /** * Get the {@link ListOfParameters} object in this {@link Model}. *

* @return the list of Parameters for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfInitialAssignments() const " /** * Get the {@link ListOfInitialAssignments} object in this {@link Model}. *

* @return the list of InitialAssignments for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfInitialAssignments " /** * Get the {@link ListOfInitialAssignments} object in this {@link Model}. *

* @return the list of {@link InitialAssignment} for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfRules() const " /** * Get the {@link ListOfRules} object in this {@link Model}. *

* @return the list of Rules for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfRules " /** * Get the {@link ListOfRules} object in this {@link Model}. *

* @return the list of Rules for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfConstraints() const " /** * Get the {@link ListOfConstraints} object in this {@link Model}. *

* @return the list of Constraints for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfConstraints " /** * Get the {@link ListOfConstraints} object in this {@link Model}. *

* @return the list of Constraints for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfReactions() const " /** * Get the {@link ListOfReactions} object in this {@link Model}. *

* @return the list of Reactions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfReactions " /** * Get the {@link ListOfReactions} object in this {@link Model}. *

* @return the list of Reactions for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfEvents() const " /** * Get the {@link ListOfEvents} object in this {@link Model}. *

* @return the list of Events for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfEvents " /** * Get the {@link ListOfEvents} object in this {@link Model}. *

* @return the list of Events for this {@link Model}. */ public"; %javamethodmodifiers Model::getFunctionDefinition " /** * Get the nth FunctionDefinitions object in this {@link Model}. *

* @return the nth {@link FunctionDefinition} of this {@link Model}. */ public"; %javamethodmodifiers Model::getFunctionDefinition(unsigned int n) " /** * Get the nth FunctionDefinitions object in this {@link Model}. *

* @return the nth {@link FunctionDefinition} of this {@link Model}. */ public"; %javamethodmodifiers Model::getFunctionDefinition(const std::string& sid) const " /** * Get a {@link FunctionDefinition} object based on its identifier. *

* @return the {@link FunctionDefinition} in this {@link Model} with the identifier * sid or NULL if no such {@link FunctionDefinition} exists. */ public"; %javamethodmodifiers Model::getFunctionDefinition(const std::string& sid) " /** * Get a {@link FunctionDefinition} object based on its identifier. *

* @return the {@link FunctionDefinition} in this {@link Model} with the identifier * sid or NULL if no such {@link FunctionDefinition} exists. */ public"; %javamethodmodifiers Model::getUnitDefinition " /** * Get the nth {@link UnitDefinition} object in this {@link Model}. *

* @return the nth {@link UnitDefinition} of this {@link Model}. */ public"; %javamethodmodifiers Model::getUnitDefinition(unsigned int n) " /** * Get the nth {@link UnitDefinition} object in this {@link Model}. *

* @return the nth {@link UnitDefinition} of this {@link Model}. */ public"; %javamethodmodifiers Model::getUnitDefinition(const std::string& sid) const " /** * Get a {@link UnitDefinition} based on its identifier. *

* @return the {@link UnitDefinition} in this {@link Model} with the identifier sid or * NULL if no such {@link UnitDefinition} exists. */ public"; %javamethodmodifiers Model::getUnitDefinition(const std::string& sid) " /** * Get a {@link UnitDefinition} based on its identifier. *

* @return the {@link UnitDefinition} in this {@link Model} with the identifier sid or * NULL if no such {@link UnitDefinition} exists. */ public"; %javamethodmodifiers Model::getCompartmentType " /** * Get the nth {@link CompartmentType} object in this {@link Model}. *

* @return the nth {@link CompartmentType} of this {@link Model}. */ public"; %javamethodmodifiers Model::getCompartmentType(unsigned int n) " /** * Get the nth {@link CompartmentType} object in this {@link Model}. *

* @return the nth {@link CompartmentType} of this {@link Model}. */ public"; %javamethodmodifiers Model::getCompartmentType(const std::string& sid) const " /** * Get a {@link CompartmentType} object based on its identifier. *

* @return the {@link CompartmentType} in this {@link Model} with the identifier sid * or NULL if no such {@link CompartmentType} exists. */ public"; %javamethodmodifiers Model::getCompartmentType(const std::string& sid) " /** * Get a {@link CompartmentType} object based on its identifier. *

* @return the {@link CompartmentType} in this {@link Model} with the identifier sid * or NULL if no such {@link CompartmentType} exists. */ public"; %javamethodmodifiers Model::getSpeciesType " /** * Get the nth {@link SpeciesType} object in this {@link Model}. *

* @return the nth {@link SpeciesType} of this {@link Model}. */ public"; %javamethodmodifiers Model::getSpeciesType(unsigned int n) " /** * Get the nth {@link SpeciesType} object in this {@link Model}. *

* @return the nth {@link SpeciesType} of this {@link Model}. */ public"; %javamethodmodifiers Model::getSpeciesType(const std::string& sid) const " /** * Get a {@link SpeciesType} object based on its identifier. *

* @return the {@link SpeciesType} in this {@link Model} with the identifier sid or * NULL if no such {@link SpeciesType} exists. */ public"; %javamethodmodifiers Model::getSpeciesType(const std::string& sid) " /** * Get a {@link SpeciesType} object based on its identifier. *

* @return the {@link SpeciesType} in this {@link Model} with the identifier sid or * NULL if no such {@link SpeciesType} exists. */ public"; %javamethodmodifiers Model::getCompartment " /** * Get the nth {@link Compartment} object in this {@link Model}. *

* @return the nth {@link Compartment} of this {@link Model}. */ public"; %javamethodmodifiers Model::getCompartment(unsigned int n) " /** * Get the nth {@link Compartment} object in this {@link Model}. *

* @return the nth {@link Compartment} of this {@link Model}. */ public"; %javamethodmodifiers Model::getCompartment(const std::string& sid) const " /** * Get a {@link Compartment} object based on its identifier. *

* @return the {@link Compartment} in this {@link Model} with the identifier sid or * NULL if no such {@link Compartment} exists. */ public"; %javamethodmodifiers Model::getCompartment(const std::string& sid) " /** * Get a {@link Compartment} object based on its identifier. *

* @return the {@link Compartment} in this {@link Model} with the identifier sid or * NULL if no such {@link Compartment} exists. */ public"; %javamethodmodifiers Model::getSpecies " /** * Get the nth {@link Species} object in this {@link Model}. *

* @return the nth {@link Species} of this {@link Model}. */ public"; %javamethodmodifiers Model::getSpecies(unsigned int n) " /** * Get the nth {@link Species} object in this {@link Model}. *

* @return the nth {@link Species} of this {@link Model}. */ public"; %javamethodmodifiers Model::getSpecies(const std::string& sid) const " /** * Get a {@link Species} object based on its identifier. *

* @return the {@link Species} in this {@link Model} with the identifier sid or NULL * if no such {@link Species} exists. */ public"; %javamethodmodifiers Model::getSpecies(const std::string& sid) " /** * Get a {@link Species} object based on its identifier. *

* @return the {@link Species} in this {@link Model} with the identifier sid or NULL * if no such {@link Species} exists. */ public"; %javamethodmodifiers Model::getParameter " /** * Get the nth {@link Parameter} object in this {@link Model}. *

* @return the nth {@link Parameter} of this {@link Model}. */ public"; %javamethodmodifiers Model::getParameter(unsigned int n) " /** * Get the nth {@link Parameter} object in this {@link Model}. *

* @return the nth {@link Parameter} of this {@link Model}. */ public"; %javamethodmodifiers Model::getParameter(const std::string& sid) const " /** * Get a {@link Parameter} object based on its identifier. *

* @return the {@link Parameter} in this {@link Model} with the identifier sid or NULL * if no such {@link Parameter} exists. */ public"; %javamethodmodifiers Model::getParameter(const std::string& sid) " /** * Get a {@link Parameter} object based on its identifier. *

* @return the {@link Parameter} in this {@link Model} with the identifier sid or NULL * if no such {@link Parameter} exists. */ public"; %javamethodmodifiers Model::getInitialAssignment " /** * Get the nth {@link InitialAssignment} object in this {@link Model}. *

* @return the nth {@link InitialAssignment} of this {@link Model}. */ public"; %javamethodmodifiers Model::getInitialAssignment(unsigned int n) " /** * Get the nth {@link InitialAssignment} object in this {@link Model}. *

* @return the nth {@link InitialAssignment} of this {@link Model}. */ public"; %javamethodmodifiers Model::getInitialAssignment(const std::string& symbol) const " /** * Get an {@link InitialAssignment} object based on the symbol to which it * assigns a value. *

* @return the {@link InitialAssignment} in this {@link Model} with the given \'symbol\' * attribute value or NULL if no such {@link InitialAssignment} exists. */ public"; %javamethodmodifiers Model::getInitialAssignment(const std::string& symbol) " /** * Get an {@link InitialAssignment} object based on the symbol to which it * assigns a value. *

* @return the {@link InitialAssignment} in this {@link Model} with the given \'symbol\' * attribute value or NULL if no such {@link InitialAssignment} exists. */ public"; %javamethodmodifiers Model::getRule " /** * Get the nth {@link Rule} object in this {@link Model}. *

* @return the nth {@link Rule} of this {@link Model}. */ public"; %javamethodmodifiers Model::getRule(unsigned int n) " /** * Get the nth {@link Rule} object in this {@link Model}. *

* @return the nth {@link Rule} of this {@link Model}. */ public"; %javamethodmodifiers Model::getRule(const std::string& variable) const " /** * Get a {@link Rule} object based on the variable to which it assigns a value. *

* @return the {@link Rule} in this {@link Model} with the given \'variable\' attribute * value or NULL if no such {@link Rule} exists. */ public"; %javamethodmodifiers Model::getRule(const std::string& variable) " /** * Get a {@link Rule} object based on the variable to which it assigns a value. *

* @return the {@link Rule} in this {@link Model} with the given \'variable\' attribute * value or NULL if no such {@link Rule} exists. */ public"; %javamethodmodifiers Model::getConstraint " /** * Get the nth {@link Constraint} object in this {@link Model}. *

* @return the nth {@link Constraint} of this {@link Model}. */ public"; %javamethodmodifiers Model::getConstraint(unsigned int n) " /** * Get the nth {@link Constraint} object in this {@link Model}. *

* @return the nth {@link Constraint} of this {@link Model}. */ public"; %javamethodmodifiers Model::getReaction " /** * Get the nth {@link Reaction} object in this {@link Model}. *

* @return the nth {@link Reaction} of this {@link Model}. */ public"; %javamethodmodifiers Model::getReaction(unsigned int n) " /** * Get the nth {@link Reaction} object in this {@link Model}. *

* @return the nth {@link Reaction} of this {@link Model}. */ public"; %javamethodmodifiers Model::getReaction(const std::string& sid) const " /** * Get a {@link Reaction} object based on its identifier. *

* @return the {@link Reaction} in this {@link Model} with the identifier sid or NULL * if no such {@link Reaction} exists. */ public"; %javamethodmodifiers Model::getReaction(const std::string& sid) " /** * Get a {@link Reaction} object based on its identifier. *

* @return the {@link Reaction} in this {@link Model} with the identifier sid or NULL * if no such {@link Reaction} exists. */ public"; %javamethodmodifiers Model::getEvent " /** * Get the nth {@link Event} object in this {@link Model}. *

* @return the nth {@link Event} of this {@link Model}. */ public"; %javamethodmodifiers Model::getEvent(unsigned int n) " /** * Get the nth {@link Event} object in this {@link Model}. *

* @return the nth {@link Event} of this {@link Model}. */ public"; %javamethodmodifiers Model::getEvent(const std::string& sid) const " /** * Get an {@link Event} object based on its identifier. *

* @return the {@link Event} in this {@link Model} with the identifier sid or NULL if * no such {@link Event} exists. */ public"; %javamethodmodifiers Model::getEvent(const std::string& sid) " /** * Get an {@link Event} object based on its identifier. *

* @return the {@link Event} in this {@link Model} with the identifier sid or NULL if * no such {@link Event} exists. */ public"; %javamethodmodifiers Model::getNumFunctionDefinitions() const " /** * Get the number of {@link FunctionDefinition} objects in this {@link Model}. *

* @return the number of FunctionDefinitions in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumUnitDefinitions() const " /** * Get the number of {@link UnitDefinition} objects in this {@link Model}. *

* @return the number of UnitDefinitions in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumCompartmentTypes() const " /** * Get the number of {@link CompartmentType} objects in this {@link Model}. *

* @return the number of CompartmentTypes in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumSpeciesTypes() const " /** * Get the number of {@link SpeciesType} objects in this {@link Model}. *

* @return the number of SpeciesTypes in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumCompartments() const " /** * Get the number of {@link Compartment} objects in this {@link Model}. *

* @return the number of Compartments in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumSpecies() const " /** * Get the number of Specie objects in this {@link Model}. *

* @return the number of {@link Species} in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumSpeciesWithBoundaryCondition() const " /** * Get the number of {@link Species} in this {@link Model} having their * \'boundaryCondition\' attribute value set to true. *

* @return the number of {@link Species} in this {@link Model} with boundaryCondition set * to true. */ public"; %javamethodmodifiers Model::getNumParameters() const " /** * Get the number of {@link Parameter} objects in this {@link Model}. *

* @return the number of Parameters in this {@link Model}. Parameters defined in * KineticLaws are not included. */ public"; %javamethodmodifiers Model::getNumInitialAssignments() const " /** * Get the number of {@link InitialAssignment} objects in this {@link Model}. *

* @return the number of InitialAssignments in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumRules() const " /** * Get the number of {@link Rule} objects in this {@link Model}. *

* @return the number of Rules in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumConstraints() const " /** * Get the number of {@link Constraint} objects in this {@link Model}. *

* @return the number of Constraints in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumReactions() const " /** * Get the number of {@link Reaction} objects in this {@link Model}. *

* @return the number of Reactions in this {@link Model}. */ public"; %javamethodmodifiers Model::getNumEvents() const " /** * Get the number of {@link Event} objects in this {@link Model}. *

* @return the number of Events in this {@link Model}. */ public"; %javamethodmodifiers Model::convertToL1 " /** * Converts the model to a from SBML Level 2 to Level 1. *

* Most of the necessary changes occur during the various * writeAttributes() methods, however there are some difference between * L1 and L2 that require the underlying {@link Model} to be changed. */ public"; %javamethodmodifiers Model::convertToL2 " /** * Converts the model to a from SBML Level 1 to Level 2. *

* Most of the necessary changes occur during the various * writeAttributes() methods, however there are some difference between * L1 and L2 that require the underlying {@link Model} to be changed. */ public"; %javamethodmodifiers Model::isBoolean(const ASTNode* node) const " /** * Predicate returning true or false depending on whether the * given {@link ASTNode} is a boolean. *

* Often times, this question can be answered with the {@link ASTNode}\'s own * isBoolean() method, but if the AST is an expression that calls a * function defined in the {@link Model}\'s {@link ListOfFunctionDefinitions}, the model * is needed for lookup context. *

* @return true if the given {@link ASTNode} is a boolean. */ public"; %javamethodmodifiers Model::removeDuplicateTopLevelAnnotations " /** * Predicate returning true or false depending on whether the * given {@link ASTNode} is a boolean. *

* @return true if the given {@link ASTNode} is a boolean.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} object to set

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Model::getElementName() const " /** * Returns the XML element name of this object, which for {@link Model}, is * always \'model\'. *

* @return the name of this element, i.e., \'model\'. */ public"; %javamethodmodifiers Model::getElementPosition() const " /** * @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getListOfLayouts() const " /** * Returns the {@link ListOf} Layouts for this {@link Model}. */ public"; %javamethodmodifiers Model::getListOfLayouts " /** * Returns the {@link ListOf} Layouts for this {@link Model}. */ public"; %javamethodmodifiers Model::getLayout " /** * Returns the layout object that belongs to the given index. If the * index is invalid, NULL is returned. */ public"; %javamethodmodifiers Model::getLayout(unsigned int index) " /** * Returns the layout object that belongs to the given index. If the * index is invalid, NULL is returned. */ public"; %javamethodmodifiers Model::addLayout(const Layout* layout) " /** * Adds a copy of the layout object to the list of layouts. */ public"; %javamethodmodifiers Model::createLayout " /** * Creates a new layout object and adds it to the list of layout objects * and returns it. */ public"; %javamethodmodifiers Model::populateListFormulaUnitsData " /** * Populates the list of FormulaDataUnits with the units derived * for the model. The list contains elements of class * FormulaUnitsData. *

* The first element of the list refers to the default units * of \'substance per time\' derived from the model and has the * unitReferenceId \'subs_per_time\'. This facilitates the comparison of units * derived from mathematical formula with the expected units. *

* The next elements of the list record the units of the * compartments and species established from either explicitly * declared or default units. *

* The next elements record the units of any parameters. *

* Subsequent elements of the list record the units derived for * each mathematical expression encountered within the model. *

* @note This function is utilised by the {@link Unit} Consistency Validator. * The list is populated prior to running the validation and thus * the consistency of units can be checked by accessing the members * of the list and comparing the appropriate data. */ public"; %javamethodmodifiers Model::isPopulatedListFormulaUnitsData " /** * Predicate returning true or false depending on whether * the list of FormulaUnitsData has been populated. *

* @return true if the list of FormulaUnitsData has been populated, * false otherwise. */ public"; %javamethodmodifiers Model::addFormulaUnitsData(const FormulaUnitsData* fud) " /** * Adds a copy of the given FormulaUnitsData object to this {@link Model}. *

* @param fud the FormulaUnitsData to add

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::createFormulaUnitsData " /** * Creates a new FormulaUnitsData inside this {@link Model} and returns it. *

* @return the FormulaUnitsData object created

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getFormulaUnitsData " /** * Get the nth FormulaUnitsData object in this {@link Model}. *

* @return the nth FormulaUnitsData of this {@link Model}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getFormulaUnitsData(unsigned int n) " /** * Get the nth FormulaUnitsData object in this {@link Model}. *

* @return the nth FormulaUnitsData of this {@link Model}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getFormulaUnitsData(const std::string& sid, SBMLTypeCode_t typecode) const " /** * Get a FormulaUnitsData object based on its unitReferenceId and typecode. *

* @return the FormulaUnitsData in this {@link Model} with the unitReferenceId sid * and the SBMLTypeCode_t typecode or NULL * if no such FormulaUnitsData exists. *

* @note The SBMLTypecode_t parameter is necessary as the unitReferenceId * of the FormulaUnitsData need not be unique. For example if a {@link Species} * with id \'s\' is assigned by an {@link AssignmentRule} there will be two * elements of the FormulaUnitsData list with the unitReferenceId \'s\'; * one with * typecode \'SBML_SPECIES\' referring to the units related to the species, * the other with typecode \'SBML_ASSIGNMENT_RULE\' referring to the units * derived from the math element of the {@link AssignmentRule}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getFormulaUnitsData(const std::string& sid, SBMLTypeCode_t) " /** * Get a FormulaUnitsData object based on its unitReferenceId and typecode. *

* @return the FormulaUnitsData in this {@link Model} with the unitReferenceId sid * and the SBMLTypeCode_t typecode or NULL * if no such FormulaUnitsData exists. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getNumFormulaUnitsData() const " /** * Get the number of FormulaUnitsData objects in this {@link Model}. *

* @return the number of FormulaUnitsData in this {@link Model}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getListFormulaUnitsData " /** * Get the list of FormulaUnitsData object in this {@link Model}. *

* @return the list of FormulaUnitsData for this {@link Model}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::getListFormulaUnitsData() const " /** * Get the list of FormulaUnitsData object in this {@link Model}. *

* @return the list of FormulaUnitsData for this {@link Model}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::syncAnnotation " /** * Synchronizes the annotation of this SBML object. *

* Annotation element (XMLNode mAnnotation) is synchronized with the * current {@link CVTerm} objects (List mCVTerm), {@link ModelHistory} object * (ModelHistory mHistory) and ListOfLayouts object (ListOfLayouts mLayouts). * Currently, this method is called in getAnnotation, isSetAnnotation, * and writeElements methods.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Model::syncAnnotation " /** * Synchronizes the annotation of this SBML object. *

* @deprecated libSBML internal */ public"; %typemap(javaimports) SBMLDocument " /** * Container for an SBML document and interface for global operations * on SBML documents. *

* LibSBML uses the class * {@link SBMLDocument} as a top-level container for storing SBML content and data * associated with it (such as warnings and error messages). The two * primary means of reading an SBML model, {@link SBMLReader#readSBML(String * filename)} and {@link SBMLReader#readSBMLFromString(String xml)}, both return a * pointer to an {@link SBMLDocument} object. From there, callers can inquire * about any errors encountered (e.g., using SBMLDocument.getNumErrors()), * access the {@link Model} object, and perform other actions such as * consistency-checking and model translation. *

* When creating fresh models programmatically, the starting point is * typically the creation of an {@link SBMLDocument} object instance. The * {@link SBMLDocument} constructor accepts arguments for the SBML Level and * Version of the model to be created. After creating the {@link SBMLDocument} * object, calling programs then typically call SBMLDocument.createModel() * almost immediately, and then proceed to call the methods on the {@link Model} * object to fill out the model\'s contents. *

* {@link SBMLDocument} corresponds roughly to the class Sbml defined in the * SBML Level 2 specification. It does not have a direct * correspondence in SBML Level 1. (However, to make matters simpler * for applications, libSBML creates an {@link SBMLDocument} no matter whether the model * is Level 1 or Level 2.) In its barest form, when written out * in XML format for SBML Level 2 Version 4, the corresponding * structure is the following: *

<sbml xmlns=\'http://www.sbml.org/sbml/level2/version4\' level=\'2\' version=\'4\'
  ...
</sbml>

* {@link SBMLDocument} is derived from {@link SBase}, and therefore contains the usual {@link SBase} * attributes (in SBML Level 2 Version 4) of \'metaid\' and \'sboTerm\', as * well as the subelements \'notes\' and \'annotation\'. It also contains the * attributes \'level\' and \'version\' indicating the Level and Version of the * SBML data structure. These can be accessed using the methods defined by * the {@link SBase} class for that purpose. *

Checking consistency and adherence to SBML specifications

* One of the most important features of libSBML is its ability to perform * SBML validation to ensure that a model adheres to the SBML specification * for whatever Level+Version combination the model uses. {@link SBMLDocument} * provides the methods for running consistency-checking and validation * rules on the SBML content. *

* First, a brief explanation of the rationale is in order. In libSBML * versions up to and including the version 3.3.x series, the individual * methods for creating and setting attributes and other components are * quite lenient, and allow a caller to compose SBML entities that may not, * in the end, represent valid SBML. This allows applications the freedom * to do things such as save incomplete models (which is useful when models * are being developed over long periods of time), but at the same time, it * means that a separate validation step is necessary when a calling * program finally wants to finish a complete SBML document. *

* The primary interface to this facility is {@link SBMLDocument}\'s * SBMLDocument.checkInternalConsistency() and * SBMLDocument.checkConsistency(). The former verifies the basic * internal consistency and syntax of an SBML document, and the latter * implements more elaborate validation rules (both those defined by the * SBML specifications, as well as additional rules offered by libSBML). *

* The checks * performed by SBMLDocument.checkInternalConsistency() are hardwired and * cannot be changed by calling programs, but the validation performed by * SBMLDocument.checkConsistency() is under program control using the * method {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)}. * Applications can selectively disable specific kinds of checks that they * may not be interested by calling {@link SBMLDocument#setConsistencyChecks(int * categ, boolean onoff)} with appropriate parameters. *

* These methods have slightly different relevance depending on whether a * model is created programmaticaly from scratch, or whether it is read in * from a file or data stream. The following table summarizes the possible * scenarios. *

* * * * * * * * * *

Scenario	Relevant methods
Creating a model from scratch	Before writing out the model: * * Call * SBMLDocument.checkInternalConsistency(), then inquire about the results by * calling SBMLDocument.getNumErrors() * * * Call {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} to configure which checks * will be performed by SBMLDocument.checkConsistency() * * Call SBMLDocument.checkConsistency(), then inquire about the results by * calling SBMLDocument.getNumErrors() * *
Reading a model from a file or data stream	After reading the model: * * Basic consistency checks will have been * performed automatically by libSBML upon reading the content—only need * to inquire about the results by using SBMLDocument.getNumErrors() * * * Call {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} to configure which * checks are performed by SBMLDocument.checkConsistency() * * Call SBMLDocument.checkConsistency(), then inquire about the results * by calling SBMLDocument.getNumErrors() * *

Scenario

Relevant methods

Creating a model from scratch

Before writing out the model:

Call * SBMLDocument.checkInternalConsistency(), then inquire about the results by * calling SBMLDocument.getNumErrors()

* Call {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} to configure which checks * will be performed by SBMLDocument.checkConsistency()

Call SBMLDocument.checkConsistency(), then inquire about the results by * calling SBMLDocument.getNumErrors()

Reading a model from a file or data stream

After reading the model:

Basic consistency checks will have been * performed automatically by libSBML upon reading the content—only need * to inquire about the results by using SBMLDocument.getNumErrors()

* Call {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} to configure which * checks are performed by SBMLDocument.checkConsistency()

Call SBMLDocument.checkConsistency(), then inquire about the results * by calling SBMLDocument.getNumErrors()

* *

Converting documents between Levels and Versions of SBML

* LibSBML provides facilities for limited translation of SBML between * Levels and Versions of the SBML specifications. The method for doing is * is {@link SBMLDocument#setLevelAndVersion(long lev, long ver)} . In * general, models can be converted upward without difficulty (e.g., from * SBML Level 1 to Level 2, or from an earlier Version of * Level 2 to the latest Version of Level 2). Sometimes models * can be translated downward as well, if they do not use constructs * specific to more advanced Levels of SBML. *

* Calling {@link SBMLDocument#setLevelAndVersion(long lev, long ver)} will not necessarily lead * to a successful conversion. The method will return a boolean value * to indicate success or failure. Callers must check the error log (see * next section) attached to the {@link SBMLDocument} object after calling * {@link SBMLDocument#setLevelAndVersion(long lev, long ver)} in order to assess whether any * problems arose. *

* If an application is interested in translating to a lower Level and/or * Version of SBML within a Level, the following methods allow for prior * assessment of whether there is sufficient compatibility to make a * translation possible: *

SBMLDocument.checkL1Compatibility(), *

SBMLDocument.checkL2v1Compatibility(), *

SBMLDocument.checkL2v2Compatibility(), *

SBMLDocument.checkL2v3Compatibility(), and *

SBMLDocument.checkL2v4Compatibility(). *

* Some changes between Versions of SBML Level 2 may lead to * unexpected behaviors when attempting conversions in either direction. * For example, SBML Level 2 Version 4 relaxed the requirement * for consistency in units of measurement between expressions annd * quantities in a model. As a result, a model written in Version 4, * if converted to Version 3 with no other changes, may fail * validation as a Version 3 model because Version 3 imposed * stricter requirements on unit consistency. *

Error handling

* Upon reading a model, {@link SBMLDocument} logs any problems encountered while * reading the model from the file or data stream. The log contains * objects that record diagnostic information about any notable issues that * arose. Whether the problems are warnings or errors, they are both * reported through a single common interface involving the object class * {@link SBMLError}. *

* The methods SBMLDocument.getNumErrors(), {@link SBMLDocument#getError(long n)} and * SBMLDocument.printErrors() allow callers to interact with the warnings * or errors logged. Alternatively, callers may retrieve the entire log as * an {@link SBMLErrorLog} object using the method SBMLDocument.getErrorLog(). * The {@link SBMLErrorLog} object provides some alternative methods for * interacting with the set of errors and warnings. In either case, * applications typically should first call SBMLDocument.getNumErrors() to * find out if any issues have been logged after specific libSBML * operations such as the ones discussed in the sections above. If they * have, then an application will should proceed to inspect the individual * reports using either the direct interfaces on {@link SBMLDocument} or using the * methods on the {@link SBMLErrorLog} object. *

*/ " %javamethodmodifiers SBMLDocument::getDefaultLevel " /** * The default SBML Level of new {@link SBMLDocument} objects. *

* This \'default level\' corresponds to the most recent SBML specification * Level available at the time this version of libSBML was released. For * this copy of libSBML, the value is 2. The default Level * is used by {@link SBMLDocument} if no Level is explicitly specified at the * time of the construction of an {@link SBMLDocument} instance. *

* @return an integer indicating the most recent SBML specification Level *

* @see #getDefaultVersion() */ public"; %javamethodmodifiers SBMLDocument::getDefaultVersion " /** * The default Version of new {@link SBMLDocument} objects. *

* This \'default version\' corresponds to the most recent SBML Version * within the most recent Level of SBML available at the time this * version of libSBML was released. For this copy of libSBML, the value * is 4. The default Version is used by {@link SBMLDocument} if no * Version is explicitly specified at the time of the construction of an * {@link SBMLDocument} instance. *

* @return an integer indicating the most recent SBML specification * Version *

* @see #getDefaultLevel() */ public"; %javamethodmodifiers SBMLDocument::SBMLDocument(unsigned int level = 0, unsigned int version = 0) " /** * Creates a new {@link SBMLDocument}, optionally with given values for the SBML * Level and Version. *

* If both the SBML Level and Version attributes are not * specified, the SBML document is treated as having the latest Level and * Version of SBML as determined by SBMLDocument.getDefaultLevel() and * SBMLDocument.getDefaultVersion(); however, the {@link SBMLDocument} * object is otherwise left blank. In particular, the blank {@link SBMLDocument} * object has no associated XML attributes, including (but not limited * to) an XML namespace declaration. The XML namespace declaration is * not added until the model is written out, or the method * {@link SBMLDocument#setLevelAndVersion(long lev, long ver)} is called. This may be important to keep in mind * if an application needs to add additional XML namespace declarations * on the <sbml> element. Application writers should * either provide values for level and version on the call to this * constructor, or else call {@link SBMLDocument#setLevelAndVersion(long lev, long ver)} shortly after creating * the {@link SBMLDocument} object. *

* @param level an integer for the SBML Level *

* @param version an integer for the Version within the SBML Level *

* @see SBMLDocument#setLevelAndVersion(long lev, long ver) * @see #getDefaultLevel() * @see #getDefaultVersion() *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers SBMLDocument::clone() const " /** * Creates and returns a deep copy of this {@link SBMLDocument}. *

* @return a (deep) copy of this {@link SBMLDocument}. */ public"; %javamethodmodifiers SBMLDocument::getModel() const " /** * Returns the {@link Model} object stored in this {@link SBMLDocument}. *

* It is important to note that this method does not create a * {@link Model} instance. The model in the {@link SBMLDocument} must have been created * at some prior time, for example using SBMLDocument.createModel() * or {@link SBMLDocument#setModel(Model m)} . * This method returns NULL if a model does not yet exist. *

* @return the {@link Model} contained in this {@link SBMLDocument}. *

* @see #createModel() */ public"; %javamethodmodifiers SBMLDocument::getModel " /** * Returns the {@link Model} object stored in this {@link SBMLDocument}. *

* @return the {@link Model} contained in this {@link SBMLDocument}. *

* @see #createModel() */ public"; %javamethodmodifiers SBMLDocument::setLevelAndVersion(unsigned int level, unsigned int version) " /** * Sets the SBML Level and Version of this {@link SBMLDocument} instance, * attempting to convert the model as needed. *

* This method is the principal way in libSBML to convert models between * Levels and Versions of SBML. Generally, models can be converted * upward without difficulty (e.g., from SBML Level 1 to * Level 2, or from an earlier Version of Level 2 to the latest * Version of Level 2). Sometimes models can be translated downward * as well, if they do not use constructs specific to more advanced * Levels of SBML. *

* Before calling this method, callers may check compatibility directly * using the methods SBMLDocument.checkL1Compatibility(), * SBMLDocument.checkL2v1Compatibility(), * SBMLDocument.checkL2v2Compatibility(), * SBMLDocument.checkL2v3Compatibility() and * SBMLDocument.checkL2v4Compatibility(). *

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

Level 1 Version 2 *
Level 2 Version 1 *
Level 2 Version 2 *
Level 2 Version 3 *
Level 2 Version 4 *

* @param level the desired SBML Level *

* @param version the desired Version within the SBML Level *

* @note Calling this method will not necessarily lead to a successful * conversion. If the conversion fails, it will be logged in the error * list associated with this {@link SBMLDocument}. Callers should consult * getNumErrors() to find out if the conversion succeeded without * problems. For conversions from Level 2 to Level 1, callers * can also check the Level of the model after calling this method to * find out whether it is Level 1. (If the conversion to * Level 1 failed, the Level of this model will be left unchanged.) *

* @see #checkL1Compatibility() * @see #checkL2v1Compatibility() * @see #checkL2v2Compatibility() * @see #checkL2v3Compatibility() * @see #checkL2v4Compatibility() */ public"; %javamethodmodifiers SBMLDocument::setModel(const Model* m) " /** * Sets the {@link Model} for this {@link SBMLDocument} to a copy of the given {@link Model}. *

* @param m the new {@link Model} to use. *

* @see #createModel() * @see #getModel() */ public"; %javamethodmodifiers SBMLDocument::createModel(const std::string& sid = "") " /** * Creates a new {@link Model} inside this {@link SBMLDocument}, and returns a pointer to * it. *

* In SBML Level 2, the use of an identifier on a {@link Model} object is * optional. This method takes an optional argument, sid, for setting * the identifier. If not supplied, the identifier attribute on the * {@link Model} instance is not set. *

* @param sid the identifier of the new {@link Model} to create. *

* @see #getModel() * @see SBMLDocument#setModel(Model m) */ public"; %javamethodmodifiers SBMLDocument::setConsistencyChecks(SBMLErrorCategory_t category, bool apply) " /** * Controls the consistency checks that are performed when * SBMLDocument.checkConsistency() is called. *

* This method works by adding or subtracting consistency checks from the * set of all possible checks that SBMLDocument.checkConsistency() knows * how to perform. This method may need to be called multiple times in * order to achieve the desired combination of checks. The first * argument (category) in a call to this method indicates the category * of consistency/error checks that are to be turned on or off, and the * second argument (apply, a boolean) indicates whether to turn it on * (value of true) or off (value of false). *

* The possible categories (values to the argument category) are the * set of values from the enumeration #SBMLErrorCategory_t. The * following are the possible choices in libSBML version 3.3.x: *

LIBSBML_CAT_GENERAL_CONSISTENCY: Correctness and consistency of * specific SBML language constructs. Performing this set of checks is * highly recommended. With respect to the SBML specification, these * concern failures in applying the validation rules numbered 2xxxx in * the Level 2 Versions 2, 3 and 4 specifications. *

LIBSBML_CAT_IDENTIFIER_CONSISTENCY: Correctness and consistency * of identifiers used for model entities. An example of inconsistency * would be using a species identifier in a reaction rate formula without * first having declared the species. With respect to the SBML * specification, these concern failures in applying the validation rules * numbered 103xx in the Level 2 Versions 2, 3 and 4 * specifications. *

LIBSBML_CAT_UNITS_CONSISTENCY: Consistency of measurement units * associated with quantities in a model. With respect to the SBML * specification, these concern failures in applying the validation rules * numbered 105xx in the Level 2 Versions 2, 3 and 4 * specifications. *

LIBSBML_CAT_MATHML_CONSISTENCY: Syntax of MathML constructs. * With respect to the SBML specification, these concern failures in * applying the validation rules numbered 102xx in the Level 2 * Versions 2, 3 and 4 specifications. *

LIBSBML_CAT_SBO_CONSISTENCY: Consistency and validity of {@link SBO} * identifiers (if any) used in the model. With respect to the SBML * specification, these concern failures in applying the validation rules * numbered 107xx in the Level 2 Versions 2, 3 and 4 * specifications. *

LIBSBML_CAT_OVERDETERMINED_MODEL: Static analysis of * whether the system of equations implied by a model is mathematically * overdetermined. With respect to the SBML specification, this is * validation rule #10601 in the SBML Level 2 Versions 2, 3 * and 4 specifications. *

LIBSBML_CAT_MODELING_PRACTICE: Additional checks for * recommended good modeling practice. (These are tests performed by * libSBML and do not have equivalent SBML validation rules.) *

* By default, all validation checks are applied to the model in * an {@link SBMLDocument} object unless {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} is called to * indicate that only a subset should be applied. Further, this default * (i.e., performing all checks) applies separately to each new * {@link SBMLDocument} object created. In other words, each time a model * is read using {@link SBMLReader#readSBML(String filename)} , {@link SBMLReader#readSBMLFromString(String xml)} , * or the global functions readSBML() and readSBMLFromString(), a new * {@link SBMLDocument} is created and for that document, a call to * SBMLDocument.checkConsistency() will default to applying all possible checks. * Calling programs must invoke {@link SBMLDocument#setConsistencyChecks(int categ, boolean onoff)} for each such new * model if they wish to change the consistency checks applied. *

* @param category a value drawn from #SBMLErrorCategory_t indicating the * consistency checking/validation to be turned on or off *

* @param apply a boolean indicating whether the checks indicated by * category should be applied or not. *

* @see SBMLDocument#checkConsistency() */ public"; %javamethodmodifiers SBMLDocument::checkConsistency " /** * Performs consistency checking and validation on this SBML document. *

* If this method returns a nonzero value (meaning, one or more * consistency checks have failed for SBML document), the failures may be * due to warnings or errors. Callers should inspect the severity * flag in the individual {@link SBMLError} objects returned by * {@link SBMLDocument#getError(long n)} to determine the nature of the failures. *

* @return the number of failed checks (errors) encountered. *

* @see SBMLDocument#checkInternalConsistency() */ public"; %javamethodmodifiers SBMLDocument::checkInternalConsistency " /** * Performs consistency checking on libSBML\'s internal representation of * an SBML {@link Model}. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. *

* The distinction between this method and * SBMLDocument.checkConsistency() is that this method reports on * fundamental syntactic and structural errors that violate the XML * Schema for SBML; by contrast, SBMLDocument.checkConsistency() * performs more elaborate model verifications and also validation * according to the validation rules written in the appendices of the * SBML Level 2 Versions 2–4 specification documents. *

* @see SBMLDocument#checkConsistency() */ public"; %javamethodmodifiers SBMLDocument::checkL1Compatibility " /** * Performs a set of consistency checks on the document to establish * whether it is compatible with SBML Level 1 and can be converted * to Level 1. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. */ public"; %javamethodmodifiers SBMLDocument::checkL2v1Compatibility " /** * Performs a set of consistency checks on the document to establish * whether it is compatible with SBML Level 2 Version 1 and can * be converted to Level 2 Version 1. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. */ public"; %javamethodmodifiers SBMLDocument::checkL2v2Compatibility " /** * Performs a set of consistency checks on the document to establish * whether it is compatible with SBML Level 2 Version 2 and can * be converted to Level 2 Version 2. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. */ public"; %javamethodmodifiers SBMLDocument::checkL2v3Compatibility " /** * Performs a set of consistency checks on the document to establish * whether it is compatible with SBML Level 2 Version 3 and can * be converted to Level 2 Version 3. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. */ public"; %javamethodmodifiers SBMLDocument::checkL2v4Compatibility " /** * Performs a set of consistency checks on the document to establish * whether it is compatible with SBML Level 2 Version 4 and can * be converted to Level 2 Version 4. *

* Callers should query the results of the consistency check by calling * {@link SBMLDocument#getError(long n)} . *

* @return the number of failed checks (errors) encountered. */ public"; %javamethodmodifiers SBMLDocument::getError " /** * Returns the nth error or warning encountered during parsing, * consistency checking, or attempted translation of this model. *

* Callers can use method XMLError.getSeverity() on the result to assess * the severity of the problem. The possible severity levels range from * informational messages to fatal errors. *

* @return the error or warning indexed by integer n, or return * NULL if n > (getNumErrors() - 1). *

* @param n the integer index of the error sought. *

* @see SBMLDocument#getNumErrors() */ public"; %javamethodmodifiers SBMLDocument::getNumErrors() const " /** * Returns the number of errors or warnings encountered during parsing, * consistency checking, or attempted translation of this model. *

* @return the number of errors or warnings encountered */ public"; %javamethodmodifiers SBMLDocument::printErrors(std::ostream& stream = std::cerr) const " /** * Prints to the given output stream all the errors or warnings * encountered during parsing, consistency checking, or attempted * translation of this model. *

* If no errors have occurred, i.e., getNumErrors() == 0, no * output will be sent to the stream. *

* The format of the output is: *

   N error(s):
     line NNN: (id) message

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see SBMLDocument#getElementName() */ public"; %javamethodmodifiers SBMLDocument::getElementName() const " /** * Returns the XML element name of this object, which for {@link SBMLDocument}, * is always \'sbml\'. *

* @return the name of this element, i.e., \'sbml\'. */ public"; %javamethodmodifiers SBMLDocument::getErrorLog " /** * Returns the list of errors or warnings logged during parsing, * consistency checking, or attempted translation of this model. *

* @return the {@link SBMLErrorLog} used for this {@link SBMLDocument} *

* @see SBMLDocument#getNumErrors() */ public"; %javamethodmodifiers SBMLDocument::getNamespaces() const " /** * Returns a list of XML Namespaces associated with the XML content * of this SBML document. *

* @return the XML Namespaces associated with this SBML object */ public"; %javamethodmodifiers SBMLDocument::getElementPosition() const " /** * @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::conversion_errors(unsigned int errors) " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::hasStrictUnits " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLDocument::hasStrictSBO " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %typemap(javaimports) FunctionDefinition " /** * LibSBML implementation of SBML\'s FunctionDefinition construct. *

* The {@link FunctionDefinition} structure associates an identifier with a * function definition. This identifier can then be used as the function * called in subsequent MathML content elsewhere in an SBML model. *

* {@link FunctionDefinition} has one required attribute, \'id\', to give the * function a unique identifier by which other parts of an SBML model * definition can refer to it. A {@link FunctionDefinition} instance can also have * an optional \'name\' attribute of type string. Identifiers and names * must be used according to the guidelines described in the SBML * specification (e.g., Section 3.3 in the Level 2 Version 4 * specification). *

* {@link FunctionDefinition} has a required \'math\' subelement containing a MathML * expression defining the function body. The content of this element can * only be a MathML \'lambda\' element. The \'lambda\' element must begin with * zero or more \'bvar\' elements, followed by any other of the elements in * the MathML subset allowed in SBML Level 2 except \'lambda\' (i.e., a * \'lambda\' element cannot contain another \'lambda\' element). This is the * only place in SBML where a \'lambda\' element can be used. The function * defined by a {@link FunctionDefinition} is only available for use in other * MathML elements that follow the {@link FunctionDefinition} definition in the * model. (These restrictions prevent recursive and mutually-recursive * functions from being expressed.) *

* A further restriction on the content of \'math\' is that it cannot contain * references to variables other than the variables declared to the * \'lambda\' itself. That is, the contents of MathML \'ci\' elements inside * the body of the \'lambda\' can only be the variables declared by its * \'bvar\' elements, or the identifiers of other {@link FunctionDefinition} * instances earlier in the model. This means must be written so that all * variables or parameters used in the MathML content are passed to them * via their function parameters. *

* @note Function definitions (also informally known as user-defined * functions) were introduced in SBML Level 2. They have purposefully * limited capabilities. A function cannot reference parameters or other * model quantities outside of itself; values must be passed as parameters * to the function. Moreover, recursive and mutually-recursive functions * are not permitted. The purpose of these limitations is to balance power * against complexity of implementation. With the restrictions as they * are, function definitions could be implemented as textual * substitutions—they are simply macros. Software implementations * therefore do not need the full function-definition machinery typically * associated with programming languages. *

* @note Another important point to note is {@link FunctionDefinition} does not * have a separate attribute for defining the units of the value returned * by the function. The units associated with the function\'s return value, * when the function is called from within MathML expressions elsewhere in * SBML, are simply the overall units of the expression in * {@link FunctionDefinition}\'s \'math\' subelement when applied to the arguments * supplied in the call to the function. Ascertaining these units requires * performing dimensional analysis on the expression. (Readers may wonder * why there is no attribute. The reason is that having a separate * attribute for declaring the units would not only be redundant, but also * lead to the potential for having conflicting information. In the case * of a conflict between the declared units and those of the value actually * returned by the function, the only logical resolution rule would be to * assume that the correct units are those of the expression anyway.) *

* *

*/ " %typemap(javaimports) ListOfFunctionDefinitions " /** * LibSBML implementation of SBML\'s ListOfFunctionDefinitions construct. *

* The various ListOf___ classes in SBML are merely containers used for * organizing the main components of an SBML model. All are derived from * the abstract class {@link SBase}, and inherit the various attributes and * subelements of {@link SBase}, such as \'metaid\' as and \'annotation\'. The * ListOf___ classes do not add any attributes of their own. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* Readers may wonder about the motivations for using the ListOf___ * containers. A simpler approach in XML might be to place the components * all directly at the top level of the model definition. We chose instead * to group them within XML elements named after {@link ListOf}Classname, * in part because we believe this helps organize the components and makes * visual reading of models in XML easier. More importantly, the fact that * the container classes are derived from {@link SBase} means that software tools * can add information about the lists themselves into each list * container\'s \'annotation\'. *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers FunctionDefinition::FunctionDefinition( const std::string& id = "" , const std::string& formula = "" ) " /** * Creates a new {@link FunctionDefinition}, optionally with a given identifier * and mathematical formula. *

* @param id a string, the identifier of this {@link FunctionDefinition} instance * @param formula the formula of the function definition expressed as a * string in infix notation *

* @param id a string, the identifier of this {@link FunctionDefinition} instance *

* @param math the formula of the function definition expressed as an * AST. */ public"; %javamethodmodifiers FunctionDefinition::FunctionDefinition(unsigned int level, unsigned int version, XMLNamespaces* xmlns = 0) " /** * Creates a new {@link FunctionDefinition} using the given SBML level and version * values and optionally a set of {@link XMLNamespaces}. *

* @param level a long integer, the SBML Level to assign to this {@link FunctionDefinition} *

* @param version a long integer, the SBML Version to assign to this * {@link FunctionDefinition} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link FunctionDefinition} *

* @note Once a {@link FunctionDefinition} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link FunctionDefinition}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link FunctionDefinition} in * the list of function definitions. */ public"; %javamethodmodifiers FunctionDefinition::clone() const " /** * Creates and returns a deep copy of this {@link FunctionDefinition}. *

* @return a (deep) copy of this {@link FunctionDefinition}. */ public"; %javamethodmodifiers FunctionDefinition::getMath() const " /** * Get the mathematical formula of this {@link FunctionDefinition}. *

* @return an {@link ASTNode}, the value of the \'math\' subelement of this * {@link FunctionDefinition} */ public"; %javamethodmodifiers FunctionDefinition::isSetMath() const " /** * Predicate returning true or false depending on whether this * {@link FunctionDefinition}\'s \'math\' subelement contains a value. *

* @return true if the \'math\' for this {@link FunctionDefinition} has been set, * false otherwise. */ public"; %javamethodmodifiers FunctionDefinition::setMath(const ASTNode* math) " /** * Sets the \'math\' subelement of this {@link FunctionDefinition} to the Abstract * Syntax Tree given in math. *

* @param math an AST containing the mathematical expression to * be used as the formula for this {@link FunctionDefinition}. */ public"; %javamethodmodifiers FunctionDefinition::getArgument " /** * Get the nth argument to this function. *

* Callers should first find out the number of arguments to the function * by calling getNumArguments(). *

* @param n an integer index for the argument sought. *

* @return the nth argument (bound variable) passed to this * {@link FunctionDefinition}. *

* @see #getNumArguments() */ public"; %javamethodmodifiers FunctionDefinition::getArgument(const std::string& name) const " /** * Get the argument named name to this {@link FunctionDefinition}. *

* @param name the exact name (case-sensitive) of the sought-after * argument *

* @return the argument (bound variable) having the given name, or NULL if * no such argument exists. */ public"; %javamethodmodifiers FunctionDefinition::getBody() const " /** * Get the mathematical expression that is the body of this * {@link FunctionDefinition} object. *

* @return the body of this {@link FunctionDefinition} as an Abstract Syntax * Tree, or NULL if no body is defined. */ public"; %javamethodmodifiers FunctionDefinition::getBody " /** * Get the mathematical expression that is the body of this * {@link FunctionDefinition} object. *

* @return the body of this {@link FunctionDefinition} as an Abstract Syntax * Tree, or NULL if no body is defined. */ public"; %javamethodmodifiers FunctionDefinition::getNumArguments() const " /** * Get the number of arguments (bound variables) taken by this * {@link FunctionDefinition}. *

* @return the number of arguments (bound variables) that must be passed * to this {@link FunctionDefinition}. */ public"; %javamethodmodifiers FunctionDefinition::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers FunctionDefinition::getElementName() const " /** * Returns the XML element name of this object, which for * {@link FunctionDefinition}, is always \'functionDefinition\'. *

* @return the name of this element, i.e., \'functionDefinition\'. */ public"; %javamethodmodifiers FunctionDefinition::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers FunctionDefinition::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers FunctionDefinition::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers FunctionDefinition::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfFunctionDefinitions::clone() const " /** * Creates and returns a deep copy of this {@link ListOfFunctionDefinitions} instance. *

* @return a (deep) copy of this {@link ListOfFunctionDefinitions}. */ public"; %javamethodmodifiers ListOfFunctionDefinitions::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link FunctionDefinition} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfFunctionDefinitions}, the XML element name is * \'listOfFunctionDefinitions\'. *

* @return the name of this element, i.e., \'listOfFunctionDefinitions\'. */ public"; %javamethodmodifiers ListOfFunctionDefinitions::get(unsigned int n) " /** * Get a {@link FunctionDefinition} from the {@link ListOfFunctionDefinitions}. *

* @param n the index number of the {@link FunctionDefinition} to get. *

* @return the nth {@link FunctionDefinition} in this {@link ListOfFunctionDefinitions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::get " /** * Get a {@link FunctionDefinition} from the {@link ListOfFunctionDefinitions}. *

* @param n the index number of the {@link FunctionDefinition} to get. *

* @return the nth {@link FunctionDefinition} in this {@link ListOfFunctionDefinitions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::get(const std::string& sid) " /** * Get a {@link FunctionDefinition} from the {@link ListOfFunctionDefinitions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link FunctionDefinition} to get. *

* @return {@link FunctionDefinition} in this {@link ListOfFunctionDefinitions} * with the given id or NULL if no such * {@link FunctionDefinition} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::get(const std::string& sid) const " /** * Get a {@link FunctionDefinition} from the {@link ListOfFunctionDefinitions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link FunctionDefinition} to get. *

* @return {@link FunctionDefinition} in this {@link ListOfFunctionDefinitions} * with the given id or NULL if no such * {@link FunctionDefinition} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfFunctionDefinitions} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfFunctionDefinitions::remove(const std::string& sid) " /** * Removes item in this {@link ListOfFunctionDefinitions} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfFunctionDefinitions::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the * {@link ListOfFunctionDefinitions} in a model is (in SBML Level 2 Version 4) * the first ListOf___. (However, it differs for different Levels and * Versions of SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfFunctionDefinitions::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitKind_equals(UnitKind_t uk1, UnitKind_t uk2) " /** * Tests for logical equality between two given UnitKind_t values. *

* This function behaves exactly like C\'s == operator, except for * the following two cases: *

UNIT_KIND_LITER == UNIT_KIND_LITRE *

UNIT_KIND_METER == UNIT_KIND_METRE *

* C equality comparison would yield false (because each of the above is a * distinct enumeration value), but UnitKind_equals() returns true. *

* @param uk1 a UnitKind_t enumeration value * @param uk2 the UnitKind_t enumeration value to compare to uk1 *

* @return nonzero (for true) if uk1 is logically equivalent to uk2, * zero (0) otherwise. *

* @note For more information about the UnitKind_t enumeration, please * refer to the class documentation for {@link Unit}. */ public"; %javamethodmodifiers UnitKind_forName(const char *name) " /** * Converts a string to its corresponding UnitKind_t enumeration value. *

* @param name a string, the name of a predefined base unit in SBML *

* @return a value from UnitKind_t corresponding to the given name * (determined in a case-insensitive manner). *

* @note For more information about the UnitKind_t enumeration, please * refer to the class documentation for {@link Unit}. */ public"; %javamethodmodifiers UnitKind_toString(UnitKind_t uk) " /** * Converts a UnitKind_t enumeration value to a text string equivalent. *

* @param uk the UnitKind_t value to convert *

* @return the name of the given UnitKind. *

* @note The string returned is a static data value. The caller does not * own the returned string and is therefore not allowed to modify it. *

* @note For more information about the UnitKind_t enumeration, please * refer to the class documentation for {@link Unit}. */ public"; %javamethodmodifiers UnitKind_isValidUnitKindString(const char *string, unsigned int level, unsigned int version) " /** * Predicate for testing whether a given string corresponds to a * predefined UnitKind_t enumeration value. *

* @return nonzero (for true) if string is the name of a valid * UnitKind_t enumeration value, zero (0) otherwise. *

* @note For more information about the UnitKind_t enumeration, please * refer to the class documentation for {@link Unit}. */ public"; %typemap(javaimports) Unit " /** * LibSBML implementation of SBML\'s Unit construct. *

* The SBML unit definition facility uses two classes of objects, * {@link UnitDefinition} and {@link Unit}. The approach to defining units in SBML is * compositional; for example, meter second^–2 is * constructed by combining a {@link Unit} object representing meter with * another {@link Unit} object representing second^–2. * The combination is wrapped inside a {@link UnitDefinition}, which provides for * assigning an identifier and optional name to the combination. The * identifier can then be referenced from elsewhere in a model. Thus, the * {@link UnitDefinition} class is the container, and {@link Unit} instances are placed * inside {@link UnitDefinition} instances. *

* A {@link Unit} structure has four attributes named \'kind\', \'exponent\', \'scale\' * and \'multiplier\'. It represents a (possibly transformed) reference to a * base unit. The attribute \'kind\' on {@link Unit} indicates the chosen base unit. * Its value in SBML Level 2 Version 4 must be one of the following * predefined strings: *

*

ampere gram katal lux pascal tesla

becquerel gray kelvin meter radian volt

candela henry kilogram metre second watt

coulomb hertz liter mole siemens weber

dimensionless item litre newton sievert

farad joule lumen ohm steradian

*

* (See also the definition of the UNIT_KIND_ constants in the section below.) For SBML * Level 2 Version 1 models, the string Celsius is also * permitted. Note also that the table above contains two names not * strictly defined in SBML Level 2: liter and meter. For * convenience, libSBML defines the American English spellings of these * units, although the SBML specification limits the valid unit names to * those defined by SI. *

* The optional attribute named \'exponent\' on {@link Unit} represents an exponent * on the unit. Its default value is 1 (one). A {@link Unit} structure also * has an optional attribute called \'scale\'; its value must be an integer * exponent for a power-of-ten multiplier used to set the scale of the * unit. For example, a unit having a \'kind\' value of gram and a * \'scale\' value of -3 signifies 10^–3 * × gram, or milligrams. The default value of \'scale\' is 0 * (zero), because 10⁰ = 1. Lastly, the optional attribute * named \'multiplier\' can be used to multiply the kind unit by a * real-numbered factor; this enables the definition of units that are not * power-of-ten multiples of SI units. For instance, a multiplier of * 0.3048 could be used to define foot as a measure of length in terms * of a metre. The \'multiplier\' attribute has a default value of 1 * (one). *

UnitKind_t

* SBML defines a set of base units which serves as the starting point for * new unit definitions. This set of base units consists of the SI units * and a small number of additional convenience units. *

* In SBML Level 2 Versions before * Version 3, there existed an enumeration of units called * UnitKind. In Version 3, this enumeration was removed and the * identifier class UnitSId redefined to include the previous * UnitKind values as reserved symbols. This change has no net effect on * permissible models, their representation or their syntax. The purpose * of the change in the SBML specification was simply to clean up an * inconsistency about the contexts in which these values were usable. * However, LibSBML maintains UnitKind in the form of of a set of static * integer constants whose names begin with the characters * UNIT_KIND_. These constants are defined in the class * libsbmlConstants This * enumeration in libSBML has a small number of differences compared to the * SBML specifications: *

The alternate spelling \'meter\' is included in addition to the * official SI spelling \'metre\'. *
*
The alternate spelling \'liter\' is included in addition to the * official SI spelling \'litre\'. *
*
The unit \'Celsius\' is included because of its presence in * specifications of SBML prior to SBML Level 2 Version 3. *

* The table below lists the unit * constants defined in libSBML, and their meanings. *

Enumerator	Meaning
`UNIT_KIND_AMPERE`	The ampere unit
`UNIT_KIND_BECQUEREL`	The becquerel unit.
`UNIT_KIND_CANDELA`	The candela unit.
`UNIT_KIND_CELSIUS`	The Celsius unit.
`UNIT_KIND_COULOMB`	The coulomb unit.
`UNIT_KIND_DIMENSIONLESS`	A pseudo-unit indicating a dimensionless quantity. (This is in fact defined in the SBML specification.)
`UNIT_KIND_FARAD`	The farad unit.
`UNIT_KIND_GRAM`	The gram unit.
`UNIT_KIND_GRAY`	The gray unit.
`UNIT_KIND_HENRY`	The henry unit.
`UNIT_KIND_HERTZ`	The hertz unit.
`UNIT_KIND_ITEM`	A pseudo-unit representing a single \'thing\'. (This is in fact defined in the SBML specification.)
`UNIT_KIND_JOULE`	The joule unit.
`UNIT_KIND_KATAL`	The katal unit.
`UNIT_KIND_KELVIN`	The kelvin unit.
`UNIT_KIND_KILOGRAM`	The kilogram unit.
`UNIT_KIND_LITER`	Alternate spelling of litre.
`UNIT_KIND_LITRE`	The litre unit.
`UNIT_KIND_LUMEN`	The lumen unit.
`UNIT_KIND_LUX`	The lux unit.
`UNIT_KIND_METER`	Alternate spelling of metre.
`UNIT_KIND_METRE`	The metre unit.
`UNIT_KIND_MOLE`	The mole unit.
`UNIT_KIND_NEWTON`	The newton unit.
`UNIT_KIND_OHM`	The ohm unit.
`UNIT_KIND_PASCAL`	The pascal unit.
`UNIT_KIND_RADIAN`	The radian unit.
`UNIT_KIND_SECOND`	The second unit.
`UNIT_KIND_SIEMENS`	The siemens unit.
`UNIT_KIND_SIEVERT`	The sievert unit.
`UNIT_KIND_STERADIAN`	The steradian unit.
`UNIT_KIND_TESLA`	The tesla unit.
`UNIT_KIND_VOLT`	The volt unit.
`UNIT_KIND_WATT`	The watt unit.
`UNIT_KIND_WEBER`	The weber unit.
`UNIT_KIND_INVALID`	Marker used by libSBML to indicate an invalid or unset unit.

* */ " %typemap(javaimports) ListOfUnits " /** * LibSBML implementation of SBML\'s ListOfUnits construct. *

* {@link ListOfUnits} is entirely contained within {@link UnitDefinition}. */ " %javamethodmodifiers Unit::Unit( UnitKind_t kind = UNIT_KIND_INVALID , int exponent = 1 , int scale = 0 , double multiplier = 1.0 ) " /** * Creates a new {@link Unit}, optionally with specific values of kind, * exponent, scale and multipler. *

* If no * arguments are passed to this constructor, the value of kind * defaults to UNIT_KIND_INVALID. Callers must reset the value to * something appropriate using the method {@link Unit#setKind(int kind)}. * The use of arguments to this constructor is functionally * equivalent to the following: *

   *   {@link Unit} u = new {@link Unit}();
   *   u.setKind(kind);
   *   u.setExponent(exponent);
   *   u.setScale(scale);
   *   u.setMultiplier(multipler);

* Readers are urged to read the description of the {@link Unit} class (both the * beginning of this page, and in the SBML specification documents) for * more information about the meaning of the arguments to this * constructor. *

* @param kind a value from the * set of static integer constants having names beginning with the * characters UNIT_KIND_ in libsbmlConstants *

* @param exponent an integer, the \'exponent\' attribute of the unit * definition *

* @param scale an integer, the \'scale\' attribute of the unit definition *

* @param multiplier a double, the \'multiplier\' attribute of the unit * definition *

* This * method accepts a unit kind name as a string, and internally converts * it to the appropriate UNIT_KIND_ constants from libsbmlConstants. If the * string passed as the value of kind is not recognized as a valid * unit name, this method sets the value to UNIT_KIND_INVALID. The * following table lists the valid unit kind names: *

* In addition to the strings above, the string Celsius is * accepted for models in SBML Level 2 Version 1 format. *

* @param kind a string whose value is a valid unit name *

* @param exponent an integer, the \'exponent\' attribute of the unit * definition *

* @param scale an integer, the \'scale\' attribute of the unit definition *

* @param multiplier a double, the \'multiplier\' attribute of the unit * definition *

* @param level a long integer, the SBML Level to assign to this {@link Unit} *

* @param version a long integer, the SBML Version to assign to this * {@link Unit} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Unit} *

* @note Once a {@link Unit} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Unit}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link Unit} in the list * of units within which this {@link Unit} is embedded (i.e., in the {@link ListOfUnits} * located in the enclosing {@link UnitDefinition} instance). */ public"; %javamethodmodifiers Unit::clone() const " /** * Creates and returns a deep copy of this {@link Unit}. *

* @return a (deep) copy of this {@link Unit}. */ public"; %javamethodmodifiers Unit::initDefaults " /** * Initializes the attributes of this {@link Unit} (except for \'kind\') to their * defaults values. *

* The default values are as follows: *

exponent = 1 *

scale = 0 *

multiplier = 1.0 *

* The \'kind\' attribute is left unchanged. */ public"; %javamethodmodifiers Unit::getKind() const " /** * Returns the \'kind\' of {@link Unit} this is. *

* @return the value of the \'kind\' attribute of this {@link Unit} as a value from * the UnitKind_t enumeration */ public"; %javamethodmodifiers Unit::getExponent() const " /** * Returns the value of the \'exponent\' attribute of this unit. *

* @return the \'exponent\' value of this {@link Unit}, as an integer */ public"; %javamethodmodifiers Unit::getScale() const " /** * Returns the value of the \'scale\' attribute of this unit. *

* @return the \'scale\' value of this {@link Unit}, as an integer. */ public"; %javamethodmodifiers Unit::getMultiplier() const " /** * Returns the value of the \'multiplier\' attribute of this {@link Unit}. *

* @return the \'multiplier\' value of this {@link Unit}, as a double */ public"; %javamethodmodifiers Unit::getOffset() const " /** * Returns the value of the \'offset\' attribute of this {@link Unit}. *

* @warning The \'offset\' attribute is only available in SBML Level 2 * Version 1. This attribute is not present in SBML Level 2 * Version 2 or above. When producing SBML models using these later * specifications, modelers and software tools need to account for units * with offsets explicitly. The SBML specification document offers a * number of suggestions for how to achieve this. LibSBML methods such * as this one related to \'offset\' are retained for compatibility with * earlier versions of SBML Level 2, but their use is strongly * discouraged. *

* @return the \'offset\' value of this {@link Unit}, as a double */ public"; %javamethodmodifiers Unit::isAmpere() const " /** * Predicate for testing whether this {@link Unit} is of the kind ampere. *

* @return true if the kind of this {@link Unit} is ampere, false * otherwise. */ public"; %javamethodmodifiers Unit::isBecquerel() const " /** * Predicate for testing whether this {@link Unit} is of the kind becquerel *

* @return true if the kind of this {@link Unit} is becquerel, false * otherwise. */ public"; %javamethodmodifiers Unit::isCandela() const " /** * Predicate for testing whether this {@link Unit} is of the kind candela *

* @return true if the kind of this {@link Unit} is candela, false * otherwise. */ public"; %javamethodmodifiers Unit::isCelsius() const " /** * Predicate for testing whether this {@link Unit} is of the kind Celsius *

* @return true if the kind of this {@link Unit} is Celsius, false * otherwise. *

* @warning The predefined unit Celsius was removed from the list of * predefined units in SBML Level 2 Version 2 at the same time * that the \'offset\' attribute was removed from {@link Unit} definitions. * LibSBML methods such as this one related to Celsius are retained in * order to support SBML Level 2 Version 1, but their use is * strongly discouraged. */ public"; %javamethodmodifiers Unit::isCoulomb() const " /** * Predicate for testing whether this {@link Unit} is of the kind coulomb *

* @return true if the kind of this {@link Unit} is coulomb, false * otherwise. */ public"; %javamethodmodifiers Unit::isDimensionless() const " /** * Predicate for testing whether this {@link Unit} is of the kind * dimensionless *

* @return true if the kind of this {@link Unit} is dimensionless, false *

* otherwise. */ public"; %javamethodmodifiers Unit::isFarad() const " /** * Predicate for testing whether this {@link Unit} is of the kind farad *

* @return true if the kind of this {@link Unit} is farad, false * otherwise. */ public"; %javamethodmodifiers Unit::isGram() const " /** * Predicate for testing whether this {@link Unit} is of the kind gram *

* @return true if the kind of this {@link Unit} is gram, false * otherwise. */ public"; %javamethodmodifiers Unit::isGray() const " /** * Predicate for testing whether this {@link Unit} is of the kind gray *

* @return true if the kind of this {@link Unit} is gray, false * otherwise. */ public"; %javamethodmodifiers Unit::isHenry() const " /** * Predicate for testing whether this {@link Unit} is of the kind henry *

* @return true if the kind of this {@link Unit} is henry, false * otherwise. */ public"; %javamethodmodifiers Unit::isHertz() const " /** * Predicate for testing whether this {@link Unit} is of the kind hertz *

* @return true if the kind of this {@link Unit} is hertz, false * otherwise. */ public"; %javamethodmodifiers Unit::isItem() const " /** * Predicate for testing whether this {@link Unit} is of the kind item *

* @return true if the kind of this {@link Unit} is item, false * otherwise. */ public"; %javamethodmodifiers Unit::isJoule() const " /** * Predicate for testing whether this {@link Unit} is of the kind joule *

* @return true if the kind of this {@link Unit} is joule, false * otherwise. */ public"; %javamethodmodifiers Unit::isKatal() const " /** * Predicate for testing whether this {@link Unit} is of the kind katal *

* @return true if the kind of this {@link Unit} is katal, false * otherwise. */ public"; %javamethodmodifiers Unit::isKelvin() const " /** * Predicate for testing whether this {@link Unit} is of the kind kelvin *

* @return true if the kind of this {@link Unit} is kelvin, false * otherwise. */ public"; %javamethodmodifiers Unit::isKilogram() const " /** * Predicate for testing whether this {@link Unit} is of the kind kilogram *

* @return true if the kind of this {@link Unit} is kilogram, false * otherwise. */ public"; %javamethodmodifiers Unit::isLitre() const " /** * Predicate for testing whether this {@link Unit} is of the kind litre *

* @return true if the kind of this {@link Unit} is litre or \'liter\', * false * otherwise. */ public"; %javamethodmodifiers Unit::isLumen() const " /** * Predicate for testing whether this {@link Unit} is of the kind lumen *

* @return true if the kind of this {@link Unit} is lumen, false * otherwise. */ public"; %javamethodmodifiers Unit::isLux() const " /** * Predicate for testing whether this {@link Unit} is of the kind lux *

* @return true if the kind of this {@link Unit} is lux, false * otherwise. */ public"; %javamethodmodifiers Unit::isMetre() const " /** * Predicate for testing whether this {@link Unit} is of the kind metre *

* @return true if the kind of this {@link Unit} is metre or \'meter\', * false * otherwise. */ public"; %javamethodmodifiers Unit::isMole() const " /** * Predicate for testing whether this {@link Unit} is of the kind mole *

* @return true if the kind of this {@link Unit} is mole, false * otherwise. */ public"; %javamethodmodifiers Unit::isNewton() const " /** * Predicate for testing whether this {@link Unit} is of the kind newton *

* @return true if the kind of this {@link Unit} is newton, false * otherwise. */ public"; %javamethodmodifiers Unit::isOhm() const " /** * Predicate for testing whether this {@link Unit} is of the kind ohm *

* @return true if the kind of this {@link Unit} is ohm, false * otherwise. */ public"; %javamethodmodifiers Unit::isPascal() const " /** * Predicate for testing whether this {@link Unit} is of the kind pascal *

* @return true if the kind of this {@link Unit} is pascal, false * otherwise. */ public"; %javamethodmodifiers Unit::isRadian() const " /** * Predicate for testing whether this {@link Unit} is of the kind radian *

* @return true if the kind of this {@link Unit} is radian, false * otherwise. */ public"; %javamethodmodifiers Unit::isSecond() const " /** * Predicate for testing whether this {@link Unit} is of the kind second *

* @return true if the kind of this {@link Unit} is second, false * otherwise. */ public"; %javamethodmodifiers Unit::isSiemens() const " /** * Predicate for testing whether this {@link Unit} is of the kind siemens *

* @return true if the kind of this {@link Unit} is siemens, false * otherwise. */ public"; %javamethodmodifiers Unit::isSievert() const " /** * Predicate for testing whether this {@link Unit} is of the kind sievert *

* @return true if the kind of this {@link Unit} is sievert, false * otherwise. */ public"; %javamethodmodifiers Unit::isSteradian() const " /** * Predicate for testing whether this {@link Unit} is of the kind steradian *

* @return true if the kind of this {@link Unit} is steradian, false * otherwise. */ public"; %javamethodmodifiers Unit::isTesla() const " /** * Predicate for testing whether this {@link Unit} is of the kind tesla *

* @return true if the kind of this {@link Unit} is tesla, false * otherwise. */ public"; %javamethodmodifiers Unit::isVolt() const " /** * Predicate for testing whether this {@link Unit} is of the kind volt *

* @return true if the kind of this {@link Unit} is volt, false * otherwise. */ public"; %javamethodmodifiers Unit::isWatt() const " /** * Predicate for testing whether this {@link Unit} is of the kind watt *

* @return true if the kind of this {@link Unit} is watt, false * otherwise. */ public"; %javamethodmodifiers Unit::isWeber() const " /** * Predicate for testing whether this {@link Unit} is of the kind weber *

* @return true if the kind of this {@link Unit} is weber, false * otherwise. */ public"; %javamethodmodifiers Unit::isSetKind() const " /** * Predicate to test whether the \'kind\' attribute of this {@link Unit} has been set. *

* @return true if the \'kind\' attribute of this {@link Unit} has been set, * false otherwise. */ public"; %javamethodmodifiers Unit::setKind(UnitKind_t kind) " /** * Sets the \'kind\' attribute value of this {@link Unit}. *

* @param kind a value from the UnitKind_t enumeration */ public"; %javamethodmodifiers Unit::setExponent(int value) " /** * Sets the \'exponent\' attribute value of this {@link Unit}. *

* @param value the integer to which the attribute \'exponent\' should be set */ public"; %javamethodmodifiers Unit::setScale(int value) " /** * Sets the \'scale\' attribute value of this {@link Unit}. *

* @param value the integer to which the attribute \'scale\' should be set */ public"; %javamethodmodifiers Unit::setMultiplier(double value) " /** * Sets the \'multipler\' attribute value of this {@link Unit}. *

* @param value the floating-point value to which the attribute * \'multiplier\' should be set */ public"; %javamethodmodifiers Unit::setOffset(double value) " /** * Sets the \'offset\' attribute value of this {@link Unit}. *

* @param value the float-point value to which the attribute \'offset\' * should set *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Unit::getElementName() const " /** * Returns the XML element name of this object, which for {@link Unit}, is * always \'unit\'. *

* @return the name of this element, i.e., \'unit\'. */ public"; %javamethodmodifiers Unit::isBuiltIn(const std::string& name, unsigned int level) " /** * Predicate to test whether a given string is the name of a * predefined SBML unit. *

* @param name a string to be tested against the predefined unit names *

* @param level the Level of SBML for which the determination should be * made. This is necessary because there are a few small differences * in allowed units between SBML Level 1 and Level 2. *

* @return true if name is one of the five SBML predefined unit * identifiers (\'substance\', \'volume\', \'area\', \'length\' or * \'time\'), false otherwise. *

* @note The predefined unit identifiers \'length\' and \'area\' were * added in Level 2 Version 1 */ public"; %javamethodmodifiers Unit::isUnitKind(const std::string& name, unsigned int level, unsigned int version) " /** * Predicate to test whether a given string is the name of a valid * base unit in SBML (such as \'gram\' or \'mole\'). *

* This method exists because prior to SBML Level 2 Version 3, * an enumeration called UnitKind was defined by SBML. This enumeration * was removed in SBML Level 2 Version 3 and its values were * folded into the space of values of a type called UnitSId. This method * therefore has less significance in SBML Level 2 Version 3 * and Level 2 Version 4, but remains for backward * compatibility and support for reading models in older Versions of * Level 2. *

* @param name a string to be tested *

* @param level a long integer representing the SBML specification * Level *

* @param version a long integer representing the SBML specification * Version *

* @return true if name is a valid UnitKind, false otherwise *

* @note The allowed unit names differ between SBML Levels 1 * and 2 and again slightly between Level 2 Versions 1 * and 2. */ public"; %javamethodmodifiers Unit::areIdentical(Unit * unit1, Unit * unit2) " /** * Predicate returning true or false depending on whether two * {@link Unit} objects are identical. *

* Two {@link Unit} objects are considered to be identical if they match in * all attributes. (Contrast this to the method * {@link Unit#areEquivalent(Unit unit1, Unit unit2)}, which compares * {@link Unit} objects only with respect to certain attributes.) *

* @param unit1 the first {@link Unit} object to compare * @param unit2 the second {@link Unit} object to compare *

* @return true if all the attributes of unit1 are identical * to the attributes of unit2, false otherwise. *

* @see #areEquivalent(Unit unit1, Unit unit2) */ public"; %javamethodmodifiers Unit::areEquivalent(Unit * unit1, Unit * unit2) " /** * Predicate returning true or false depending on whether * {@link Unit} objects are equivalent. *

* Two {@link Unit} objects are considered to be equivalent if their \'kind\' * and \'exponent\' attributes are equal. (Contrast this to the method * {@link Unit#areIdentical(Unit unit1, Unit unit2)}, which compares {@link Unit} * objects with respect to all attributes, not just the kind and * exponent.) *

* @param unit1 the first {@link Unit} object to compare * @param unit2 the second {@link Unit} object to compare *

* @return true if the \'kind\' and \'exponent\' attributes of unit1 are * identical to the kind and exponent attributes of unit2, false * otherwise. *

* @see #areIdentical(Unit unit1, Unit unit2) */ public"; %javamethodmodifiers Unit::removeScale(Unit * unit) " /** * Manipulates the attributes of the {@link Unit} to express the unit with the * value of the scale attribute reduced to zero. *

* For example, 1 millimetre can be expressed as a {@link Unit} with kind= * \'metre\' multiplier=\'1\' scale=\'-3\' exponent=\'1\'. It can also be * expressed as a {@link Unit} with kind=\'metre\' * multiplier=\'0.001\' scale=\'0\' exponent=\'1\'. *

* @param unit the {@link Unit} object to manipulate. */ public"; %javamethodmodifiers Unit::merge(Unit * unit1, Unit * unit2) " /** * Merges two {@link Unit} objects with the same \'kind\' attribute value into a * single {@link Unit}. *

* For example, the following, *

  * <unit kind=\'metre\' exponent=\'2\'/>
  * <unit kind=\'metre\' exponent=\'1\'/>

* would be merged to become *

  * <unit kind=\'metre\' exponent=\'3\'/>

* @param unit1 the first {@link Unit} object; the result of the operation is * left as a new version of this unit, modified in-place. *

* @param unit2 the second {@link Unit} object to merge with the first */ public"; %javamethodmodifiers Unit::convertToSI(const Unit * unit) " /** * Returns a {@link UnitDefinition} object which contains the argument {@link Unit} * converted to the appropriate SI unit. *

* @param unit the {@link Unit} object to convert to SI *

* @return a {@link UnitDefinition} object containing the SI unit. */ public"; %javamethodmodifiers Unit::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Unit::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Unit::isL1UnitKind(const std::string& name) " /** * Predicate to test whether a given string is the name of a valid * base unit in SBML Level 1 (such as \'gram\' or \'mole\') *

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @deprecated libSBML internal */ public"; %javamethodmodifiers Unit::isL2V1UnitKind(const std::string& name) " /** * Predicate to test whether a given string is the name of a valid base * unit in SBML Level 2 Version 1 (such as \'gram\' or * \'mole\') *

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @deprecated libSBML internal */ public"; %javamethodmodifiers Unit::isL2UnitKind(const std::string& name) " /** * Predicate to test whether a given string is the name of a valid base * unit in SBML Level 2 Version 2, 3 or 4 (such as \'gram\' or * \'mole\') *

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @param name a string to be tested *

* @return true if name is a valid UnitKind, false otherwise

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfUnits::clone() const " /** * Creates and returns a deep copy of this {@link ListOfUnits}. *

* @return a (deep) copy of this {@link ListOfUnits}. */ public"; %javamethodmodifiers ListOfUnits::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfUnits::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Unit} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfUnits::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfUnits}, the XML element name is \'listOfUnits\'. *

* @return the name of this element, i.e., \'listOfUnits\'. */ public"; %javamethodmodifiers ListOfUnits::get(unsigned int n) " /** * Get a {@link Unit} from the {@link ListOfUnits}. *

* @param n the index number of the {@link Unit} to get. *

* @return the nth {@link Unit} in this {@link ListOfUnits}. *

* @see #size() */ public"; %javamethodmodifiers ListOfUnits::get " /** * Get a {@link Unit} from the {@link ListOfUnits}. *

* @param n the index number of the {@link Unit} to get. *

* @return the nth {@link Unit} in this {@link ListOfUnits}. *

* @see #size() */ public"; %javamethodmodifiers ListOfUnits::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfUnits} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfUnits::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfUnits::createObject(XMLInputStream& stream) " /** * Create a {@link ListOfUnits} object corresponding to the next token * in the XML input stream. *

* @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream, or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) UnitDefinition " /** * LibSBML implementation of SBML\'s UnitDefinition construct. *

* Units of measurement may be supplied in a number of contexts in an SBML * model. The units of the following mathematical entities can be * specified explicitly: the size of a compartment, the initial amount of a * species, and the units of constant and variable parameter values. The * overall units of any mathematical formula appearing in SBML are those * that arise naturally from the components and mathematical expressions * comprising the formula, or in other words, the units obtained by doing * dimensional analysis on the formula. *

* Rather than requiring a complete unit definition on every construct, * SBML provides a facility for defining units that can be referenced * throughout a model. In addition, every kind of SBML mathematical * entity has units assigned to it from a set of predefined defaults (listed * below); by redefining these predefined default units, it is possible to * change the units used throughout a model in a simple and consistent * manner. *

Summary of the {@link UnitDefinition} construct

* {@link UnitDefinition} in SBML Level 2 has two attributes and one * subelement. The two attributes are \'id\' and \'name\', and the subelement * is {@link ListOfUnits}. *

* The required attribute \'id\' and optional attribute \'name\' are both * strings. The \'id\' attribute is used to give the defined unit a unique * identifier by which other parts of an SBML model definition can refer to * it. The \'name\' attribute is intended to be used for giving the unit * definition an optional human-readable name. *

* There are two important restrictions about the use of unit definition * \'id\' values in SBML Level 2 Versions 3–4: *

The \'id\' of a {@link UnitDefinition} must not contain a value from the * list of reserved base unit names (i.e., the strings gram, liter, * etc.; see the definition of {@link Unit} for the complete list). This * constraint simply prevents the redefinition of the base units. *
*

There is a set of reserved identifiers for the predefined * units in SBML; these identifiers are substance, volume, area, * length, and time. Using one of these values for the attribute * \'id\' of a {@link UnitDefinition} has the effect of redefining the model-wide * default units for the corresponding quantities. The list of * predefined units is given in the table below: *

Identifier	Possible scalable units	Default units
`substance`	mole, item, gram, kilogram, dimensionless	mole
`volume`	litre, cubic metre, dimensionless	litre
`area`	square metre, dimensionless	square metre
`length`	metre, dimensionless	metre
`time`	second, dimensionless	second

* Also, two limitations are imposed on redefining the predefined * unit substance, volume, area, length, and time: * (1) The {@link UnitDefinition} of a predefined SBML unit can only * contain a single {@link Unit} object within it. * (2) The value of the \'kind\' attribute in * a {@link Unit} instance must be drawn from one of the values * in the second column of the table above. *

* A {@link UnitDefinition} must contain exactly one {@link ListOfUnits}, and this list * must contain one or more {@link Unit} definitions; see the definitions of these * other object classes for more information about them. The following * example illustrates a complete unit definition (when written in XML) * when they all the pieces are combined together. This defines \'mmls\' * to be millimoles per litre per second. *

 * <listOfUnitDefinitions>
 *     <unitDefinition id=\'mmls\'>
 *         <listOfUnits>
 *             <unit kind=\'mole\'   scale=\'-3\'/>
 *             <unit kind=\'litre\'  exponent=\'-1\'/>
 *             <unit kind=\'second\' exponent=\'-1\'/>
 *         </listOfUnits>
 *     </unitDefinition>
 * </listOfUnitDefinitions>

Further comments about SBML\'s unit definition system

* The vast majority of modeling situations requiring new SBML unit * definitions involve simple multiplicative combinations of base units and * factors. An example of this might be moles per litre per * second. What distinguishes these sorts of simpler unit definitions * from more complex ones is that they may be expressed without the use of * an additive offset from a zero point. The use of offsets complicates * all unit definition systems, yet in the domain of SBML the real-life * cases requiring offsets are few (and in fact, to the best of our * knowledge, only involve temperature). Consequently, the SBML unit * system has been consciously designed in a way that attempts to simplify * implementation of unit support for the most common cases in systems * biology. *

* As of SBML Level 2 Version 2, {@link Unit} no longer has the * attribute called \'offset\' introduced in SBML Level 2 * Version 1. It turned out that the general case involving units * with offsets was incorrectly defined, and few (if any) developers even * attempted to support offset-based units in their software. In the * development of Level 2 Version 2, a consensus among SBML * developers emerged that a fully generalized unit scheme is so * confusing and complicated that it actually impedes interoperability. * SBML Level 2 Version 2, Version 3 and Version 4 acknowledge this * reality by reducing and simplifying the unit system, specifically by * removing the \'offset\' attribute on {@link Unit} and Celsius as a pre-defined * unit. *

* The following guidelines suggest methods for handling units that do * require the use of zero offsets for their definitions: *

Handling Celsius. A model in which certain quantities are * temperatures measured in degrees Celsius can be converted * straightforwardly to a model in which those temperatures are in * kelvin. A software tool could do this by performing a straightforward * substitution using the following relationship: T_kelvin = * T_Celsius + 273.15. In every mathematical formula of the * model where a quantity (call it x) in degrees Celsius appears, * replace x with x_k+ 273.15, where x_k is now * in kelvin. An alternative approach would be to use a * {@link FunctionDefinition} to define a function encapsulating this * relationship above and then using that in the rest of the model as * needed. Since Celsius is a commonly-used unit, software tools could * help users by providing users with the ability to express temperatures * in Celsius in the tools\' interfaces, and making substitutions * automatically when writing out the SBML. *
*

Other units requiring offsets. One approach to handling * other kinds of units is to use a {@link FunctionDefinition} to define a function * encapsulating the necessary mathematical relationship, then * substituting a call to this function wherever the original quantity * appeared in the model. For example, here is a possible definition for * converting Fahrenheit to Celsius degrees: *

 * <functionDefinition id=\'Fahrenheit_to_kelvin\'>
 *     <math xmlns=\'http://www.w3.org/1998/Math/MathML\'>
 *         <lambda>
 *             <bvar><ci> temp_in_fahrenheit </ci></bvar>
 *             <apply>
 *                 <divide/>
 *                 <apply>
 *                     <plus/>
 *                     <ci> temp_in_fahrenheit </ci>
 *                     <cn> 459.67 </cn>
 *                 </apply>
 *                 <cn> 1.8 </cn>
 *             </apply>
 *         </lambda>
 *     </math>
 * </functionDefinition>

An alternative approach not requiring the use of function definitions * is to use an {@link AssignmentRule} for each variable in Fahrenheit units. * The {@link AssignmentRule} could compute the conversion from Fahrenheit to * (say) kelvin, assign its value to a variable (in Kelvin units), and * then that variable could be used elsewhere in the model. *
*
Still another approach is to rewrite the mathematical formulas of a * model to directly incorporate the conversion formula wherever the * original quantity appeared. *

* Please consult the SBML specifications for more information about this * and other issues involving units. *

* */ " %typemap(javaimports) ListOfUnitDefinitions " /** * LibSBML implementation of SBML\'s ListOfUnitDefinitions construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers UnitDefinition::UnitDefinition(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link UnitDefinition} instance, optionally with specific values * of id and name. *

* The permitted values of the identifier id exclude the * predefined base units in SBML and two spelling variants \'meter\' and * \'liter\'. More specifically, the following is the set of base unit * names which are excluded from being used as a value of id: *

* In addition, there is a set of reserved identifiers for the predefined * default units in SBML. These identifiers are substance, volume, * area, length, and time. Using one of these values for the * attribute id of a {@link UnitDefinition} has the special meaning of * redefining the model-wide default units for the corresponding * quantities. The list of reserved unit names is given in the table below: *

Identifier	Possible scalable units	Default units
`substance`	mole, item, gram, kilogram, dimensionless	mole
`volume`	litre, cubic metre, dimensionless	litre
`area`	square metre, dimensionless	square metre
`length`	metre, dimensionless	metre
`time`	second, dimensionless	second

* Finally, note that SBML imposes two limitations on redefining the * predefined units listed above: *

The {@link UnitDefinition} of a predefined SBML unit can only * contain a single {@link Unit} object within it. *
The value of the \'kind\' attribute in * a {@link Unit} instance must be drawn from one of the values * in the second column of the table above. *

* @param id the identifier to assign to the new unit definition. *

* @param name an optional name to assign to the new unit definition. *

* @param level a long integer, the SBML Level to assign to this {@link UnitDefinition} *

* @param version a long integer, the SBML Version to assign to this * {@link UnitDefinition} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link UnitDefinition} *

* @note Once a {@link UnitDefinition} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link UnitDefinition}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link UnitDefinition} in the * list of units within which this {@link UnitDefinition} is embedded (i.e., in * the {@link ListOfUnitDefinitions} located in the enclosing {@link Model} instance). */ public"; %javamethodmodifiers UnitDefinition::clone() const " /** * Creates and returns a deep copy of this {@link UnitDefinition}. *

* @return a (deep) copy of this {@link UnitDefinition}. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfArea() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'area\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit area, meaning square metres with only abritrary variations * in scale or multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfLength() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'length\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit length, meaning metres with only abritrary variations in scale * or multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfSubstance() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'substance\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit substance, meaning moles or items (and grams or kilograms from * SBML Level 2 Version 2 onwards) with only abritrary variations * in scale or multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfTime() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'time\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit time, meaning seconds with only abritrary variations in scale or * multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfVolume() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'volume\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit volume, meaning litre or cubic metre with only abritrary * variations in scale or multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfDimensionless() const " /** * Convenience function for testing if a given unit definition is a * variant of the unit \'dimensionless\'. *

* @return true if this {@link UnitDefinition} is a variant of * dimensionless, meaning dimensionless with only abritrary variations in * scale or multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfMass() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit identifier \'mass\'. *

* @return true if this {@link UnitDefinition} is a variant of mass units, * meaning gram or kilogram with only abritrary variations in scale or * multiplier values; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::isVariantOfSubstancePerTime() const " /** * Convenience function for testing if a given unit definition is a * variant of the predefined unit \'substance\' divided by the predefined * unit \'time\'. *

* @return true if this {@link UnitDefinition} is a variant of the predefined * unit substance per predefined unit time, meaning it contains two * units one of which is a variant of substance and the other is a * variant of time which an exponent of -1; false otherwise. */ public"; %javamethodmodifiers UnitDefinition::addUnit(const Unit* u) " /** * Adds a copy of the given {@link Unit} to this {@link UnitDefinition}. *

* @param u the {@link Unit} instance to add to this {@link UnitDefinition}. *

* @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 in this {@link UnitDefinition}. Changes made to the original * object instance (such as resetting attribute values) will not * affect the instance in the {@link UnitDefinition}. 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 * UnitDefinition.createUnit() for a method that does not lead to these * issues. *

* @see #createUnit() */ public"; %javamethodmodifiers UnitDefinition::createUnit " /** * Creates a new and empty {@link Unit}, adds it to this {@link UnitDefinition}\'s list of * units, and returns it. *

* @return a newly constructed (and empty) {@link Unit} instance. *

* @note It is worth emphasizing that the attribute \'kind\' value of a * {@link Unit} is a required attribute for a valid {@link Unit} definition. The * createUnit() method does not assign a valid kind to the constructed * unit (instead, it sets the \'kind\' to UNIT_KIND_INVALID). Callers * are cautioned to set the newly-constructed {@link Unit}\'s kind using * Unit.setKind() soon after calling this method. *

* @see #addUnit(Unit u) */ public"; %javamethodmodifiers UnitDefinition::getListOfUnits() const " /** * Returns the list of Units for this {@link UnitDefinition} instance. * @return the {@link ListOfUnits} value for this {@link UnitDefinition}. */ public"; %javamethodmodifiers UnitDefinition::getListOfUnits " /** * Returns the list of Units for this {@link UnitDefinition} instance. * @return the {@link ListOfUnits} value for this {@link UnitDefinition}. */ public"; %javamethodmodifiers UnitDefinition::getUnit(unsigned int n) " /** * Returns a specific {@link Unit} instance belonging to this {@link UnitDefinition}. *

* @param n an integer, the index of the {@link Unit} to be returned. *

* @return the nth {@link Unit} of this {@link UnitDefinition} *

* @see #getNumUnits() */ public"; %javamethodmodifiers UnitDefinition::getUnit " /** * Returns a specific {@link Unit} instance belonging to this {@link UnitDefinition}. *

* @param n an integer, the index of the {@link Unit} to be returned. *

* @return the nth {@link Unit} of this {@link UnitDefinition} */ public"; %javamethodmodifiers UnitDefinition::getNumUnits() const " /** * Returns the number of {@link Unit} objects contained within this * {@link UnitDefinition}. *

* @return an integer representing the number of Units in this * {@link UnitDefinition}. */ public"; %javamethodmodifiers UnitDefinition::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::getTypeCode() const " /** * Returns the libSBML type code for this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers UnitDefinition::getElementName() const " /** * Returns the XML element name of this object, which for {@link UnitDefinition}, * is always \'unitDefinition\'. *

* @return the name of this element, i.e., \'unitDefinition\'. */ public"; %javamethodmodifiers UnitDefinition::simplify(UnitDefinition * ud) " /** * Simplifies the {@link UnitDefinition} so that any {@link Unit} objects occurring within * the {@link ListOfUnits} occurs only once. *

* For example, the following definition, *

  * <unitDefinition>
  *  <listOfUnits>
  *    <unit kind=\'metre\' exponent=\'1\'/>
  *    <unit kind=\'metre\' exponent=\'2\'/>
  *  </listOfUnits>
  * <unitDefinition>

* will be simplified to *

  * <unitDefinition>
  *   <listOfUnits>
  *     <unit kind=\'metre\' exponent=\'3\'/>
  *   </listOfUnits>
  * <unitDefinition>

* @param ud the {@link UnitDefinition} object to be simplified. */ public"; %javamethodmodifiers UnitDefinition::reorder(UnitDefinition * ud) " /** * Orders alphabetically the {@link Unit} objects within the {@link ListOfUnits} of a * {@link UnitDefinition}. *

* @param ud the {@link UnitDefinition} object whose units are to be reordered. */ public"; %javamethodmodifiers UnitDefinition::convertToSI(const UnitDefinition *) " /** * Convert a given {@link UnitDefinition} into a new {@link UnitDefinition} object * that uses SI units. *

* @param ud the {@link UnitDefinition} object to convert to SI *

* @return a new {@link UnitDefinition} object representing the results of the * conversion. */ public"; %javamethodmodifiers UnitDefinition::areIdentical(const UnitDefinition * ud1, const UnitDefinition * ud2) " /** * Predicate returning true or false depending on whether two * {@link UnitDefinition} objects are identical. *

* For the purposes of performing this comparison, two {@link UnitDefinition} * objects are considered identical when they contain identical lists of * {@link Unit} objects. Pairs of {@link Unit} objects in the lists are in turn * considered identical if they satisfy the predicate * Unit.areIdentical(). The predicate compares every attribute of the * {@link Unit} objects. *

* @param ud1 the first {@link UnitDefinition} object to compare * @param ud2 the second {@link UnitDefinition} object to compare *

* @return true if all the {@link Unit} objects in ud1 are identical to the * {@link Unit} objects of ud2, false otherwise. *

* @see #areEquivalent(UnitDefinition ud1, UnitDefinition ud2) * @see Unit#areIdentical(Unit unit1, Unit unit2) */ public"; %javamethodmodifiers UnitDefinition::areEquivalent(const UnitDefinition *ud1 , const UnitDefinition * ud2) " /** * Predicate returning true or false depending on whether two * {@link UnitDefinition} objects are equivalent. *

* For the purposes of performing this comparison, two {@link UnitDefinition} * objects are considered equivalent when they contain equivalent * list of {@link Unit} objects. {@link Unit} objects are in turn considered equivalent * if they satisfy the predicate Unit.areEquivalent(). The predicate * tests a subset of the objects\'s attributes. *

* @param ud1 the first {@link UnitDefinition} object to compare *

* @param ud2 the second {@link UnitDefinition} object to compare *

* @return true if all the {@link Unit} objects in ud1 are equivalent * to the {@link Unit} objects in ud2, false otherwise. *

* @see #areIdentical(UnitDefinition ud1, UnitDefinition ud2) * @see Unit#areEquivalent(Unit unit1, Unit unit2) */ public"; %javamethodmodifiers UnitDefinition::areIdenticalSIUnits(const UnitDefinition * ud1, const UnitDefinition * ud2) " /** * Predicate returning true or false depending on whether two * {@link UnitDefinition} objects are equivalent. *

* @param ud1 the first {@link UnitDefinition} object to compare *

* @param ud2 the second {@link UnitDefinition} object to compare *

* @return true if all the {@link Unit} objects in ud1 are equivalent * to the {@link Unit} objects in ud2, false otherwise. *

* @see #areIdentical(UnitDefinition ud1, UnitDefinition ud2) * @see Unit#areEquivalent(Unit unit1, Unit unit2)

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::combine(UnitDefinition * ud1, UnitDefinition * ud2) " /** * Combines two {@link UnitDefinition} objects into a single {@link UnitDefinition} * object which expresses the product of the units of the two * {@link UnitDefinition}\'s. *

* @param ud1 the first {@link UnitDefinition} object * @param ud2 the second {@link UnitDefinition} object *

* @return a {@link UnitDefinition} which represents the product of the * units of the two argument UnitDefinitions. */ public"; %javamethodmodifiers UnitDefinition::printUnits(const UnitDefinition * ud, bool compact = false) " /** * Returns a string that expresses the unit definition * represented by this {@link UnitDefinition} object. *

* For example printUnits applied to *

   * <unitDefinition>
   *  <listOfUnits>
   *    <unit kind=\'metre\' exponent=\'1\'/>
   *    <unit kind=\'second\' exponent=\'-2\'/>
   *  </listOfUnits>
   * <unitDefinition>

* will return the string

\'metre (exponent = 1, multiplier = 1, scale = 0) 
   * second (exponent = -2, multiplier = 1, scale = 0)\'

or, if * compact = true, the string \'(1 metre)^1 (1 second)^-2\' * This may be useful for printing unit information to * human users, or in debugging, or other situations. *

* @param ud the {@link UnitDefinition} object * @param compact boolean indicating whether the compact form * should be used (defaults to false) *

* @return a string expressing the unit definition */ public"; %javamethodmodifiers UnitDefinition::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers UnitDefinition::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfUnitDefinitions::clone() const " /** * Creates and returns a deep copy of this {@link ListOfUnitDefinitions} instance. *

* @return a (deep) copy of this {@link ListOfUnitDefinitions}. */ public"; %javamethodmodifiers ListOfUnitDefinitions::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfUnitDefinitions::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link UnitDefinition} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfUnitDefinitions::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfUnitDefinitions}, the XML element name is * \'listOfUnitDefinitions\'. *

* @return the name of this element, i.e., \'listOfUnitDefinitions\'. */ public"; %javamethodmodifiers ListOfUnitDefinitions::get(unsigned int n) " /** * Get a {@link UnitDefinition} from the {@link ListOfUnitDefinitions}. *

* @param n the index number of the {@link UnitDefinition} to get. *

* @return the nth {@link UnitDefinition} in this {@link ListOfUnitDefinitions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfUnitDefinitions::get " /** * Get a {@link UnitDefinition} from the {@link ListOfUnitDefinitions}. *

* @param n the index number of the {@link UnitDefinition} to get. *

* @return the nth {@link UnitDefinition} in this {@link ListOfUnitDefinitions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfUnitDefinitions::get(const std::string& sid) " /** * Get a {@link UnitDefinition} from the {@link ListOfUnitDefinitions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link UnitDefinition} to get. *

* @return {@link UnitDefinition} in this {@link ListOfUnitDefinitions} * with the given id or NULL if no such * {@link UnitDefinition} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfUnitDefinitions::get(const std::string& sid) const " /** * Get a {@link UnitDefinition} from the {@link ListOfUnitDefinitions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link UnitDefinition} to get. *

* @return {@link UnitDefinition} in this {@link ListOfUnitDefinitions} * with the given id or NULL if no such * {@link UnitDefinition} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfUnitDefinitions::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfUnitDefinitions} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfUnitDefinitions::remove(const std::string& sid) " /** * Removes item in this {@link ListOfUnitDefinitions} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfUnitDefinitions::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the * {@link ListOfUnitDefinitions} in a model is (in SBML Level 2 * Version 4) the second ListOf___. (However, it differs for * different Levels and Versions of SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfUnitDefinitions::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) CompartmentType " /** * LibSBML implementation of SBML\'s CompartmentType construct. *

* A compartment type in SBML is a grouping construct used to * establish a relationship between multiple {@link Compartment} objects. * In SBML Level 2 Versions 2, 3 and 4, a compartment type only has an * identity, and this identity can only be used to indicate that particular * compartments belong to this type. This may be useful for conveying a * modeling intention, such as when a model contains many similar * compartments, either by their biological function or the reactions they * carry. Without a compartment type construct, it would be impossible in * the language of SBML to indicate that all of the compartments share an * underlying conceptual relationship because each SBML compartment must be * given a unique and separate identity. {@link Compartment} types have no * mathematical meaning in SBML Level 2—they have no effect on a * model\'s mathematical interpretation. Simulators and other numerical * analysis software may ignore {@link CompartmentType} definitions and references * to them in a model. *

* There is no mechanism in SBML for representing hierarchies of * compartment types. One {@link CompartmentType} instance cannot be the subtype * of another {@link CompartmentType} instance; SBML provides no means of defining * such relationships. *

* As with other major structures in SBML, {@link CompartmentType} 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. {@link CompartmentType} 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 (e.g., * Section 3.3 in the Level 2 Version 4 specification). *

* {@link CompartmentType} was introduced in SBML Level 2 Version 2. It is not * available in earlier versions of Level 2 nor in any version of Level 1. *

* @see Compartment * @see ListOfCompartmentTypes * @see SpeciesType * @see ListOfSpeciesTypes *

*/ " %typemap(javaimports) ListOfCompartmentTypes " /** * LibSBML implementation of SBML\'s ListOfCompartmentTypes construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers CompartmentType::CompartmentType(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link CompartmentType}, optionally with the given id and * name attribute values. *

* In SBML, identifiers are required for {@link CompartmentType} objects; * however, the identifier does not have to be set at the time of * creation of the object, and instead can be set using the setId() * method on the {@link SBase} parent class. *

* @param id a string, the identifier of this {@link CompartmentType} instance * @param name a string, the optional name of this {@link CompartmentType} instance *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link CompartmentType} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param level a long integer, the SBML Level to assign to this {@link CompartmentType} *

* @param version a long integer, the SBML Version to assign to this * {@link CompartmentType} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link CompartmentType} *

* @note Once a {@link CompartmentType} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link CompartmentType}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link CompartmentType} in * the list of compartment types. */ public"; %javamethodmodifiers CompartmentType::clone() const " /** * Creates and returns a deep copy of this {@link CompartmentType}. *

* @return a (deep) copy of this {@link CompartmentType}. */ public"; %javamethodmodifiers CompartmentType::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers CompartmentType::getElementName() const " /** * Returns the XML element name of this object, which for * {@link CompartmentType}, is always \'compartmentType\'. *

* @return the name of this element, i.e., \'compartmentType\'. */ public"; %javamethodmodifiers CompartmentType::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well. *

* @param attributes the {@link XMLAttributes} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers CompartmentType::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well. *

* @param stream the XMLOutputStream to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfCompartmentTypes::clone() const " /** * Creates and returns a deep copy of this {@link ListOfCompartmentTypes} instance. *

* @return a (deep) copy of this {@link ListOfCompartmentTypes}. */ public"; %javamethodmodifiers ListOfCompartmentTypes::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfCompartmentTypes::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link CompartmentType} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfCompartmentTypes::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfCompartmentTypes}, the XML element name is * \'listOfCompartmentTypes\'. *

* @return the name of this element, i.e., \'listOfCompartmentTypes\'. */ public"; %javamethodmodifiers ListOfCompartmentTypes::get(unsigned int n) " /** * Get a {@link CompartmentType} from the {@link ListOfCompartmentTypes}. *

* @param n the index number of the {@link CompartmentType} to get. *

* @return the nth {@link CompartmentType} in this {@link ListOfCompartmentTypes}. *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartmentTypes::get " /** * Get a {@link CompartmentType} from the {@link ListOfCompartmentTypes}. *

* @param n the index number of the {@link CompartmentType} to get. *

* @return the nth {@link CompartmentType} in this {@link ListOfCompartmentTypes}. *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartmentTypes::get(const std::string& sid) " /** * Get a {@link CompartmentType} from the {@link ListOfCompartmentTypes} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link CompartmentType} to get. *

* @return {@link CompartmentType} in this {@link ListOfCompartmentTypes} * with the given id or NULL if no such * {@link CompartmentType} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfCompartmentTypes::get(const std::string& sid) const " /** * Get a {@link CompartmentType} from the {@link ListOfCompartmentTypes} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link CompartmentType} to get. *

* @return {@link CompartmentType} in this {@link ListOfCompartmentTypes} * with the given id or NULL if no such * {@link CompartmentType} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfCompartmentTypes::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfCompartmentTypes} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartmentTypes::remove(const std::string& sid) " /** * Removes item in this {@link ListOfCompartmentTypes} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfCompartmentTypes::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. For example, the * {@link ListOfCompartmentTypes} in a model (in SBML Level 2 Version 4) is the * third ListOf___. (However, it differs for different Levels and * Versions of SBML, so calling code should not hardwire this number.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfCompartmentTypes::createObject(XMLInputStream& stream) " /** * Create a {@link ListOfCompartmentTypes} object corresponding to the next token * in the XML input stream. *

* @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream, or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) SpeciesType " /** * LibSBML implementation of SBML\'s SpeciesType construct. *

* The term species type refers to reacting entities independent of * location. These include simple ions (e.g., protons, calcium), simple * molecules (e.g., glucose, ATP), large molecules (e.g., RNA, * polysaccharides, and proteins), and others. *

* {@link SpeciesType} structures are included in SBML to enable {@link Species} of the * same type to be related together. It is a conceptual construct; the * existence of {@link SpeciesType} objects in a model has no effect on the * model\'s numerical interpretation. Except for the requirement for * uniqueness of species/species type combinations located in compartments, * simulators and other numerical analysis software may ignore {@link SpeciesType} * definitions and references to them in a model. *

* There is no mechanism in SBML for representing hierarchies of species * types. One {@link SpeciesType} object cannot be the subtype of another * {@link SpeciesType} object; SBML provides no means of defining such * relationships. *

* As with other major structures in SBML, {@link SpeciesType} has a mandatory * attribute, \'id\', used to give the species type an identifier. The * identifier must be a text string conforming to the identifer syntax * permitted in SBML. {@link SpeciesType} 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 (e.g., Section 3.3 in * the Level 2 Version 4 specification). *

* {@link SpeciesType} was introduced in SBML Level 2 Version 2. It is not * available in earlier versions of Level 2 nor in any version of Level 1. *

* *

*/ " %typemap(javaimports) ListOfSpeciesTypes " /** * LibSBML implementation of SBML\'s ListOfSpeciesTypes construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers SpeciesType::SpeciesType(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link SpeciesType}, optionally with the given id and * name attribute values. *

* In SBML, identifiers are required for {@link SpeciesType} objects; * however, the identifier does not have to be set at the time of * creation of the object, and instead can be set using the setId() * method on the {@link SBase} parent class. *

* @param id a string, the identifier of this {@link SpeciesType} instance * @param name a string, the optional name of this {@link SpeciesType} instance *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link SpeciesType} object is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param level a long integer, the SBML Level to assign to this {@link SpeciesType} *

* @param version a long integer, the SBML Version to assign to this * {@link SpeciesType} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link SpeciesType} *

* @note Once a {@link SpeciesType} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link SpeciesType}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link SpeciesType} in * the list of compartment types. */ public"; %javamethodmodifiers SpeciesType::clone() const " /** * Creates and returns a deep copy of this {@link SpeciesType}. *

* @return a (deep) copy of this {@link SpeciesType}. */ public"; %javamethodmodifiers SpeciesType::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers SpeciesType::getElementName() const " /** * Returns the XML element name of this object, which for * {@link SpeciesType}, is always \'compartmentType\'. *

* @return the name of this element, i.e., \'compartmentType\'. */ public"; %javamethodmodifiers SpeciesType::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well. *

* @param attributes the {@link XMLAttributes} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesType::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well. *

* @param stream the XMLOutputStream to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpeciesTypes::clone() const " /** * Creates and returns a deep copy of this {@link ListOfSpeciesTypes} instance. *

* @return a (deep) copy of this {@link ListOfSpeciesTypes}. */ public"; %javamethodmodifiers ListOfSpeciesTypes::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpeciesTypes::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link SpeciesType} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpeciesTypes::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfSpeciesTypes}, the XML element name is * \'listOfSpeciesTypes\'. *

* @return the name of this element, i.e., \'listOfSpeciesTypes\'. */ public"; %javamethodmodifiers ListOfSpeciesTypes::get(unsigned int n) " /** * Get a {@link SpeciesType} from the {@link ListOfSpeciesTypes}. *

* @param n the index number of the {@link SpeciesType} to get. *

* @return the nth {@link SpeciesType} in this {@link ListOfSpeciesTypes}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesTypes::get " /** * Get a {@link SpeciesType} from the {@link ListOfSpeciesTypes}. *

* @param n the index number of the {@link SpeciesType} to get. *

* @return the nth {@link SpeciesType} in this {@link ListOfSpeciesTypes}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesTypes::get(const std::string& sid) " /** * Get a {@link SpeciesType} from the {@link ListOfSpeciesTypes} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link SpeciesType} to get. *

* @return {@link SpeciesType} in this {@link ListOfSpeciesTypes} * with the given id or NULL if no such * {@link SpeciesType} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpeciesTypes::get(const std::string& sid) const " /** * Get a {@link SpeciesType} from the {@link ListOfSpeciesTypes} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link SpeciesType} to get. *

* @return {@link SpeciesType} in this {@link ListOfSpeciesTypes} * with the given id or NULL if no such * {@link SpeciesType} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpeciesTypes::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfSpeciesTypes} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesTypes::remove(const std::string& sid) " /** * Removes item in this {@link ListOfSpeciesTypes} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfSpeciesTypes::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. For example, the * {@link ListOfSpeciesTypes} in a model (in SBML Level 2 Version 4) is the * third ListOf___. (However, it differs for different Levels and * Versions of SBML, so calling code should not hardwire this number.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpeciesTypes::createObject(XMLInputStream& stream) " /** * Create a {@link ListOfSpeciesTypes} object corresponding to the next token * in the XML input stream. *

* @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream, or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Compartment " /** * LibSBML implementation of SBML\'s Compartment construct. *

* A compartment in SBML represents a bounded space in which species are * located. Compartments do not necessarily have to correspond to actual * structures inside or outside of a biological cell. *

* It is important to note that although compartments are optional in the * overall definition of {@link Model}, every species in an SBML model must be * located in a compartment. This in turn means that if a model defines * any species, the model must also define at least one compartment. The * reason is simply that species represent physical things, and therefore * must exist somewhere. Compartments represent the somewhere. *

* {@link Compartment} has one required attribute, \'id\', to give the compartment a * unique identifier by which other parts of an SBML model definition can * refer to it. A compartment can also have an optional \'name\' attribute * of type string. Identifiers and names must be used according to the * guidelines described in the SBML specification (e.g., Section 3.3 in * the Level 2 Version 4 specification). *

* Each compartment in a model may optionally be designated as belonging to * a particular compartment type. The optional attribute \'compartmentType\' * is used identify the compartment type represented by the {@link Compartment} * structure. The \'compartmentType\' attribute\'s value must be the * identifier of a {@link CompartmentType} instance defined in the model. If the * \'compartmentType\' attribute is not present on a particular compartment * definition, a unique virtual compartment type is assumed for that * compartment, and no other compartment can belong to that compartment * type. The values of \'compartmentType\' attributes on compartments have * no effect on the numerical interpretation of a model. Simulators and * other numerical analysis software may ignore \'compartmentType\' * attributes. *

* {@link Compartment} also has an optional attribute \'spatialDimensions\', whose * value must be a positive integer indicating the number of spatial * dimensions possessed by the compartment. The maximum value is 3, * meaning a three-dimensional structure (a volume). Other permissible * values are 2 (for a two-dimensional area), 1 (for a * one-dimensional curve), and 0 (for a point). The default value of * \'spatialDimensions\' is 3. *

* {@link Compartment} has another optional attribute named \'size\', representing * the initial total size of the compartment. The \'size\' attribute must be * a floating-point value and may represent a volume (if the compartment is * a three-dimensional one), or an area (if the compartment is * two-dimensional), or a length (if the compartment is one-dimensional). * There is no default value of compartment size in SBML Level 2. In * particular, a missing \'size\' value does not imply that the * compartment size is 1. (This is unlike the definition of * compartment \'volume\' in SBML Level 1.) When the compartment\'s * \'spatialDimensions\' attribute does not have a value of 0, a missing * value of \'size\' for a given compartment signifies that the value either * is unknown, or to be obtained from an external source, or determined by * an {@link InitialAssignment}, {@link AssignmentRule}, {@link AlgebraicRule} or {@link RateRule} * elsewhere in the model. The \'size\' attribute must not be present if the * \'spatialDimensions\' attribute has a value of 0; otherwise, a logical * inconsistency would exist because a zero-dimensional object cannot have * a physical size. *

* The units associated with a compartment\'s \'size\' attribute value may be * set using the optional {@link Compartment} attribute \'units\'. The default * units, and the kinds of units allowed as values of the attribute * \'units\', interact with the number of spatial dimensions of the * compartment. The value of the \'units\' attribute of a {@link Compartment} object * must be one of the base units (see {@link Unit}), or the predefined unit * identifiers volume, area, length or dimensionless, or a new * unit defined by a {@link UnitDefinition} object in the enclosing {@link Model}, subject * to the restrictions detailed in the following table: *

Restrictions on values permitted for compartment `size` and `units` attributes.
Value of `spatialDimensions`	`size` allowed?	`units` allowed?	Allowable kinds of units	Default value of attribute `units`
\'`3`\'	yes	yes	units of volume, or `dimensionless`	\'`volume`\'
\'`2`\'	yes	yes	units of area, or `dimensionless`	\'`area`\'
\'`1`\'	yes	yes	units of length, or `dimensionless`	\'`length`\'
\'`0`\'	no	no	(no units allowed)

* In SBML Level 2, the units of the compartment size, as defined by the * \'units\' attribute or (if \'units\' is not set) the default value listed in * the table above, are used in the following ways when the compartment has * a \'spatialDimensions\' value greater than 0: *

The value of the \'units\' attribute is used as the units of the * compartment identifier when the identifier appears as a numerical * quantity in a mathematical formula expressed in MathML. *
*
The math element of an {@link AssignmentRule} or {@link InitialAssignment} * referring to this compartment must have identical units. *
*
In {@link RateRule} objects that set the rate of change of the compartment\'s * size, the units of the rule\'s math element must be identical to the * compartment\'s \'units\' attribute divided by the default time units. * (In other words, the units for the rate of change of compartment size * are compartment size/time units. *
*
When a {@link Species} is to be treated in terms of concentrations or * density, the units of the spatial size portion of the concentration * value (i.e., the denominator in the units formula substance/ * size) are those indicated by the value of the \'units\' attribute on the * compartment in which the species is located. *

* Compartments with \'spatialDimensions\'=0 require special treatment in * this framework. If a compartment has no size or dimensional units, how * should such a compartment\'s identifier be interpreted when it appears in * mathematical formulas? The answer is that such a compartment\'s * identifier should not appear in mathematical formulas in the first * place—it has no value, and its value cannot change. Note also * that a zero-dimensional compartment is a point, and species located at * points can only be described in terms of amounts, not * spatially-dependent measures such as concentration. Since SBML * {@link KineticLaw} formulas are already in terms of substance/time and * not (say) concentration/time, volume or other factors in * principle are not needed for species located in zero-dimensional * compartments. *

* {@link Compartment} has another optional attribute named \'constant\'. This takes * a boolean value indicating whether the compartment\'s size stays constant * or can vary during a simulation. A value of false indicates the * compartment\'s \'size\' can be changed by other constructs in SBML. A * value of true indicates the compartment\'s \'size\' cannot be changed by * any other construct except {@link InitialAssignment}. In the special case of * \'spatialDimensions\'=0, the value cannot be changed by * {@link InitialAssignment} either. The default value for the \'constant\' * attribute is true because in the most common modeling scenarios at * the time of this writing, compartment sizes remain constant. The * \'constant\' attribute must default to or be set to true if the value * of the \'spatialDimensions\' attribute is 0, because a zero-dimensional * compartment cannot ever have a size. *

* Finally, {@link Compartment} has an optional attribute named \'outside\', whose * value can be the identifier of another {@link Compartment} object defined in the * enclosing {@link Model} object. Doing so means that the other compartment * contains it or is outside of it. This enables the representation of * simple topological relationships between compartments, for those * simulation systems that can make use of the information (e.g., for * drawing simple diagrams of compartments). There are two restrictions on * the containment relationships in SBML. First, because a compartment * with \'spatialDimensions\' of 0 has no size, such a compartment cannot * act as the container of any other compartment except compartments * that also have \'spatialDimensions\' values of 0. Second, the * directed graph formed by representing {@link Compartment} structures as vertexes * and the \'outside\' attribute values as edges must be acyclic. The latter * condition is imposed to prevent a compartment from being contained * inside itself. In the absence of a value for \'outside\', compartment * definitions in SBML Level 2 do not have any implied spatial * relationships between each other. *

* It is worth noting that in SBML, there is no relationship between * compartment sizes when compartment positioning is expressed using the * \'outside\' attribute. The size of a given compartment does not in any * sense include the sizes of other compartments having it as the value of * their \'outside\' attributes. In other words, if a compartment B has * the identifier of compartment A as its \'outside\' attribute value, * the size of A does not include the size of B. The compartment * sizes are separate. *

* @note the \'size\' attribute on a compartment must be defined as optional; * however, it is extremely good practice to specify values for * compartment sizes when such values are available. There are three * major technical reasons for this. First, if the model contains any * species whose initial amounts are given in terms of concentrations, and * there is at least one reaction in the model referencing such a species, * then the model is numerically incomplete if it lacks a value for the * size of the compartment in which the species is located. The reason is * simply that SBML {@link Reaction} objects defined in units of * substance/time, not concentration per time, and * thus the compartment size must at some point be used to convert from * species concentration to substance units. Second, models ideally should * be instantiable in a variety of simulation frameworks. A commonly-used * one is the discrete stochastic framework in which species are * represented as item counts (e.g., molecule counts). If species\' initial * quantities are given in terms of concentrations or densities, it is * impossible to convert the values to item counts without knowing * compartment sizes. Third, if a model contains multiple compartments * whose sizes are not all identical to each other, it is impossible to * quantify the reaction rate expressions without knowing the compartment * volumes. The reason for the latter is again that reaction rates in SBML * are defined in terms of substance/time, and when * species quantities are given in terms of concentrations or densities, * the compartment sizes become factors in the reaction rate expressions. *

* */ " %typemap(javaimports) ListOfCompartments " /** * LibSBML implementation of SBML\'s ListOfCompartments construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Compartment::Compartment(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link Compartment}, optionally with the given id and name * attribute values. *

* @param id a string, the identifier to assign to this {@link Compartment} * @param name a string, the optional name to assign to this {@link Compartment} *

* @note It is worth emphasizing that although the identifier is optional * for this constructor, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Compartment} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor if no identifier is provided as an argument. *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Compartment} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param level a long integer, the SBML Level to assign to this {@link Compartment} *

* @param version a long integer, the SBML Version to assign to this * {@link Compartment} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Compartment} *

* @note Once a {@link Compartment} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Compartment}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Compartment} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param orig the {@link Compartment} instance to copy. */ public"; %javamethodmodifiers Compartment::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link Compartment}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link Compartment} in the * list of compartments within which this {@link Compartment} is embedded (i.e., * the {@link ListOfCompartments} in the parent {@link Model}). */ public"; %javamethodmodifiers Compartment::clone() const " /** * Creates and returns a deep copy of this {@link Compartment}. *

* @return a (deep) copy of this {@link Compartment}. */ public"; %javamethodmodifiers Compartment::initDefaults " /** * Initializes the fields of this {@link Compartment} to the defaults defined in * the specification of the relevant Level/Version of SBML. *

(SBML Level 1 only) sets attribute \'volume\' to 1.0 *
(SBML Level 2 only) sets attribute \'spatialDimensions\' to 3 *
(SBML Level 2 only) sets attribute \'constant\' to 1 (true) *

*/ public"; %javamethodmodifiers Compartment::getCompartmentType() const " /** * Get the compartment type of this {@link Compartment}, as indicated by the * {@link Compartment} object\'s \'compartmentType\' attribute value. *

* @return the value of the \'compartmentType\' attribute of this * {@link Compartment} as a string. */ public"; %javamethodmodifiers Compartment::getSpatialDimensions() const " /** * Get the number of spatial dimensions of this {@link Compartment} object. *

* @return the value of the \'spatialDimensions\' attribute of this * {@link Compartment} as a long integereger */ public"; %javamethodmodifiers Compartment::getSize() const " /** * Get the size of this {@link Compartment} *

* This method is identical to getVolume(). In SBML Level 1, * compartments are always three-dimensional constructs and only have * volumes, whereas in SBML Level 2, compartments may be other than * three-dimensional and therefore the \'volume\' attribute is named \'size\' * in Level 2. LibSBML provides both getSize() and getVolume() for * easier compatibility between SBML Levels. *

* @return the value of the \'size\' attribute (\'volume\' in Level 1) of * this {@link Compartment} as a float-point number. *

* @see #isSetSize() */ public"; %javamethodmodifiers Compartment::getVolume() const " /** * (For SBML Level 1) Get the volume of this {@link Compartment} *

* This method is identical to getSize(). In SBML Level 1, compartments * are always three-dimensional constructs and only have volumes, whereas * in SBML Level 2, compartments may be other than three-dimensional and * therefore the \'volume\' attribute is named \'size\' in Level 2. LibSBML * provides both getSize() and getVolume() for easier compatibility * between SBML Levels. *

* @return the value of the \'volume\' attribute (\'size\' in Level 2) of * this {@link Compartment}, as a floating-point number. *

* @see #isSetVolume() */ public"; %javamethodmodifiers Compartment::getUnits() const " /** * Get the units of this compartment\'s size or volume. *

* @return the value of the \'units\' attribute of this {@link Compartment}. */ public"; %javamethodmodifiers Compartment::getOutside() const " /** * Get the identifier, if any, of the compartment that is designated * as being outside of this one. *

* @return the value of the \'outside\' attribute of this {@link Compartment}. */ public"; %javamethodmodifiers Compartment::getConstant() const " /** * Get the value of the \'constant\' attribute of this {@link Compartment}. *

* @return true if this {@link Compartment}\'s size is flagged as being * constant, false otherwise. */ public"; %javamethodmodifiers Compartment::isSetCompartmentType() const " /** * Predicate returning true or false depending on whether this * {@link Compartment}\'s \'compartmentType\' attribute has been set. *

* @return true if the \'compartmentType\' attribute of this {@link Compartment} * has been set, false otherwise. */ public"; %javamethodmodifiers Compartment::isSetSize() const " /** * Predicate returning true or false depending on whether this * {@link Compartment}\'s \'size\' attribute has been set. *

* This method is similar but not identical to isSetVolume(). The latter * should be used in the context of SBML Level 1 models instead of * isSetSize() because isSetVolume() performs extra processing to take * into account the difference in default values between SBML Levels 1 * and 2. *

* @return true if the \'size\' attribute (\'volume\' in Level) of this * {@link Compartment} has been set, false otherwise. *

* @see #isSetVolume() * @see #setSize(double value) */ public"; %javamethodmodifiers Compartment::isSetVolume() const " /** * (For SBML Level 1) Predicate returning true or false depending * on whether this {@link Compartment}\'s \'volume\' attribute has been set. *

* This method is similar but not identical to isSetSize(). The latter * should not be used in the context of SBML Level 1 models because this * method (isSetVolume()) performs extra processing to take into account * the difference in default values between SBML Levels 1 and 2. *

* @return true if the \'volume\' attribute (\'size\' in L2) of this * {@link Compartment} has been set, false otherwise. *

* @see #isSetSize() * @see #setVolume(double value) *

* @note In SBML Level 1, a compartment\'s volume has a default value ( * 1.0) and therefore this method will always return true. In Level * 2, a compartment\'s size (the equivalent of SBML Level 1\'s \'volume\') is * optional and has no default value, and therefore may or may not be * set. */ public"; %javamethodmodifiers Compartment::isSetUnits() const " /** * Predicate returning true or false depending on whether this * {@link Compartment}\'s \'units\' attribute has been set. *

* @return true if the \'units\' attribute of this {@link Compartment} has been * set, false otherwise. */ public"; %javamethodmodifiers Compartment::isSetOutside() const " /** * Predicate returning true or false depending on whether this * {@link Compartment}\'s \'outside\' attribute has been set. *

* @return true if the \'outside\' attribute of this {@link Compartment} has * been set, false otherwise. */ public"; %javamethodmodifiers Compartment::setCompartmentType(const std::string& sid) " /** * Sets the \'compartmentType\' attribute of this {@link Compartment}. *

* @param sid the identifier of a {@link CompartmentType} object defined * elsewhere in this {@link Model}. */ public"; %javamethodmodifiers Compartment::setSpatialDimensions(unsigned int value) " /** * Sets the \'spatialDimensions\' attribute of this {@link Compartment}. *

* If value is not one of 0, 1, 2, or 3, this method will * have no effect (i.e., the \'spatialDimensions\' attribute will not be * set). *

* @param value a long integereger indicating the number of dimensions * of this compartment. */ public"; %javamethodmodifiers Compartment::setSize(double value) " /** * Sets the \'size\' attribute (or \'volume\' in SBML Level 1) of this * {@link Compartment}. *

* This method is identical to setVolume() and is provided for * compatibility between SBML Level 1 and Level 2. *

* @param value a double representing the size of this compartment * instance in whatever units are in effect for the compartment. */ public"; %javamethodmodifiers Compartment::setVolume(double value) " /** * Sets the \'volume\' attribute (or \'size\' in SBML Level 2) of this * {@link Compartment}. *

* This method is identical to setVolume() and is provided for * compatibility between SBML Level 1 and Level 2. *

* @param value a double representing the volume of this compartment * instance in whatever units are in effect for the compartment. */ public"; %javamethodmodifiers Compartment::setUnits(const std::string& sid) " /** * Sets the \'units\' attribute of this {@link Compartment}. *

* @param sid the identifier of the defined units to use. */ public"; %javamethodmodifiers Compartment::setOutside(const std::string& sid) " /** * Sets the \'outside\' attribute of this {@link Compartment}. *

* @param sid the identifier of a compartment that encloses this one. */ public"; %javamethodmodifiers Compartment::setConstant(bool value) " /** * Sets the value of the \'constant\' attribute of this {@link Compartment}. *

* @param value a boolean indicating whether the size/volume of this * compartment should be considered constant (true) or variable ( * false) */ public"; %javamethodmodifiers Compartment::unsetCompartmentType " /** * Unsets the value of the \'compartmentType\' attribute of this * {@link Compartment}. *

* @see #setCompartmentType(String sid) * @see #isSetCompartmentType() *

*/ public"; %javamethodmodifiers Compartment::unsetSize " /** * Unsets the value of the \'size\' attribute of this {@link Compartment}. *

*/ public"; %javamethodmodifiers Compartment::unsetVolume " /** * (For SBML Level 1) Unsets the value of the \'volume\' attribute of this * {@link Compartment}. *

* In SBML Level 1, a {@link Compartment} volume has a default value (1.0) and * therefore should always be set. In Level 2, \'size\' is * optional with no default value and as such may or may not be set. */ public"; %javamethodmodifiers Compartment::unsetUnits " /** * Unsets the value of the \'units\' attribute of this {@link Compartment}. *

* Compartments in SBML have an attribute (\'units\') for declaring the * units of measurement intended for the value of the compartment\'s size. * In the absence of a value given for this attribute, the units are * taken from the model\'s definition of \'volume\', \'area\', * \'length\' units, depending on the value given to this {@link Compartment}\'s * \'size\' attribute, or (if the {@link Model} does not redefine them) the * corresponding SBML default units for those quantities. Following that * procedure, the method getDerivedUnitDefinition() returns a * {@link UnitDefinition} based on the interpreted units of this compartment\'s * size. *

* Note that the functionality that facilitates unit analysis depends * on the model as a whole. Thus, in cases where the object has not * been added to a model or the model itself is incomplete, * unit analysis is not possible and this method will return NULL. *

* Note also that unit declarations for {@link Compartment} are in terms of the * identifier of a unit, but this method returns a {@link UnitDefinition} * object, not a unit identifier. It does this by constructing an * appropriate {@link UnitDefinition}. Callers may find this particularly useful * when used in conjunction with the helper methods on {@link UnitDefinition} for * comparing different {@link UnitDefinition} objects. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Compartment}. *

* @see #getUnits() */ public"; %javamethodmodifiers Compartment::getDerivedUnitDefinition() const " /** * Constructs and returns a {@link UnitDefinition} that corresponds to the units * of this {@link Compartment}\'s designated size. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Compartment}. *

* @see #getUnits() */ public"; %javamethodmodifiers Compartment::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Compartment::getElementName() const " /** * Returns the XML element name of this object, which for {@link Compartment}, is * always \'compartment\'. *

* @return the name of this element, i.e., \'compartment\'. */ public"; %javamethodmodifiers Compartment::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Compartment::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfCompartments::clone() const " /** * Creates and returns a deep copy of this {@link ListOfCompartments} instance. *

* @return a (deep) copy of this {@link ListOfCompartments}. */ public"; %javamethodmodifiers ListOfCompartments::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default).

* @see #getElementName() */ public"; %javamethodmodifiers ListOfCompartments::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Compartment} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfCompartments::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfCompartments}, the XML element name is \'listOfCompartments\'. *

* @return the name of this element, i.e., \'listOfCompartments\'. */ public"; %javamethodmodifiers ListOfCompartments::get(unsigned int n) " /** * Get a {@link Compartment} from the {@link ListOfCompartments}. *

* @param n the index number of the {@link Compartment} to get. *

* @return the nth {@link Compartment} in this {@link ListOfCompartments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartments::get " /** * Get a {@link Compartment} from the {@link ListOfCompartments}. *

* @param n the index number of the {@link Compartment} to get. *

* @return the nth {@link Compartment} in this {@link ListOfCompartments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartments::get(const std::string& sid) " /** * Get a {@link Compartment} from the {@link ListOfCompartments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Compartment} to get. *

* @return {@link Compartment} in this {@link ListOfCompartments} * with the given id or NULL if no such * {@link Compartment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfCompartments::get(const std::string& sid) const " /** * Get a {@link Compartment} from the {@link ListOfCompartments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Compartment} to get. *

* @return {@link Compartment} in this {@link ListOfCompartments} * with the given id or NULL if no such * {@link Compartment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfCompartments::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfCompartments} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfCompartments::remove(const std::string& sid) " /** * Removes item in this {@link ListOfCompartments} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfCompartments::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the {@link ListOfCompartments} * in a model is (in SBML Level 2 Version 4) the fifth ListOf___. * (However, it differs for different Levels and Versions of SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfCompartments::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Species " /** * LibSBML implementation of SBML\'s Species construct. *

* A species refers to a pool of reacting entities of a specific * species type that take part in reactions and are located in a * specific compartment. The {@link Species} data structure is intended to * represent these pools. A {@link Species} definition has several parts: an * optional identifier (defined by the attribute \'id\'), an optional name * (defined by the attribute \'name\'), a required attribute \'compartment\', * and optional attributes \'speciesType\', \'initialAmount\', * \'initialConcentration\', \'substanceUnits\', \'hasOnlySubstanceUnits\', * \'boundaryCondition\', \'charge\' and \'constant\'. These various parts are * described next. *

* As with other major structures in SBML, {@link Species} has a mandatory * attribute, \'id\', used to give the species type an identifier in the * model. The identifier must be a text string conforming to the identifer * syntax permitted in SBML. {@link Species} 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 (e.g., * Section 3.3 in the Level 2 Version 4 specification). *

* The required attribute \'compartment\' is used to identify the compartment * in which the species is located. The attribute\'s value must be the * identifier of an existing {@link Compartment} structure. It is important to * note that there is no default value for the \'compartment\' attribute on * {@link Species}; every species in an SBML model must be assigned a compartment, * and consequently, a model must define at least one compartment if that * model contains any species. *

* Each species in a model may optionally be designated as belonging to a * particular species type. The optional attribute \'speciesType\' is used * to identify the species type of the chemical entities that make up the * pool represented by the {@link Species} structure. The attribute\'s value must * be the identifier of an existing {@link SpeciesType} structure. If the * \'speciesType\' attribute is not present on a particular species * definition, it means the pool contains chemical entities of a type * unique to that pool; in effect, a virtual species type is assumed for * that species, and no other species can belong to that species type. The * value of \'speciesType\' attributes on species have no effect on the * numerical interpretation of a model; simulators and other numerical * analysis software may ignore \'speciesType\' attributes. *

* There can be only one species of a given species type in any given * compartment of a model. More specifically, for all {@link Species} structures * having a value for the \'speciesType\' attribute, the pair *

* (\'speciesType\' attribute value, \'compartment\' attribute value) * *

* must be unique across the set of all {@link Species} structures in a model. *

The initial amount and concentration of a species

* The optional attributes \'initialAmount\' and \'initialConcentration\', both * having a data type of double, are used to set the initial quantity of * the species in the compartment where the species is located. These * attributes are mutually exclusive; i.e., only one can have a * value on any given instance of a {@link Species} structure. Missing * \'initialAmount\' and \'initialConcentration\' values implies that their * values either are unknown, or to be obtained from an external source, or * determined by an {@link InitialAssignment} or {@link Rule} object elsewhere in the * model. In the case where a species\' compartment has a * \'spatialDimensions\' value of 0 (zero), the species cannot have a * value for \'initialConcentration\' because the concepts of concentration * and density break down when a container has zero dimensions. *

* A species\' initial quantity is set by the \'initialAmount\' or * \'initialConcentration\' attributes exactly once. If the species\' * \'constant\' attribute is true (the default), then the size is fixed * and cannot be changed except by an {@link InitialAssignment}. These methods * differ in that the \'initialAmount\' and \'initialConcentration\' attributes * can only be used to set the species quantity to a literal scalar value, * whereas {@link InitialAssignment} allows the value to be set using an arbitrary * mathematical expression. If the species\' \'constant\' attribute is * false, the species\' quantity value may be overridden by an * {@link InitialAssignment} or changed by {@link AssignmentRule} or {@link AlgebraicRule}, and in * addition, for t < 0, it may also be changed by a {@link RateRule} or * {@link Event}. (However, some constructs are mutually exclusive; see the SBML * specification for more details.) It is not an error to define * \'initialAmount\' or \'initialConcentration\' on a species and also redefine * the value using an {@link InitialAssignment}, but the \'initialAmount\' or * \'initialConcentration\' setting in that case is ignored. *

The units of a species\' amount or concentration

* The units associated with a species\' quantity, referred to as the * units of the species, are determined via the optional * attributes \'substanceUnits\' and \'hasOnlySubstanceUnits\', in combination * with the units of the size defined for the compartment object in which * the species are located. The way this is done is as follows. *

* The units of the value in the \'initialConcentration\' attribute are * substance/size units, where the units of substance are those * defined by the \'substanceUnits\' attribute and the size units are * those given in the definition of the size of the {@link Compartment} in which * the species is located. The units of the value in the \'initialAmount\' * attribute are determined by the \'substanceUnits\' attribute of the * species structure. The role of the attribute \'hasOnlySubstanceUnits\' is * to indicate whether the units of the species, when the species * identifier appears in mathematical formulas, are intended to be * concentration or amount. The attribute takes on boolean values and * defaults to false. Although it may seem as though this intention * could be determined based on whether \'initialConcentration\' or * \'initialAmount\' is set, the fact that these two attributes are optional * means that a separate flag is needed. (Consider the situation where * neither is set, and instead the species\' quantity is established by an * {@link InitialAssignment} or {@link AssignmentRule}.) *

* The possible values of units of the species are summarized in * the following table. (The dependence on the number of spatial * dimensions of the compartment is due to the fact that a zero-dimensional * compartment cannot support concentrations or densities.) *

Interpretation of species\' units.
Value of `hasOnlySubstanceUnits`	Units of the species when `spatialDimensions` is greater than 0	Units of the species when `spatialDimensions` is 0
`false` (default)	substance/size	substance
`true` (default)	substance	substance

* The value assigned to \'substanceUnits\' must be chosen from one of the * following possibilities: one of the base unit identifiers defined in * SBML; the built-in unit identifier \'substance\'; or the identifier of * a new unit defined in the list of unit definitions in the enclosing * {@link Model} structure. The chosen units for \'substanceUnits\' must be be * \'dimensionless\', \'mole\', \'item\', \'kilogram\', \'gram\', or * units derived from these. The \'substanceUnits\' attribute defaults to * the the built-in unit \'substance\'. *

* The units of the species are used in the following ways: *

The species identifier has these units when the identifier appears * as a numerical quantity in a mathematical formula expressed in MathML. *
*
The \'math\' subelement of an {@link AssignmentRule} or {@link InitialAssignment} * referring to this species must have identical units. *
*
In {@link RateRule} structures that set the rate of change of the species\' * quantity, the units of the rule\'s \'math\' subelement must be identical to * the units of the species divided by the model\'s time units. *

The \'constant\' and \'boundaryCondition\' attributes

* The {@link Species} structure has two optional boolean attributes named * \'constant\' and \'boundaryCondition\', used to indicate whether and how the * quantity of that species can vary during a simulation. The following * table shows how to interpret the combined values of these attributes. *

Interpretation of species\' `constant` and `boundaryCondition` attributes.
`constant` value	`boundaryCondition` value	Can have assignment or rate rule?	Can be reactant or product?	{@link Species}\' quantity can be changed by
`true`	`true`	no	yes	(never changes)
`false`	`true`	yes	yes	rules and events
`true`	`false`	no	no	(never changes)
`false`	`false`	yes	yes	reactions or rules (but not both at the same time), and events

* By default, when a species is a product or reactant of one or more * reactions, its quantity is determined by those reactions. In SBML, it * is possible to indicate that a given species\' quantity is not * determined by the set of reactions even when that species occurs as a * product or reactant; i.e., the species is on the boundary of * the reaction system, and its quantity is not determined by the * reactions. The boolean attribute \'boundaryCondition\' can be used to * indicate this. The value of the attribute defaults to false, * indicating the species is part of the reaction system. *

* The \'constant\' attribute indicates whether the species\' quantity can be * changed at all, regardless of whether by reactions, rules, or constructs * other than {@link InitialAssignment}. The default value is false, indicating * that the species\' quantity can be changed, since the purpose of most * simulations is precisely to calculate changes in species quantities. * Note that the initial quantity of a species can be set by an * {@link InitialAssignment} irrespective of the value of the \'constant\' attribute. *

* In practice, a \'boundaryCondition\' value of true means a differential * equation derived from the reaction definitions should not be generated * for the species. However, the species\' quantity may still be changed by * {@link AssignmentRule}, {@link RateRule}, {@link AlgebraicRule}, {@link Event}, and {@link InitialAssignment} * constructs if its \'constant\' attribute is false. Conversely, if the * species\' \'constant\' attribute is true, then its value cannot be * changed by anything except {@link InitialAssignment}. *

* A species having \'boundaryCondition\'=false and \'constant\'=false * can appear as a product and/or reactant of one or more reactions in the * model. If the species is a reactant or product of a reaction, it must * not also appear as the target of any {@link AssignmentRule} or {@link RateRule} * structure in the model. If instead the species has * \'boundaryCondition\'=false and \'constant\'=true, then it cannot * appear as a reactant or product, or as the target of any * {@link AssignmentRule}, {@link RateRule} or {@link EventAssignment} structure in the model. *

* @warning In versions of SBML Level 2 before Version 3, the class * {@link Species} included an attribute called \'spatialSizeUnits, which allowed * explicitly setting the units of size for initial concentration. LibSBML * retains this attribute for compatibility with older definitions of * Level 2, but its use is strongly discouraged because it is * incompatible with Level 2 Version 3 andLevel 2 Version 4. *

* */ " %typemap(javaimports) ListOfSpecies " /** * LibSBML implementation of SBML\'s ListOfSpecies construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Species::Species(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link Species}, optionally with the given id and name * attribute values. *

* @param id a string, the identifier to assign to this {@link Species} * @param name a string, the optional name to assign to this {@link Species} *

* @note It is worth emphasizing that although the identifier is optional * for this constructor, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Species} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor if no identifier is provided as an argument. *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Species} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param level a long integer, the SBML Level to assign to this {@link Species} *

* @param version a long integer, the SBML Version to assign to this * {@link Species} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Species} *

* @note Once a {@link Species} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Species}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Species} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor. Setting the identifier can be accomplished using the * method {@link SBase#setId(String id)} . *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Species::clone() const " /** * Creates and returns a deep copy of this {@link Species}. *

* @return a (deep) copy of this {@link Species}. */ public"; %javamethodmodifiers Species::initDefaults " /** * Initializes the fields of this {@link Species} to the defaults defined * in the specification of the relevant Level/Version of SBML. *

sets \'boundaryCondition\' to 1 (true) *
(Level 2 only) sets \'constant\' to 0 (false) *
(Level 2 only) sets \'hasOnlySubstanceUnits\' to 0 (false) *

*/ public"; %javamethodmodifiers Species::getSpeciesType() const " /** * Get the species type of this {@link Species}, as indicated by the * {@link Species} object\'s \'speciesType\' attribute value. *

* @return the value of the \'speciesType\' attribute of this * {@link Species} as a string. */ public"; %javamethodmodifiers Species::getCompartment() const " /** * Get the compartment in which this species is located. *

* @return the value of the \'compartment\' attribute of this {@link Species}, as a * string. */ public"; %javamethodmodifiers Species::getInitialAmount() const " /** * Get the value of the \'initialAmount\' attribute. *

* @return the initialAmount of this {@link Species}, as a float-point number. */ public"; %javamethodmodifiers Species::getInitialConcentration() const " /** * Get the value of the \'initialConcentration\' attribute. *

* @return the initialConcentration of this {@link Species},, as a float-point * number. */ public"; %javamethodmodifiers Species::getSubstanceUnits() const " /** * Get the value of the \'substanceUnit\' attribute. *

* @return the substanceUnits of this {@link Species}, as a string. */ public"; %javamethodmodifiers Species::getSpatialSizeUnits() const " /** * Get the value of the \'spatialSizeUnits\' attribute. *

* @return the spatialSizeUnits of this {@link Species}. *

* @warning In versions of SBML Level~2 before Version 3, the class * {@link Species} included an attribute called \'spatialSizeUnits\', which allowed * explicitly setting the units of size for initial concentration. This * attribute was removed in SBML Level 2 Version 3. LibSBML * retains this attribute for compatibility with older definitions of * Level 2, but its use is strongly discouraged because it is * incompatible with Level 2 Version 3 and Level 2 Version 4. */ public"; %javamethodmodifiers Species::getUnits() const " /** * (SBML Level 1 only) Get the value of the \'units\' attribute. *

* @return the units of this {@link Species} (L1 only). */ public"; %javamethodmodifiers Species::getHasOnlySubstanceUnits() const " /** * Get the value of the \'hasOnlySubstanceUnits\' attribute. *

* @return true if this {@link Species}\' \'hasOnlySubstanceUnits\' attribute * value is nonzero, false otherwise. */ public"; %javamethodmodifiers Species::getBoundaryCondition() const " /** * Get the value of the \'boundaryCondition\' attribute. *

* @return true if this {@link Species}\' \'boundaryCondition\' attribute value * is nonzero, false otherwise. */ public"; %javamethodmodifiers Species::getCharge() const " /** * Get the value of the \'charge\' attribute. *

* @return the charge of this {@link Species}. *

* @note Beginning in SBML Level 2 Version 2, the \'charge\' * attribute on {@link Species} is deprecated and its use strongly discouraged. * Its presence is considered a misfeature in earlier definitions of SBML * because its implications for the mathematics of a model were never * defined, and in any case, no known modeling system ever used it. * Instead, models take account of charge values directly in their * definitions of species by (for example) having separate species * identities for the charged and uncharged versions of the same species. * This allows the condition to affect model mathematics directly. * LibSBML retains this method for easier compatibility with SBML * Level 1. */ public"; %javamethodmodifiers Species::getConstant() const " /** * Get the value of the \'constant\' attribute. *

* @return true if this {@link Species}\'s \'constant\' attribute value is * nonzero, false otherwise. */ public"; %javamethodmodifiers Species::isSetSpeciesType() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'speciesType\' attribute has been set. *

* @return true if the \'speciesType\' attribute of this {@link Species} has * been set, false otherwise. */ public"; %javamethodmodifiers Species::isSetCompartment() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'compartment\' attribute has been set. *

* @return true if the \'compartment\' attribute of this {@link Species} has * been set, false otherwise. */ public"; %javamethodmodifiers Species::isSetInitialAmount() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'initialAmount\' attribute has been set. *

* @return true if the \'initialAmount\' attribute of this {@link Species} has * been set, false otherwise. *

* @note In SBML Level 1, {@link Species}\' \'initialAmount\' is required and * therefore should always be set. (However, in Level 1, the * attribute has no default value either, so this method will not return * true until a value has been assigned.) In SBML Level 2, * \'initialAmount\' is optional and as such may or may not be set. */ public"; %javamethodmodifiers Species::isSetInitialConcentration() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'initialConcentration\' attribute has been set. *

* @return true if the \'initialConcentration\' attribute of this {@link Species} has * been set, false otherwise. */ public"; %javamethodmodifiers Species::isSetSubstanceUnits() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'substanceUnits\' attribute has been set. *

* @return true if the \'substanceUnits\' attribute of this {@link Species} has * been set, false otherwise. */ public"; %javamethodmodifiers Species::isSetSpatialSizeUnits() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'spatialSizeUnits\' attribute has been set. *

* @return true if the \'spatialSizeUnits\' attribute of this {@link Species} has * been set, false otherwise. *

* @warning In versions of SBML Level~2 before Version 3, the class * {@link Species} included an attribute called \'spatialSizeUnits\', which allowed * explicitly setting the units of size for initial concentration. This * attribute was removed in SBML Level 2 Version 3. LibSBML * retains this attribute for compatibility with older definitions of * Level 2, but its use is strongly discouraged because it is * incompatible with Level 2 Version 3 and Level 2 Version 4. */ public"; %javamethodmodifiers Species::isSetUnits() const " /** * (SBML Level 1 only) Predicate returning true or false depending * on whether this {@link Species}\'s \'units\' attribute has been set. *

* @return true if the \'units\' attribute of this {@link Species} has * been set, false otherwise. */ public"; %javamethodmodifiers Species::isSetCharge() const " /** * Predicate returning true or false depending on whether this * {@link Species}\'s \'charge\' attribute has been set. *

* @return true if the \'charge\' attribute of this {@link Species} has * been set, false otherwise. *

* @note Beginning in SBML Level 2 Version 2, the \'charge\' * attribute on {@link Species} in SBML is deprecated and its use strongly * discouraged. Its presence is considered a misfeature in earlier * definitions of SBML because its implications for the mathematics of a * model were never defined, and in any case, no known modeling system * ever used it. Instead, models take account of charge values directly * in their definitions of species by (for example) having separate * species identities for the charged and uncharged versions of the same * species. This allows the condition to affect model mathematics * directly. LibSBML retains this method for easier compatibility with * SBML Level 1. */ public"; %javamethodmodifiers Species::setSpeciesType(const std::string& sid) " /** * Sets the \'speciesType\' attribute of this {@link Species}. *

* @param sid the identifier of a {@link SpeciesType} object defined elsewhere * in this {@link Model}. */ public"; %javamethodmodifiers Species::setCompartment(const std::string& sid) " /** * Sets the \'compartment\' attribute of this {@link Species}. *

* @param sid the identifier of a {@link Compartment} object defined elsewhere * in this {@link Model}. */ public"; %javamethodmodifiers Species::setInitialAmount(double value) " /** * Sets the \'initialAmount\' attribute of this {@link Species} and marks the field * as set. *

* This method also unsets the \'initialConcentration\' attribute. *

* @param value the value to which the \'initialAmount\' attribute should * be set. */ public"; %javamethodmodifiers Species::setInitialConcentration(double value) " /** * Sets the \'initialConcentration\' attribute of this {@link Species} and marks * the field as set. *

* This method also unsets the \'initialAmount\' attribute. *

* @param value the value to which the \'initialConcentration\' attribute * should be set. */ public"; %javamethodmodifiers Species::setSubstanceUnits(const std::string& sid) " /** * Sets the \'substanceUnits\' attribute of this {@link Species}. *

* @param sid the identifier of the unit to use. */ public"; %javamethodmodifiers Species::setSpatialSizeUnits(const std::string& sid) " /** * Sets the \'spatialSizeUnits\' attribute of this {@link Species}. *

* @param sid the identifier of the unit to use. *

* @warning In versions of SBML Level~2 before Version 3, the class * {@link Species} included an attribute called \'spatialSizeUnits\', which allowed * explicitly setting the units of size for initial concentration. This * attribute was removed in SBML Level 2 Version 3. LibSBML * retains this attribute for compatibility with older definitions of * Level 2, but its use is strongly discouraged because it is * incompatible with Level 2 Version 3 and Level 2 Version 4. */ public"; %javamethodmodifiers Species::setUnits(const std::string& sname) " /** * (SBML Level 1 only) Sets the units of this {@link Species}. *

* @param sname the identifier of the unit to use. */ public"; %javamethodmodifiers Species::setHasOnlySubstanceUnits(bool value) " /** * Sets the \'hasOnlySubstanceUnits\' attribute of this {@link Species}. *

* @param value boolean value for the \'hasOnlySubstanceUnits\' attribute. */ public"; %javamethodmodifiers Species::setBoundaryCondition(bool value) " /** * Sets the \'boundaryCondition\' attribute of this {@link Species}. *

* @param value boolean value for the \'boundaryCondition\' attribute. */ public"; %javamethodmodifiers Species::setCharge(int value) " /** * Sets the \'charge\' attribute of this {@link Species}. *

* @param value an integer to which to set the \'charge\' to. *

* @note Beginning in SBML Level 2 Version 2, the \'charge\' * attribute on {@link Species} in SBML is deprecated and its use strongly * discouraged. Its presence is considered a misfeature in earlier * definitions of SBML because its implications for the mathematics of a * model were never defined, and in any case, no known modeling system * ever used it. Instead, models take account of charge values directly * in their definitions of species by (for example) having separate * species identities for the charged and uncharged versions of the same * species. This allows the condition to affect model mathematics * directly. LibSBML retains this method for easier compatibility with * SBML Level 1. */ public"; %javamethodmodifiers Species::setConstant(bool value) " /** * Sets the \'constant\' attribute of this {@link Species}. *

* @param value a boolean value for the \'constant\' attribute */ public"; %javamethodmodifiers Species::unsetSpeciesType " /** * Unsets the \'speciesType\' attribute value of this {@link Species}. *

* @warning In versions of SBML Level~2 before Version 3, the class * {@link Species} included an attribute called \'spatialSizeUnits\', which allowed * explicitly setting the units of size for initial concentration. This * attribute was removed in SBML Level 2 Version 3. LibSBML * retains this attribute for compatibility with older definitions of * Level 2, but its use is strongly discouraged because it is * incompatible with Level 2 Version 3 and Level 2 Version 4. */ public"; %javamethodmodifiers Species::unsetUnits " /** * (SBML Level 1 only) Unsets the \'units\' attribute value of this {@link Species}. *

* @note Beginning in SBML Level 2 Version 2, the \'charge\' * attribute on {@link Species} in SBML is deprecated and its use strongly * discouraged. Its presence is considered a misfeature in earlier * definitions of SBML because its implications for the mathematics of a * model were never defined, and in any case, no known modeling system * ever used it. Instead, models take account of charge values directly * in their definitions of species by (for example) having separate * species identities for the charged and uncharged versions of the same * species. This allows the condition to affect model mathematics * directly. LibSBML retains this method for easier compatibility with * SBML Level 1. */ public"; %javamethodmodifiers Species::getDerivedUnitDefinition " /** * Constructs and returns a {@link UnitDefinition} that corresponds to the units * of this {@link Species}\' amount or concentration. *

* {@link Species} in SBML have an attribute (\'substanceUnits\') for declaring the * units of measurement intended for the species\' amount or concentration * (depending on which one applies). In the absence of a value given for * \'substanceUnits\', the units are taken from the enclosing {@link Model}\'s * definition of \'substance\' or \'substance\'/(size of the * compartment) in which the species is located, or finally, if * these are not redefined by the {@link Model}, the relevant SBML default units * for those quantities. Following that procedure, the method * getDerivedUnitDefinition() returns a {@link UnitDefinition} based on the * interpreted units of this species\'s amount or concentration. *

* Note also that unit declarations for {@link Species} are in terms of the * identifier of a unit, but this method returns a {@link UnitDefinition} object, * not a unit identifier. It does this by constructing an appropriate * {@link UnitDefinition}. Callers may find this particularly useful when used * in conjunction with the helper methods on {@link UnitDefinition} for comparing * different {@link UnitDefinition} objects. *

* In SBML Level 2 specifications prior to Version 3, {@link Species} * includes an additional attribute named \'spatialSizeUnits\', which * allows explicitly setting the units of size for initial concentration. * The getDerivedUnitDefinition() takes this into account for models * expressed in SBML Level 2 Versions 1 and 2. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Species}. *

* @see #getSubstanceUnits() */ public"; %javamethodmodifiers Species::getDerivedUnitDefinition() const " /** * Constructs and returns a {@link UnitDefinition} that corresponds to the units * of this {@link Species}\' amount or concentration. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Species}. *

* @see #getSubstanceUnits() */ public"; %javamethodmodifiers Species::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Species::getElementName() const " /** * Returns the XML element name of this object, which for {@link Species}, is * always \'species\'. *

* @return the name of this element, i.e., \'species\'. */ public"; %javamethodmodifiers Species::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Species::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpecies::clone() const " /** * Creates and returns a deep copy of this ListOfSpeciess instance. *

* @return a (deep) copy of this ListOfSpeciess. */ public"; %javamethodmodifiers ListOfSpecies::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpecies::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Species} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpecies::getElementName() const " /** * Returns the XML element name of this object. *

* For ListOfSpeciess, the XML element name is \'listOfSpeciess\'. *

* @return the name of this element, i.e., \'listOfSpeciess\'. */ public"; %javamethodmodifiers ListOfSpecies::get(unsigned int n) " /** * Get a {@link Species} from the {@link ListOfSpecies}. *

* @param n the index number of the {@link Species} to get. *

* @return the nth {@link Species} in this {@link ListOfSpecies}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpecies::get " /** * Get a {@link Species} from the {@link ListOfSpecies}. *

* @param n the index number of the {@link Species} to get. *

* @return the nth {@link Species} in this {@link ListOfSpecies}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpecies::get(const std::string& sid) " /** * Get a {@link Species} from the {@link ListOfSpecies} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Species} to get. *

* @return {@link Species} in this {@link ListOfSpecies} * with the given id or NULL if no such * {@link Species} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpecies::get(const std::string& sid) const " /** * Get a {@link Species} from the {@link ListOfSpecies} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Species} to get. *

* @return {@link Species} in this {@link ListOfSpecies} * with the given id or NULL if no such * {@link Species} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpecies::remove(unsigned int n) " /** * Removes the nth item from this ListOfSpeciess items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfSpecies::remove(const std::string& sid) " /** * Removes item in this ListOfSpeciess items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfSpecies::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the ListOfSpeciess in * a model is (in SBML Level 2 Version 4) the sixth * ListOf___. (However, it differs for different Levels and Versions of * SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpecies::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Parameter " /** * LibSBML implementation of SBML\'s Parameter construct. *

* A {@link Parameter} is used in SBML to define a symbol associated with a value; * this symbol can then be used in mathematical formulas in a model. By * default, parameters have constant value for the duration of a * simulation, and for this reason are called parameters instead of * variables in SBML, although it is crucial to understand that %SBML * parameters represent both concepts. Whether a given SBML * parameter is intended to be constant or variable is indicated by the * value of its \'constant\' attribute. *

* SBML\'s {@link Parameter} has one required attribute, \'id\', to give the * parameter a unique identifier by which other parts of an SBML model * definition can refer to it. A parameter can also have an optional * \'name\' attribute of type string. Identifiers and names must be used * according to the guidelines described in the SBML specification (e.g., * Section 3.3 in the Level 2 Version 4 specification). *

* The optional attribute \'value\' determines the value (of type double) * assigned to the identifier. A missing value for \'value\' implies that * the value either is unknown, or to be obtained from an external source, * or determined by an initial assignment. The units associated with the * value of the parameter are specified by the attribute named \'units\'. * The value assigned to the parameter\'s \'units\' attribute must be chosen * from one of the following possibilities: one of the base unit * identifiers defined in SBML; one of the built-in unit identifiers * \'substance\', \'time\', \'volume\', \'area\' or \'length\'; or the * identifier of a new unit defined in the list of unit definitions in the * enclosing {@link Model} structure. There are no constraints on the units that * can be chosen from these sets. There are no default units for * parameters. Please consult the SBML specification documents for more * details about the meanings and implications of the various unit choices. *

* The {@link Parameter} structure has an optional boolean attribute named * \'constant\' that indicates whether the parameter\'s value can vary during * a simulation. The attribute\'s default value is true. A value of * false indicates the parameter\'s value can be changed by {@link Rule} constructs * and that the \'value\' attribute is actually intended to be the initial * value of the parameter. Parameters local to a reaction (that is, those * defined within the {@link KineticLaw} structure of a {@link Reaction}) cannot be changed * by rules and therefore are implicitly always constant; thus, parameter * definitions within {@link Reaction} structures should not have their * \'constant\' attribute set to false. *

* What if a global parameter has its \'constant\' attribute set to false, * but the model does not contain any rules, events or other constructs * that ever change its value over time? Although the model may be * suspect, this situation is not strictly an error. A value of false * for \'constant\' only indicates that a parameter can change value, not * that it must. *

* As with all other major SBML components, {@link Parameter} is derived from * {@link SBase}, and the methods defined on {@link SBase} are available on {@link Parameter}. *

* @see ListOfParameters * @see KineticLaw *

* @note The use of the term parameter in SBML sometimes leads to * confusion among readers who have a particular notion of what something * called \'parameter\' should be. It has been the source of heated debate, * but despite this, no one has yet found an adequate replacement term that * does not have different connotations to different people and hence leads * to confusion among some subset of users. Perhaps it would have been * better to have two constructs, one called constants and the other * called variables. The current approach in SBML is simply more * parsimonious, using a single {@link Parameter} construct with the boolean flag * \'constant\' indicating which flavor it is. In any case, readers are * implored to look past their particular definition of a parameter and * simply view SBML\'s {@link Parameter} as a single mechanism for defining both * constants and (additional) variables in a model. (We write * additional because the species in a model are usually considered to be * the central variables.) After all, software tools are not required to * expose to users the actual names of particular SBML constructs, and * thus tools can present to their users whatever terms their designers * feel best matches their target audience. *

* */ " %typemap(javaimports) ListOfParameters " /** * LibSBML implementation of SBML\'s ListOfParameters construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Parameter::Parameter(const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link Parameter}, optionally with the given id and name * attribute values. *

* @param id a string, the identifier to assign to this {@link Parameter} * @param name a string, the optional name to assign to this {@link Parameter} *

* @note It is worth emphasizing that although the identifier is optional * for this constructor, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Parameter} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor if no identifier is provided as an argument. Setting the * identifier can be accomplished using the method {@link SBase#setId(String id)} *

* In contrast to the other constructors for this class, the id * (identifier) and value parameters are required in this call. *

* @param id a string, the identifier to assign to this {@link Parameter} instance * @param value a double, the value to assign to this {@link Parameter} * @param units a string, an optional identifier for units to be assigned * to this {@link Parameter} * @param constant a boolean, the optional value to assign to the * \'constant\' attribute of this {@link Parameter} instance *

* It is worth emphasizing that although this constructor does not take * an identifier argument, in SBML Level 2 and beyond, the \'id\' * (identifier) attribute of a {@link Parameter} is required to have a value. * Thus, callers are cautioned to assign a value after calling this * constructor if no identifier is provided as an argument. Setting the * identifier can be accomplished using the method {@link SBase#setId(String id)}. *

* @param level a long integer, the SBML Level to assign to this {@link Parameter} *

* @param version a long integer, the SBML Version to assign to this * {@link Parameter} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Parameter} *

* @note Once a {@link Parameter} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Parameter}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param orig the {@link Parameter} instance to copy. */ public"; %javamethodmodifiers Parameter::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link Parameter}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link Parameter} in the list * of parameters within which this {@link Parameter} is embedded (i.e., either * the list of parameters in the parent {@link Model} or the list of parameters * in the enclosing {@link KineticLaw}). */ public"; %javamethodmodifiers Parameter::clone() const " /** * Creates and returns a deep copy of this {@link Parameter}. *

* @return a (deep) copy of this {@link Parameter}. */ public"; %javamethodmodifiers Parameter::initDefaults " /** * Initializes the fields of this {@link Parameter} to the defaults defined in * the specification of the relevant Level/Version of SBML. *

* The exact actions of this are as follows: *

(%SBML Level 2 only) set the \'constant\' attribute to true. *

*/ public"; %javamethodmodifiers Parameter::getValue() const " /** * Gets the numerical value of this {@link Parameter}. *

* @return the value of the \'value\' attribute of this {@link Parameter}, as a * number of type double. *

* @see #isSetValue() *

* @note It is crucial that callers not blindly call * Parameter.getValue() without first checking with * Parameter.isSetValue() to determine whether a value has been set. * Otherwise, the value return by Parameter.getValue() may not actually * represent a value assigned to the parameter. */ public"; %javamethodmodifiers Parameter::getUnits() const " /** * Gets the units defined for this {@link Parameter} *

* @return the value of the \'units\' attribute of this {@link Parameter}, as a * string. */ public"; %javamethodmodifiers Parameter::getConstant() const " /** * Gets the value of the \'constant\' attribute of this {@link Parameter} instance. *

* Note that in SBML Level 2 and beyond, the default value of * {@link Parameter}\'s \'constant\' attribute is true. Since a boolean value * can only be true or false, there is no \'isSetConstant()\' * method as is available for the other attributes on {@link Parameter}, because * \'unset\' is not an option. *

* @return true if this {@link Parameter} has been declared as being constant, * false otherwise. */ public"; %javamethodmodifiers Parameter::isSetValue() const " /** * Predicate returning true or false depending on whether the * \'value\' attribute of this {@link Parameter} has been set. *

* In SBML definitions after SBML Level 1 Version 1, * parameter values are optional and have no defaults. If a model read * from a file does not contain a setting for the \'value\' attribute of a * parameter, its value is considered unset; it does not default to any * particular value. Similarly, when a {@link Parameter} object is created in * libSBML, it has no value until given a value. The * Parameter.isSetValue() method allows calling applications to * determine whether a given parameter\'s value has ever been set. *

* In SBML Level 1 Version 1, parameters are required to have * values and therefore, the value of a {@link Parameter} should always be * set. In Level 1 Version 2 and beyond, the value is * optional and as such, the \'value\' attribute may or may not be set. *

* @return true if the value of this {@link Parameter} has been set, * false otherwise. *

* @see #getValue() *

* @note It is crucial that callers not blindly call * Parameter.getValue() without first checking with * Parameter.isSetValue() to determine whether a value has been set. * Otherwise, the value return by Parameter.getValue() may not actually * represent a value assigned to the parameter. */ public"; %javamethodmodifiers Parameter::isSetUnits() const " /** * Predicate returning true or false depending on whether the * \'units\' attribute of this {@link Parameter} has been set. *

* @return true if the \'units\' attribute of this {@link Parameter} has been * set, false otherwise. */ public"; %javamethodmodifiers Parameter::setValue(double value) " /** * Sets the \'value\' attribute of this {@link Parameter} to the given double * value and marks the attribute as set. *

* @param value a double, the value to assign */ public"; %javamethodmodifiers Parameter::setUnits(const std::string& units) " /** * Sets the \'units\' attribute of this {@link Parameter} to a copy of the given * units identifier units. *

* @param units a string, the identifier of the units to assign to this * {@link Parameter} instance */ public"; %javamethodmodifiers Parameter::setConstant(bool flag) " /** * Sets the \'constant\' attribute of this {@link Parameter} to the given boolean * flag. *

* @param flag a boolean, the value for the \'constant\' attribute of this * {@link Parameter} instance */ public"; %javamethodmodifiers Parameter::unsetValue " /** * Unsets the \'value\' attribute of this {@link Parameter} instance. *

* In SBML Level 1 Version 1, parameters are required to have * values and therefore, the value of a {@link Parameter} should always be * set. In SBML Level 1 Version 2 and beyond, the value * is optional and as such, the \'value\' attribute may or may not be set. */ public"; %javamethodmodifiers Parameter::unsetUnits " /** * Unsets the \'units\' attribute of this {@link Parameter} instance. *

* Parameters in SBML have an attribute (\'units\') for declaring the units * of measurement intended for the parameter\'s value. No defaults are * defined by SBML in the absence of a definition for \'units\'. The * Parameter.getDerivedUnitDefinition() method returns a {@link UnitDefinition} * object based on the units declared for this {@link Parameter} using its * \'units\' attribute, or it returns NULL if no units have been declared. *

* Note that unit declarations for {@link Parameter} are in terms of the * identifier of a unit, but this method returns a {@link UnitDefinition} object, * not a unit identifier. It does this by constructing an appropriate * {@link UnitDefinition} even when the value of the \'units\' attribute is one of * the predefined SBML units \'substance\', \'volume\', \'area\', * \'length\' or \'time\'. Callers may find this particularly useful * when used in conjunction with the helper methods on {@link UnitDefinition} * for comparing different {@link UnitDefinition} objects. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Parameter}. */ public"; %javamethodmodifiers Parameter::getDerivedUnitDefinition() const " /** * Constructs and returns a {@link UnitDefinition} that corresponds to the units * of this {@link Parameter}\'s value. *

* @return a {@link UnitDefinition} that expresses the units of this * {@link Parameter}. */ public"; %javamethodmodifiers Parameter::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Parameter::getElementName() const " /** * Returns the XML element name of this object, which for {@link Parameter}, is * always \'parameter\'. *

* @return the name of this element, i.e., \'parameter\'. */ public"; %javamethodmodifiers Parameter::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Parameter::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfParameters::clone() const " /** * Creates and returns a deep copy of this {@link ListOfParameters} instance. *

* @return a (deep) copy of this {@link ListOfParameters}. */ public"; %javamethodmodifiers ListOfParameters::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfParameters::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Parameter} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfParameters::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfParameters}, the XML element name is \'listOfParameters\'. *

* @return the name of this element, i.e., \'listOfParameters\'. */ public"; %javamethodmodifiers ListOfParameters::get(unsigned int n) " /** * Get a {@link Parameter} from the {@link ListOfParameters}. *

* @param n the index number of the {@link Parameter} to get. *

* @return the nth {@link Parameter} in this {@link ListOfParameters}. *

* @see #size() */ public"; %javamethodmodifiers ListOfParameters::get " /** * Get a {@link Parameter} from the {@link ListOfParameters}. *

* @param n the index number of the {@link Parameter} to get. *

* @return the nth {@link Parameter} in this {@link ListOfParameters}. *

* @see #size() */ public"; %javamethodmodifiers ListOfParameters::get(const std::string& sid) " /** * Get a {@link Parameter} from the {@link ListOfParameters} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Parameter} to get. *

* @return {@link Parameter} in this {@link ListOfParameters} * with the given id or NULL if no such * {@link Parameter} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfParameters::get(const std::string& sid) const " /** * Get a {@link Parameter} from the {@link ListOfParameters} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Parameter} to get. *

* @return {@link Parameter} in this {@link ListOfParameters} * with the given id or NULL if no such * {@link Parameter} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfParameters::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfParameters} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfParameters::remove(const std::string& sid) " /** * Removes item in this {@link ListOfParameters} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfParameters::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the {@link ListOfParameters} * in a model is (in SBML Level 2 Version 4) the seventh * ListOf___. (However, it differs for different Levels and Versions of * SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfParameters::createObject(XMLInputStream& stream) " /** * Create a {@link ListOfParameters} object corresponding to the next token in * the XML input stream. *

* @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream, or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) InitialAssignment " /** * LibSBML implementation of SBML\'s InitialAssignment construct. *

* SBML Level 2 Versions 2, 3 and 4 provide two ways of assigning initial * values to entities in a model. The simplest and most basic is to set * the values of the appropriate attributes in the relevant components; for * example, the initial value of a model parameter (whether it is a * constant or a variable) can be assigned by setting its \'value\' attribute * directly in the model definition. However, this approach is not * suitable when the value must be calculated, because the initial value * attributes on different components such as species, compartments, and * parameters are single values and not mathematical expressions. In those * situations, the {@link InitialAssignment} construct can be used; it permits the * calculation of the value of a constant or the initial value of a * variable from the values of other quantities in a model. *

* As explained below, the provision of {@link InitialAssignment} does not mean * that models necessarily must use this construct when defining initial * values of quantities in a model. If a value can be set directly using * the relevant attribute of a component in a model, then that * approach may be more efficient and more portable to other software * tools. {@link InitialAssignment} should be used when the other mechanism is * insufficient for the needs of a particular model. *

* The {@link InitialAssignment} construct has some similarities to {@link AssignmentRule}. * The main differences are: (a) an {@link InitialAssignment} can set the value of * a constant whereas an {@link AssignmentRule} cannot, and (b) unlike * {@link AssignmentRule}, an {@link InitialAssignment} definition only applies up to and * including the beginning of simulation time, i.e., t ≤ 0, * while an {@link AssignmentRule} applies at all times. *

* {@link InitialAssignment} has a required attribute, \'symbol\', whose value must * follow the guidelines for identifiers described in the SBML * specification (e.g., Section 3.3 in the Level 2 Version 4 * specification). The value of this attribute in an {@link InitialAssignment} * object can be the identifier of a {@link Compartment}, {@link Species} or global * {@link Parameter} elsewhere in the model. The {@link InitialAssignment} defines the * initial value of the constant or variable referred to by the \'symbol\' * attribute. (The attribute\'s name is \'symbol\' rather than \'variable\' * because it may assign values to constants as well as variables in a * model.) Note that an initial assignment cannot be made to reaction * identifiers, that is, the \'symbol\' attribute value of an * {@link InitialAssignment} cannot be an identifier that is the \'id\' attribute * value of a {@link Reaction} object in the model. This is identical to a * restriction placed on rules. *

* {@link InitialAssignment} also has a required \'math\' subelement that contains a * MathML expression used to calculate the value of the constant or the * initial value of the variable. The units of the value computed by the * formula in the \'math\' subelement should (in SBML Level 2 * Version 4) or must (in previous Versions) be identical to be the * units associated with the identifier given in the \'symbol\' attribute. * (That is, the units are the units of the species, compartment, or * parameter, as appropriate for the kind of object identified by the value * of \'symbol\'.) *

* {@link InitialAssignment} was introduced in SBML Level 2 Version 2. It is not * available in earlier versions of Level 2 nor in any version of Level 1. *

Semantics of Initial Assignments

* The value calculated by an {@link InitialAssignment} object overrides the value * assigned to the given symbol by the object defining that symbol. For * example, if a compartment\'s \'size\' attribute is set in its definition, * and the model also contains an {@link InitialAssignment} having that * compartment\'s identifier as its \'symbol\' attribute value, then the * interpretation is that the \'size\' assigned in the {@link Compartment} object * should be ignored and the value assigned based on the computation * defined in the {@link InitialAssignment}. Initial assignments can take place * for {@link Compartment}, {@link Species} and global {@link Parameter} objects regardless of the * value of their \'constant\' attribute. *

* The actions of all {@link InitialAssignment} objects are in general terms * the same, but differ in the precise details depending on the type * of variable being set: *

In the case of a species, an {@link InitialAssignment} sets the * referenced species\' initial quantity (concentration or amount of * substance) to the value determined by the formula in the \'math\' * subelement. The overall units of the formula should (in SBML * Level 2 Version 4) or must (in previous Versions) be the same * as the units specified for the species. *
*
In the case of a compartment, an {@link InitialAssignment} sets * the referenced compartment\'s initial size to the size determined by the * formula in \'math\'. The overall units of the formula should (in SBML * Level 2 Version 4) or must (in previous Versions) be the same * as the units specified for the size of the compartment. *
*
In the case of a parameter, an {@link InitialAssignment} sets the * referenced parameter\'s initial value to that determined by the formula * in \'math\'. The overall units of the formula should (in SBML * Level 2 Version 4) or must (in previous Versions) be the same * as the units defined for the parameter.

* In the context of a simulation, initial assignments establish values * that are in effect prior to and including the start of simulation time, * i.e., t ≤ 0. Section 3.4.8 in the SBML Level 2 * Version 4 specification provides information about the interpretation of * assignments, rules, and entity values for simulation time up to and * including the start time t = 0; this is important for * establishing the initial conditions of a simulation if the model * involves expressions containing the delay \'csymbol\'. *

* There cannot be two initial assignments for the same symbol in a model; * that is, a model must not contain two or more {@link InitialAssignment} objects * that both have the same identifier as their \'symbol\' attribute value. A * model must also not define initial assignments and assignment * rules for the same entity. That is, there cannot be both an * {@link InitialAssignment} and an {@link AssignmentRule} for the same symbol in a model, * because both kinds of constructs apply prior to and at the start of * simulated time—allowing both to exist for a given symbol would * result in indeterminism). *

* The ordering of {@link InitialAssignment} objects is not significant. The * combined set of {@link InitialAssignment}, {@link AssignmentRule} and {@link KineticLaw} * objects form a set of assignment statements that must be considered as a * whole. The combined set of assignment statements should not contain * algebraic loops: a chain of dependency between these statements should * terminate. (More formally, consider the directed graph of assignment * statements where nodes are a model\'s assignment statements and directed * arcs exist for each occurrence of a symbol in an assignment statement * \'math\' attribute. The directed arcs in this graph start from the * statement assigning the symbol and end at the statement that contains * the symbol in their math elements. Such a graph must be acyclic.) *

* Finally, it is worth being explicit about the expected behavior in the * following situation. Suppose (1) a given symbol has a value x * assigned to it in its definition, and (2) there is an initial assignment * having the identifier as its \'symbol\' value and reassigning the value to * y, and (3) the identifier is also used in the * mathematical formula of a second initial assignment. What value should * the second initial assignment use? It is y, the value assigned * to the symbol by the first initial assignment, not whatever value was * given in the symbol\'s definition. This follows directly from the * behavior described above: if an {@link InitialAssignment} object exists for a * given symbol, then the symbol\'s value is overridden by that initial * assignment. *

* *

*/ " %typemap(javaimports) ListOfInitialAssignments " /** * LibSBML implementation of SBML\'s ListOfInitialAssignments construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers InitialAssignment::InitialAssignment(const std::string& symbol = "") " /** * Creates a new {@link InitialAssignment}, optionally with its \'symbol\' * attribute set. *

* @param symbol an identifier to assign as the value of the \'symbol\' * attribute of this {@link InitialAssignment} *

* @param level a long integer, the SBML Level to assign to this {@link InitialAssignment} *

* @param version a long integer, the SBML Version to assign to this * {@link InitialAssignment} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link InitialAssignment} *

* @note Once a {@link InitialAssignment} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link InitialAssignment}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link InitialAssignment} in * the list of compartment types. */ public"; %javamethodmodifiers InitialAssignment::clone() const " /** * Creates and returns a deep copy of this {@link InitialAssignment}. *

* @return a (deep) copy of this {@link InitialAssignment}. */ public"; %javamethodmodifiers InitialAssignment::getSymbol() const " /** * Get the value of the \'symbol\' attribute of this {@link InitialAssignment}. *

* @return the identifier string stored as the \'symbol\' attribute value * in this {@link InitialAssignment}. */ public"; %javamethodmodifiers InitialAssignment::getMath() const " /** * Get the mathematical formula of this {@link InitialAssignment}. *

* @return an {@link ASTNode}, the value of the \'math\' subelement of this * {@link InitialAssignment} */ public"; %javamethodmodifiers InitialAssignment::isSetSymbol() const " /** * Predicate returning true or false depending on whether this * {@link InitialAssignment}\'s \'symbol\' attribute has been set. *

* @return true if the \'symbol\' attribute of this {@link InitialAssignment} * has been set, false otherwise. */ public"; %javamethodmodifiers InitialAssignment::isSetMath() const " /** * Predicate returning true or false depending on whether this * {@link InitialAssignment}\'s \'math\' subelement contains a value. *

* @return true if the \'math\' for this {@link InitialAssignment} has been set, * false otherwise. */ public"; %javamethodmodifiers InitialAssignment::setSymbol(const std::string& sid) " /** * Sets the \'symbol\' attribute value of this {@link InitialAssignment}. *

* @param sid the identifier of a {@link Species}, {@link Compartment} or {@link Parameter} * object defined elsewhere in this {@link Model}. */ public"; %javamethodmodifiers InitialAssignment::setMath(const ASTNode* math) " /** * Sets the \'math\' subelement of this {@link InitialAssignment}. *

* The AST passed in math is copied. *

* @param math an AST containing the mathematical expression to * be used as the formula for this {@link InitialAssignment}. */ public"; %javamethodmodifiers InitialAssignment::getDerivedUnitDefinition " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link InitialAssignment}. *

* The units are calculated based on the mathematical expression in the * {@link InitialAssignment} and the model quantities referenced by * <ci> elements used within that expression. The * getDerivedUnitDefinition() method returns the calculated units. *

* @warning Note that it is possible the \'math\' expression in the * {@link InitialAssignment} contains pure numbers or parameters with undeclared * units. In those cases, it is not possible to calculate the units of * the overall expression without making assumptions. LibSBML does not * make assumptions about the units, and getDerivedUnitDefinition() only * returns the units as far as it is able to determine them. For * example, in an expression X + Y, if X has * unambiguously-defined units and Y does not, it will return * the units of X. It is important that callers also * invoke the method containsUndeclaredUnits() to * determine whether this situation holds. Callers may wish to * take suitable actions in those scenarios. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link InitialAssignment}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers InitialAssignment::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link InitialAssignment}. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link InitialAssignment}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers InitialAssignment::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether * the math expression of this {@link InitialAssignment} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link InitialAssignment} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers InitialAssignment::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether * the math expression of this {@link InitialAssignment} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link InitialAssignment} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers InitialAssignment::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers InitialAssignment::getElementName() const " /** * Returns the XML element name of this object, which for * {@link InitialAssignment}, is always \'initialAssignment\'. *

* @return the name of this element, i.e., \'initialAssignment\'. */ public"; %javamethodmodifiers InitialAssignment::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers InitialAssignment::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers InitialAssignment::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers InitialAssignment::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfInitialAssignments::clone() const " /** * Creates and returns a deep copy of this {@link ListOfInitialAssignments} instance. *

* @return a (deep) copy of this {@link ListOfInitialAssignments}. */ public"; %javamethodmodifiers ListOfInitialAssignments::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfInitialAssignments::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link InitialAssignment} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfInitialAssignments::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfInitialAssignments}, the XML element name is * \'listOfInitialAssignments\'. *

* @return the name of this element, i.e., \'listOfInitialAssignments\'. */ public"; %javamethodmodifiers ListOfInitialAssignments::get(unsigned int n) " /** * Get a {@link InitialAssignment} from the {@link ListOfInitialAssignments}. *

* @param n the index number of the {@link InitialAssignment} to get. *

* @return the nth {@link InitialAssignment} in this {@link ListOfInitialAssignments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfInitialAssignments::get " /** * Get a {@link InitialAssignment} from the {@link ListOfInitialAssignments}. *

* @param n the index number of the {@link InitialAssignment} to get. *

* @return the nth {@link InitialAssignment} in this {@link ListOfInitialAssignments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfInitialAssignments::get(const std::string& sid) " /** * Get a {@link InitialAssignment} from the {@link ListOfInitialAssignments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link InitialAssignment} to get. *

* @return {@link InitialAssignment} in this {@link ListOfInitialAssignments} * with the given id or NULL if no such * {@link InitialAssignment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfInitialAssignments::get(const std::string& sid) const " /** * Get a {@link InitialAssignment} from the {@link ListOfInitialAssignments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link InitialAssignment} to get. *

* @return {@link InitialAssignment} in this {@link ListOfInitialAssignments} * with the given id or NULL if no such * {@link InitialAssignment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfInitialAssignments::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfInitialAssignments} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfInitialAssignments::remove(const std::string& sid) " /** * Removes item in this {@link ListOfInitialAssignments} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfInitialAssignments::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the * {@link ListOfInitialAssignments} in a model is (in SBML Level 2 Version 4) * the eigth ListOf___. (However, it differs for different Levels and * Versions of SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfInitialAssignments::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Rule " /** * LibSBML implementation of SBML\'s Rule construct. *

* In SBML, rules provide additional ways to define the values of * variables in a model, their relationships, and the dynamical behaviors * of those variables. They enable encoding relationships that cannot be * expressed using {@link Reaction} nor {@link InitialAssignment} objects alone. *

* The libSBML implementation of rules mirrors the SBML Level 2 * Version 4 definition, with {@link Rule} being the parent class of three * subclasses as explained below. The {@link Rule} class itself cannot be * instantiated by user programs and has no constructor; only the * subclasses {@link AssignmentRule}, {@link AlgebraicRule} and {@link RateRule} can be * instantiated directly. *

General summary of SBML rules

In SBML Level 2, rules are separated into three subclasses for the benefit of model analysis software. The three subclasses are based on the following three different possible functional forms (where x is a variable, f is some arbitrary function returning a numerical result, V is a vector of variables that does not include x, and W is a vector of variables that may include x):

Algebraic:	left-hand side is zero	0 = f(W)
Assignment:	left-hand side is a scalar:	x = f(V)
Rate:	left-hand side is a rate-of-change:	dx/dt = f(W)

In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons:

Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see {@link InitialAssignment}.)
SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops.
Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations;
Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and
Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules.

The approach taken to covering these cases in SBML is to define an abstract {@link Rule} structure containing a subelement, \'math\', to hold the right-hand side expression, then to derive subtypes of {@link Rule} that add attributes to distinguish the cases of algebraic, assignment and rate rules. The \'math\' subelement must contain a MathML expression defining the mathematical formula of the rule. This MathML formula must return a numerical value. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model.

Each of the three subclasses of {@link Rule} (AssignmentRule, {@link AlgebraicRule}, {@link RateRule}) inherit the the \'math\' subelement and other fields from {@link SBase}. The {@link AssignmentRule} and {@link RateRule} classes add an additional attribute, \'variable\'. See the definitions of {@link AssignmentRule}, {@link AlgebraicRule} and {@link RateRule} for details about the structure and interpretation of each one.

Additional restrictions on SBML rules

An important design goal of SBML rule semantics is to ensure that a model\'s simulation and analysis results will not be dependent on when or how often rules are evaluated. To achieve this, SBML needs to place two restrictions on rule use. The first concerns algebraic loops in the system of assignments in a model, and the second concerns overdetermined systems.

A model must not contain algebraic loops

The combined set of {@link InitialAssignment}, {@link AssignmentRule} and {@link KineticLaw} objects in a model constitute a set of assignment statements that should be considered as a whole. (A {@link KineticLaw} object is counted as an assignment because it assigns a value to the symbol contained in the \'id\' attribute of the {@link Reaction} object in which it is defined.) This combined set of assignment statements must not contain algebraic loops—dependency chains between these statements must terminate. To put this more formally, consider a directed graph in which nodes are assignment statements and directed arcs exist for each occurrence of an SBML species, compartment or parameter symbol in an assignment statement\'s \'math\' subelement. Let the directed arcs point from the statement assigning the symbol to the statements that contain the symbol in their \'math\' subelement expressions. This graph must be acyclic.

SBML does not specify when or how often rules should be evaluated. Eliminating algebraic loops ensures that assignment statements can be evaluated any number of times without the result of those evaluations changing. As an example, consider the set of equations x = x + 1, y = z + 200 and z = y + 100. If this set of equations were interpreted as a set of assignment statements, it would be invalid because the rule for x refers to x (exhibiting one type of loop), and the rule for y refers to z while the rule for z refers back to y (exhibiting another type of loop). Conversely, the following set of equations would constitute a valid set of assignment statements: x = 10, y = z + 200, and z = x + 100.

A model must not be overdetermined

An SBML model must not be overdetermined; that is, a model must not define more equations than there are unknowns in a model. An SBML model that does not contain {@link AlgebraicRule} structures cannot be overdetermined.

LibSBML 3.3 implements the static analysis procedure described in Appendix D of the SBML Level 2 Version 4 specification for assessing whether a model is overdetermined.

(In summary, assessing whether a given continuous, deterministic, mathematical model is overdetermined does not require dynamic analysis; it can be done by analyzing the system of equations created from the model. One approach is to construct a bipartite graph in which one set of vertices represents the variables and the other the set of vertices represents the equations. Place edges between vertices such that variables in the system are linked to the equations that determine them. For algebraic equations, there will be edges between the equation and each variable occurring in the equation. For ordinary differential equations (such as those defined by rate rules or implied by the reaction rate definitions), there will be a single edge between the equation and the variable determined by that differential equation. A mathematical model is overdetermined if the maximal matchings of the bipartite graph contain disconnected vertexes representing equations. If one maximal matching has this property, then all the maximal matchings will have this property; i.e., it is only necessary to find one maximal matching.)

RuleType_t

SBML Level 1 uses a different scheme than SBML Level 2 for distinguishing rules; specifically, it uses an attribute whose value is drawn from an enumeration. LibSBML supports this using methods that work with the RuleType_t enumeration.

Enumerator	Meaning
RULE_TYPE_RATE	Indicates the rule is a \'rate\' rule.
RULE_TYPE_SCALAR	Indicates the rule is a \'scalar\' rule.
RULE_TYPE_UNKNOWN	Indicates the rule type is unknown or not yet set.

* */ " %typemap(javaimports) AlgebraicRule " /** * LibSBML implementation of SBML\'s AlgebraicRule construct. *

* The rule type {@link AlgebraicRule} is derived from the parent class {@link Rule}. It * is used to express equations that are neither assignments of model * variables nor rates of change. {@link AlgebraicRule} does not add any * attributes to the basic {@link Rule}; its role is simply to distinguish this * case from the other cases. *

* In the context of a simulation, algebraic rules are in effect at all * times, t ≥ 0. For purposes of evaluating * expressions that involve the delay \'csymbol\' (see the SBML * specification), algebraic rules are considered to apply also at * t ≤ 0. The SBML Level 2 Version 4 * specification provides additional information about the semantics of * assignments, rules, and entity values for simulation time t * ≤ 0. *

* The ability to define arbitrary algebraic expressions in an SBML model * introduces the possibility that a model is mathematically overdetermined * by the overall system of equations constructed from its rules and * reactions. An SBML model must not be overdetermined; see the * description of {@link Rule} and also the SBML Level 2 Version 4 * specification. An SBML model that does not contain {@link AlgebraicRule} * structures cannot be overdetermined. *

* Assessing whether a given continuous, deterministic, mathematical model * is overdetermined does not require dynamic analysis; it can be done by * analyzing the system of equations created from the model. One approach * is to construct a bipartite graph in which one set of vertices * represents the variables and the other the set of vertices represents * the equations. Place edges between vertices such that variables in the * system are linked to the equations that determine them. For algebraic * equations, there will be edges between the equation and each variable * occurring in the equation. For ordinary differential equations (such as * those defined by rate rules or implied by the reaction rate * definitions), there will be a single edge between the equation and the * variable determined by that differential equation. A mathematical model * is overdetermined if the maximal matchings of the bipartite graph * contain disconnected vertexes representing equations. (If one maximal * matching has this property, then all the maximal matchings will have * this property; i.e., it is only necessary to find one maximal matching.) * Appendix D of the SBML Level 2 Version 4 specification * describes a method of applying this procedure to specific SBML data * objects. *

General summary of SBML rules

Algebraic:	left-hand side is zero	0 = f(W)
Assignment:	left-hand side is a scalar:	x = f(V)
Rate:	left-hand side is a rate-of-change:	dx/dt = f(W)

In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons:

Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see {@link InitialAssignment}.)
SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops.
Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations;
Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and
Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules.

Additional restrictions on SBML rules

A model must not contain algebraic loops

A model must not be overdetermined

LibSBML 3.3 implements the static analysis procedure described in Appendix D of the SBML Level 2 Version 4 specification for assessing whether a model is overdetermined.

RuleType_t

Enumerator	Meaning
RULE_TYPE_RATE	Indicates the rule is a \'rate\' rule.
RULE_TYPE_SCALAR	Indicates the rule is a \'scalar\' rule.
RULE_TYPE_UNKNOWN	Indicates the rule type is unknown or not yet set.

* */ " %typemap(javaimports) AssignmentRule " /** * LibSBML implementation of SBML\'s AssignmentRule construct. *

* The rule type {@link AssignmentRule} is derived from the parent class {@link Rule}. It * is used to express equations that set the values of variables. The * left-hand side (the attribute named \'variable\') of an assignment rule * can refer to the identifier of a {@link Species}, {@link Compartment}, or {@link Parameter} * object in the model (but not a {@link Reaction}). The entity identified must * not have its \'constant\' attribute set to true. The effects of an * {@link AssignmentRule} are in general terms the same, but differ in the precise * details depending on the type of variable being set: *

In the case of a species, an {@link AssignmentRule} sets the * referenced species\' quantity (concentration or amount of * substance) to the value determined by the formula in the subelement * \'math\' of the {@link AssignmentRule} object. The units of the formula in \'math\' * should (in SBML Level 2 Version 4) or must (in previous * Versions) be the same as the units of the species for the * species identified by the \'variable\' attribute of the {@link AssignmentRule}. * Restrictions: There must not be both an {@link AssignmentRule} * \'variable\' attribute and a {@link SpeciesReference} \'species\' attribute having * the same value, unless that species has its \'boundaryCondition\' * attribute set to true. In other words, an assignment rule cannot be * defined for a species that is created or destroyed in a reaction unless * that species is defined as a boundary condition in the model. *
*
In the case of a compartment, an {@link AssignmentRule} sets the * referenced compartment\'s size to the value determined by the formula in * the \'math\' subelement of the {@link AssignmentRule} object. The overall units * of the formula in \'math\' should (in SBML Level 2 Version 4) or * must (in previous Versions) be the same as the units of the size of the * compartment. *
*
In the case of a parameter, an {@link AssignmentRule} sets the * referenced parameter\'s value to that determined by the formula in the * \'math\' subelement of the {@link AssignmentRule} object. The overall units of * the formula in the \'math\' subelement should (in SBML Level 2 * Version 4) or must (in previous Versions) be the same as the units * defined for the parameter.

* In the context of a simulation, assignment rules are in effect at all * times, t ≥ 0. For purposes of evaluating * expressions that involve the delay \'csymbol\' (see the SBML * Level 2 specification), assignment rules are considered to apply * also at t ≤ 0. The SBML Level 2 * Version 4 specification provides additional information about the * semantics of assignments, rules, and entity values for simulation time * t ≤ 0. *

* A model must not contain more than one {@link AssignmentRule} or {@link RateRule} * object having the same value of \'variable\'; in other words, in the set * of all assignment rules and rate rules in an SBML model, each variable * appearing in the left-hand sides can only appear once. This simply * follows from the fact that an indeterminate system would result if a * model contained more than one assignment rule for the same variable or * both an assignment rule and a rate rule for the same variable. *

* Similarly, a model must also not contain both an {@link AssignmentRule} * and an {@link InitialAssignment} for the same variable, because both kinds of * constructs apply prior to and at the start of simulation time, i.e., * t ≤ 0. If a model contained both an initial * assignment and an assignment rule for the same variable, an * indeterminate system would result. *

* The value calculated by an {@link AssignmentRule} object overrides the value * assigned to the given symbol by the object defining that symbol. For * example, if a {@link Compartment}\'s \'size\' attribute value is set in its * definition, and the model also contains an {@link AssignmentRule} having that * compartment\'s \'id\' as its \'variable\' value, then the \'size\' assigned in * the {@link Compartment} definition is ignored and the value assigned based on * the computation defined in the {@link AssignmentRule}. This does not * mean that a definition for a given symbol can be omitted if there is an * {@link AssignmentRule} object for it. For example, there must be a {@link Parameter} * definition for a given parameter if there is an {@link AssignmentRule} for that * parameter. It is only a question of which value definition takes * precedence. *

General summary of SBML rules

Algebraic:	left-hand side is zero	0 = f(W)
Assignment:	left-hand side is a scalar:	x = f(V)
Rate:	left-hand side is a rate-of-change:	dx/dt = f(W)

In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons:

Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see {@link InitialAssignment}.)
SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops.
Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations;
Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and
Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules.

Additional restrictions on SBML rules

A model must not contain algebraic loops

A model must not be overdetermined

LibSBML 3.3 implements the static analysis procedure described in Appendix D of the SBML Level 2 Version 4 specification for assessing whether a model is overdetermined.

RuleType_t

Enumerator	Meaning
RULE_TYPE_RATE	Indicates the rule is a \'rate\' rule.
RULE_TYPE_SCALAR	Indicates the rule is a \'scalar\' rule.
RULE_TYPE_UNKNOWN	Indicates the rule type is unknown or not yet set.

* */ " %typemap(javaimports) RateRule " /** * LibSBML implementation of SBML\'s RateRule construct. *

* The rule type {@link RateRule} is derived from the parent class {@link Rule}. It is * used to express equations that determine the rates of change of * variables. The left-hand side (the \'variable\' attribute) can refer to * the identifier of a species, compartment, or parameter (but not a * reaction). The entity identified must have its \'constant\' attribute set * to false. The effects of a {@link RateRule} are in general terms the same, * but differ in the precise details depending on which variable is being * set: *

In the case of a species, a {@link RateRule} sets the rate of * change of the species\' quantity (concentration or amount of * substance) to the value determined by the formula in the \'math\' * subelement of the {@link RateRule} object. The overall units of the formula in * \'math\' should (in SBML Level 2 Version 4) or must (in previous * Versions) be species quantity/time, where the * time units are the SBML predefined units of time and the * species quantity units are the units of the species. * Restrictions: There must not be both a {@link RateRule} \'variable\' * attribute and a {@link SpeciesReference} \'species\' attribute having the same * value, unless that species has its \'boundaryCondition\' attribute is set * to true. This means a rate rule cannot be defined for a species that * is created or destroyed in a reaction, unless that species is defined as * a boundary condition in the model. *
*
In the case of a compartment, a {@link RateRule} sets the rate of * change of the compartment\'s size to the value determined by the formula * in the \'math\' subelement of the {@link RateRule} object. The overall units of * the formula should (in SBML Level 2 Version 4) or must (in previous * Versions) be size/time, where the time * units are the SBML predefined units of time and the size units * are the units of size on the compartment. *
*
In the case of a parameter, a {@link RateRule} sets the rate of * change of the parameter\'s value to that determined by the formula in the * \'math\' subelement of the {@link RateRule} object. The overall units of the * formula should (in SBML Level 2 Version 4) or must (in previous * Versions) be x/time, where x are the units * of the parameter. *

* In the context of a simulation, rate rules are in effect for simulation * time t < 0. The SBML Level 2 Version 4 * specification provides additional information about the semantics of * assignments, rules, and entity values for simulation time t * ≤ 0. *

* As mentioned in the description of {@link AssignmentRule}, a model must not * contain more than one {@link RateRule} or {@link AssignmentRule} object having the same * value of \'variable\'; in other words, in the set of all assignment rules * and rate rules in an SBML model, each variable appearing in the * left-hand sides can only appear once. This simply follows from the fact * that an indeterminate system would result if a model contained more than * one assignment rule for the same variable or both an assignment rule and * a rate rule for the same variable. *

General summary of SBML rules

Algebraic:	left-hand side is zero	0 = f(W)
Assignment:	left-hand side is a scalar:	x = f(V)
Rate:	left-hand side is a rate-of-change:	dx/dt = f(W)

In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons:

Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see {@link InitialAssignment}.)
SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops.
Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations;
Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and
Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules.

Additional restrictions on SBML rules

A model must not contain algebraic loops

A model must not be overdetermined

LibSBML 3.3 implements the static analysis procedure described in Appendix D of the SBML Level 2 Version 4 specification for assessing whether a model is overdetermined.

RuleType_t

Enumerator	Meaning
RULE_TYPE_RATE	Indicates the rule is a \'rate\' rule.
RULE_TYPE_SCALAR	Indicates the rule is a \'scalar\' rule.
RULE_TYPE_UNKNOWN	Indicates the rule type is unknown or not yet set.

* */ " %typemap(javaimports) ListOfRules " /** * LibSBML implementation of SBML\'s ListOfRules construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Rule::Rule(const Rule& orig) " /** * Copy constructor; creates a copy of this {@link Rule}. */ public"; %javamethodmodifiers Rule::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link Rule}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Rule::clone() const " /** * Creates and returns a deep copy of this {@link Rule}. *

* @return a (deep) copy of this {@link Rule}. */ public"; %javamethodmodifiers Rule::getFormula() const " /** * Returns the mathematical expression of this {@link Rule} in text-string form. *

* @return the formula for this {@link Rule}. */ public"; %javamethodmodifiers Rule::getMath() const " /** * Get the mathematical formula of this {@link Rule}. *

* @return an {@link ASTNode}, the value of the \'math\' subelement of this {@link Rule} */ public"; %javamethodmodifiers Rule::getVariable() const " /** * Get the value of the \'variable\' attribute of this {@link Rule}. *

* This applies to {@link AssignmentRule} and {@link RateRule}, which have explicit * left-hand sides in their equations. {@link AlgebraicRule} does not have a * variable field. *

* @return the identifier string stored as the \'variable\' attribute value * in this {@link Rule}. */ public"; %javamethodmodifiers Rule::getUnits() const " /** * (SBML Level 1 ParameterRule only) Returns the units for the * mathematical formula of this {@link Rule}. *

* @return the identifier of the units for the expression of this {@link Rule} */ public"; %javamethodmodifiers Rule::isSetFormula() const " /** * Predicate returning true or false depending on whether this * {@link Rule}\'s mathematical expression has been set. *

* This method is equivalent to isSetMath(). This version is present for * easier compatibility with SBML Level 1, in which mathematical * formulas were written in text-string form. *

* @return true if the mathematical formula for this {@link Rule} has been * set, false otherwise. */ public"; %javamethodmodifiers Rule::isSetMath() const " /** * Predicate returning true or false depending on whether this * {@link Rule}\'s mathematical expression has been set. *

* This method is equivalent to isSetFormula(). *

* @return true if the formula (or equivalently the math) for this * {@link Rule} has been set, false otherwise. */ public"; %javamethodmodifiers Rule::isSetVariable() const " /** * Predicate returning true or false depending on whether this * {@link Rule}\'s \'variable\' attribute has been set. *

* @return true if the variable of this {@link Rule} has been set, false * otherwise. */ public"; %javamethodmodifiers Rule::isSetUnits() const " /** * (SBML Level 1 ParameterRule only) Predicate returning true or * false depending on whether this {@link Rule}\'s \'units\' attribute has been set. *

* @return true if the units for this {@link Rule} has been set, false * otherwise */ public"; %javamethodmodifiers Rule::setFormula(const std::string& formula) " /** * Sets the \'math\' subelement of this {@link Rule} to an expression in * text-string form. *

* This is equivalent to setMath(). The provision of using text-string * formulas is retained for easier SBML Level 1 compatibility. The * formula is converted to an {@link ASTNode} internally. *

* @param formula a mathematical formula in text-string form. */ public"; %javamethodmodifiers Rule::setMath(const ASTNode* math) " /** * Sets the \'math\' subelement of this {@link Rule} to a copy of the given * {@link ASTNode}. *

* @param math the {@link ASTNode} structure of the mathematical formula. */ public"; %javamethodmodifiers Rule::setVariable(const std::string& sid) " /** * Sets the \'variable\' attribute of this {@link Rule}. *

* @param sid the identifier of a {@link Compartment}, {@link Species} or {@link Parameter} * elsewhere in the enclosing {@link Model} object. */ public"; %javamethodmodifiers Rule::setUnits(const std::string& sname) " /** * (SBML Level 1 ParameterRule only) Sets the units for this {@link Rule}. *

* @param sname the identifier of the units */ public"; %javamethodmodifiers Rule::unsetUnits " /** * (SBML Level 1 ParameterRule only) Unsets the \'units\' for this {@link Rule}. *

* The units are calculated based on the mathematical expression in the * {@link Rule} and the model quantities referenced by <ci> * elements used within that expression. The getDerivedUnitDefinition() * method returns the calculated units. *

* @warning Note that it is possible the \'math\' expression in the {@link Rule} * contains pure numbers or parameters with undeclared units. In those * cases, it is not possible to calculate the units of the overall * expression without making assumptions. LibSBML does not make * assumptions about the units, and getDerivedUnitDefinition() only * returns the units as far as it is able to determine them. For * example, in an expression X + Y, if X has * unambiguously-defined units and Y does not, it will return * the units of X. It is important that callers also * invoke the method containsUndeclaredUnits() to * determine whether this situation holds. Callers may wish to * take suitable actions in those scenarios. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link Rule}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers Rule::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} that expresses the units of * measurement assumed for the \'math\' expression of this {@link Rule}. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link Rule}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers Rule::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether * the math expression of this {@link Rule} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link Rule} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers Rule::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether * the math expression of this {@link Rule} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link Rule} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers Rule::getType() const " /** * (SBML Level 1) Get the type of rule this is. *

* @return the rule type (a value drawn from the enumeration RuleType_t) of this {@link Rule}. The value * will be either RULE_TYPE_RATE or RULE_TYPE_SCALAR. */ public"; %javamethodmodifiers Rule::isAlgebraic() const " /** * Predicate returning true or false depending on whether this * {@link Rule} is an {@link AlgebraicRule}. *

* @return true if this {@link Rule} is an {@link AlgebraicRule}, false otherwise. */ public"; %javamethodmodifiers Rule::isAssignment() const " /** * Predicate returning true or false depending on whether this * {@link Rule} is an {@link AssignmentRule}. *

* @return true if this {@link Rule} is an {@link AssignmentRule}, false otherwise. */ public"; %javamethodmodifiers Rule::isCompartmentVolume() const " /** * (SBML Level 1 only) Predicate returning true or false depending * on whether this {@link Rule} is an CompartmentVolumeRule. *

* @return true if this {@link Rule} is a CompartmentVolumeRule, false * otherwise. */ public"; %javamethodmodifiers Rule::isParameter() const " /** * (SBML Level 1 only) Predicate returning true or false depending * on whether this {@link Rule} is an ParameterRule. *

* @return true if this {@link Rule} is a ParameterRule, false * otherwise. */ public"; %javamethodmodifiers Rule::isRate() const " /** * Predicate returning true or false depending on whether this {@link Rule} * is a {@link RateRule} (SBML Level 2) or has a \'type\' attribute value of * \'rate\' (SBML Level 1). *

* @return true if this {@link Rule} is a {@link RateRule} (Level 2) or has * type \'rate\' (Level 1), false otherwise. */ public"; %javamethodmodifiers Rule::isScalar() const " /** * Predicate returning true or false depending on whether this {@link Rule} * is an {@link AssignmentRule} (SBML Level 2) or has a \'type\' attribute value of * \'scalar\' (SBML Level 1). *

* @return true if this {@link Rule} is an {@link AssignmentRule} (Level 2) or has * type \'scalar\' (Level 1), false otherwise. */ public"; %javamethodmodifiers Rule::isSpeciesConcentration() const " /** * (SBML Level 1 only) Predicate returning true or false depending * on whether this {@link Rule} is an SpeciesConcentrationRule. *

* @return true if this {@link Rule} is a SpeciesConcentrationRule, false * otherwise. */ public"; %javamethodmodifiers Rule::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Rule::getL1TypeCode() const " /** * Returns the SBML Level 1 type code for this {@link Rule}, or SBML_UNNOWN. *

* @return the SBML Level 1 typecode for this {@link Rule} or SBML_UNKNOWN * (default). */ public"; %javamethodmodifiers Rule::getElementName() const " /** * Returns the XML element name of this object, which can be any * of a number of different strings depending on the SBML Level and the * kind of rule this is. *

* The rules as of libSBML 3.0.0 are the following: *

(Level 2) RateRule: returns \'rateRule\' *
(Level 2) AssignmentRule: returns \'assignmentRule\' *
(Level 2) AlgebraicRule: returns \'algebraicRule\' *
(Level 1 Version 1) SpecieConcentrationRule: returns \'specieConcentrationRule\' *
(Level 1 Version 2) SpeciesConcentrationRule: returns \'speciesConcentrationRule\' *
(Level 1) CompartmentVolumeRule: returns \'compartmentVolumeRule\' *
(Level 1) ParameterRule: returns \'parameterRule\' *
Unknown rule type: returns \'unknownRule\' *

* @return the name of this element */ public"; %javamethodmodifiers Rule::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::setL1TypeCode(SBMLTypeCode_t type) " /** * Sets the SBML Level 1 typecode for this {@link Rule}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::Rule( SBMLTypeCode_t type , const std::string& variable , const std::string& formula ) " /** * Only subclasses may create Rules.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::Rule( SBMLTypeCode_t type , const std::string& variable , const ASTNode* math ) " /** * Only subclasses may create Rules.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Rule::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers AlgebraicRule::AlgebraicRule(const std::string& formula = "") " /** * Creates a new {@link AlgebraicRule}, optionally with the given mathematical * formula expressed in text-string form. *

* This is equivalent to the constructor that takes an {@link ASTNode}. It is * provided for convenience. *

* There exists another form of this method that allows you to use an * {@link ASTNode} as the the formula instead of the text string used by this * variant. *

* @param formula The algebraic expression to be placed in the rule *

* There exists another form of this method that allows you to use a text * string to express the formula instead of the {@link ASTNode} used by this * variant. *

* @param math an {@link ASTNode} containing the mathematical formula expressing * the right-hand side of the algebraic equation */ public"; %javamethodmodifiers AlgebraicRule::AlgebraicRule(unsigned int level, unsigned int version, XMLNamespaces* xmlns = 0) " /** * Creates a new {@link AlgebraicRule} using the given SBML level and version * values and optionally a set of {@link XMLNamespaces}. *

* @param level a long integer, the SBML Level to assign to this {@link AlgebraicRule} *

* @param version a long integer, the SBML Version to assign to this * {@link AlgebraicRule} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link AlgebraicRule} *

* @note Once a {@link AlgebraicRule} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link AlgebraicRule}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @return a (deep) copy of this {@link Rule}. */ public"; %javamethodmodifiers AlgebraicRule::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link AlgebraicRule}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers AlgebraicRule::setInternalIdOnly " /** * sets the mInternalIdOnly flag

* @deprecated libSBML internal */ public"; %javamethodmodifiers AlgebraicRule::getInternalIdOnly() const " /** * sets the mInternalIdOnly flag

* @deprecated libSBML internal */ public"; %javamethodmodifiers AssignmentRule::AssignmentRule( const std::string& variable = "" , const std::string& formula = "" ) " /** * Creates a new {@link AssignmentRule} and optionally sets its variable and * math. *

* There exists another form of this method that allows you to use an * {@link ASTNode} as the the formula instead of the text string used by this * variant. *

* @param variable the identifier of the variable (a {@link Compartment}, {@link Species} * or {@link Parameter} elsewhere in this {@link Model} object) that is being assigned *

* @param formula the mathematical formula placed in the assignment rule, * written as a text string. *

* There exists another form of this method that allows you to use a text * string to express the formula instead of the {@link ASTNode} used by this * variant. *

* @param variable the identifier of the variable (a {@link Compartment}, {@link Species} * or {@link Parameter} elsewhere in this {@link Model} object) that is being assigned *

* @param math an {@link ASTNode} containing the mathematical formula * expressing the right-hand side of the assignment equation */ public"; %javamethodmodifiers AssignmentRule::AssignmentRule(unsigned int level, unsigned int version, XMLNamespaces* xmlns = 0) " /** * Creates a new {@link AssignmentRule} using the given SBML level and version * values and optionally a set of {@link XMLNamespaces}. *

* @param level a long integer, the SBML Level to assign to this {@link AssignmentRule} *

* @param version a long integer, the SBML Version to assign to this * {@link AssignmentRule} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link AssignmentRule} *

* @note Once a {@link AssignmentRule} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link AssignmentRule}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @return a (deep) copy of this {@link Rule}. */ public"; %javamethodmodifiers AssignmentRule::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor} for this instance of {@link AssignmentRule}. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers RateRule::RateRule(const std::string& variable = "", const std::string& formula = "") " /** * Creates a new {@link RateRule} and optionally sets its variable and formula. *

* There exists another form of this method that allows you to use an * {@link ASTNode} as the the formula instead of the text string used by this * variant. *

* @param variable the identifier of the variable (a {@link Compartment}, {@link Species} * or {@link Parameter} elsewhere in this {@link Model} object) that is being assigned *

* @param formula the mathematical formula placed in the assignment rule, * written as a text string. *

* There exists another form of this method that allows you to use a text * string to express the formula instead of the {@link ASTNode} used by this * variant. *

* @param variable the identifier of the variable (a {@link Compartment}, {@link Species} * or {@link Parameter} elsewhere in this {@link Model} object) *

* @param math an {@link ASTNode} containing the mathematical formula * expressing the right-hand side of the rate equation */ public"; %javamethodmodifiers RateRule::RateRule(unsigned int level, unsigned int version, XMLNamespaces* xmlns = 0) " /** * Creates a new {@link RateRule} using the given SBML level and version * values and optionally a set of {@link XMLNamespaces}. *

* @param level a long integer, the SBML Level to assign to this {@link RateRule} *

* @param version a long integer, the SBML Version to assign to this * {@link RateRule} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link RateRule} *

* @note Once a {@link RateRule} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link RateRule}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @return a (deep) copy of this {@link Rule}. */ public"; %javamethodmodifiers RateRule::accept(SBMLVisitor& v) const " /** * Accepts the given {@link SBMLVisitor}. *

* @return the result of calling v.visit(), which indicates * whether or not the Visitor would like to visit the {@link Model}\'s next {@link Rule} * (if available). */ public"; %javamethodmodifiers ListOfRules::clone() const " /** * Creates and returns a deep copy of this {@link ListOfRules} instance. *

* @return a (deep) copy of this {@link ListOfRules}. */ public"; %javamethodmodifiers ListOfRules::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfRules::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Rule} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfRules::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfRules}, the XML element name is \'listOfRules\'. *

* @return the name of this element, i.e., \'listOfRules\'. */ public"; %javamethodmodifiers ListOfRules::get(unsigned int n) " /** * Get a {@link Rule} from the {@link ListOfRules}. *

* @param n the index number of the {@link Rule} to get. *

* @return the nth {@link Rule} in this {@link ListOfRules}. *

* @see #size() */ public"; %javamethodmodifiers ListOfRules::get " /** * Get a {@link Rule} from the {@link ListOfRules}. *

* @param n the index number of the {@link Rule} to get. *

* @return the nth {@link Rule} in this {@link ListOfRules}. *

* @see #size() */ public"; %javamethodmodifiers ListOfRules::get(const std::string& sid) " /** * Get a {@link Rule} from the {@link ListOfRules} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Rule} to get. *

* @return {@link Rule} in this {@link ListOfRules} * with the given id or NULL if no such * {@link Rule} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfRules::get(const std::string& sid) const " /** * Get a {@link Rule} from the {@link ListOfRules} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Rule} to get. *

* @return {@link Rule} in this {@link ListOfRules} * with the given id or NULL if no such * {@link Rule} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfRules::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfRules} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfRules::remove(const std::string& sid) " /** * Removes item in this {@link ListOfRules} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfRules::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfRules::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Constraint " /** * LibSBML implementation of SBML\'s Constraint construct. *

* The {@link Constraint} object class was introduced in SBML Level 2 Version 2 as * a mechanism for stating the assumptions under which a model is designed * to operate. The constraints are statements about permissible * values of different quantities in a model. Constraints are not used to * compute dynamical values for simulation or analysis, but rather, they * serve an advisory role for simulation/analysis tools. *

* SBML\'s {@link Constraint} object class has one required attribute, \'id\', to * give the parameter a unique identifier by which other parts of an SBML * model definition can refer to it. A {@link Constraint} object can also have an * optional \'name\' attribute of type string. Identifiers and names must * be used according to the guidelines described in the SBML specification * (e.g., Section 3.3 in the Level 2 Version 4 specification). *

* {@link Constraint} has one required subelement, \'math\', containing a MathML * formula defining the condition of the constraint. This formula must * return a boolean value of true when the model is a valid * state. The formula can be an arbitrary expression referencing the * variables and other entities in an SBML model. The evaluation of \'math\' * and behavior of constraints are described in more detail below. *

* A {@link Constraint} structure also has an optional subelement called \'message\'. * This can contain a message in XHTML format that may be displayed to the * user when the condition of the formula in the \'math\' subelement * evaluates to a value of false. Software tools are not required to * display the message, but it is recommended that they do so as a matter * of best practice. The XHTML content within a \'message\' subelement must * follow the same restrictions as for the \'notes\' element on {@link SBase} * described in in the SBML Level 2 specification. For example, \'message\' * must not contain an XML declaration or a DOCTYPE declaration, and the * permitted content can only take one of the following general forms: (1) * a complete XHTML document beginning with the element * <html> and ending with </xhtml>; * (2) the body portion of a document beginning with the element * <body> and ending with </body>; or * (3) XHTML content that is permitted within a <body> ... * </body> elements. The appendix of the SBML Level 2 * Version 4 specification document describes one approach to reading the * \'message\' subelement content. *

* {@link Constraint} was introduced in SBML Level 2 Version 2. It is not * available in earlier versions of Level 2 nor in any version of Level 1. *

Semantics of Constraints

* In the context of a simulation, a {@link Constraint} has effect at all times * t ≥ 0. Each {@link Constraint}\'s \'math\' subelement is first * evaluated after any {@link InitialAssignment} definitions in a model at t = * 0 and can conceivably trigger at that point. (In other words, a * simulation could fail a constraint immediately.) *

* {@link Constraint} structures cannot and should not be used to compute * the dynamical behavior of a model as part of, for example, simulation. * Constraints may be used as input to non-dynamical analysis, for instance * by expressing flux constraints for flux balance analysis. *

* The results of a simulation of a model containing a constraint are * invalid from any simulation time at and after a point when the function * given by the \'math\' subelement returns a value of false. Invalid * simulation results do not make a prediction of the behavior of the * biochemical reaction network represented by the model. The precise * behavior of simulation tools is left undefined with respect to * constraints. If invalid results are detected with respect to a given * constraint, the \'message\' subelement may optionally be displayed to the * user. The simulation tool may also halt the simulation or clearly * delimit in output data the simulation time point at which the simulation * results become invalid. *

* SBML does not impose restrictions on duplicate {@link Constraint} definitions or * the order of evaluation of {@link Constraint} objects in a model. It is * possible for a model to define multiple constraints all with the same * mathematical expression. Since the failure of any constraint indicates * that the model simulation has entered an invalid state, a system is not * required to attempt to detect whether other constraints in the model * have failed once any one constraint has failed. *

* *

*/ " %typemap(javaimports) ListOfConstraints " /** * LibSBML implementation of SBML\'s ListOfConstraints construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Constraint::Constraint(const ASTNode* math = NULL) " /** * Creates a new {@link Constraint} optionally with its math set. *

* @param math {@link ASTNode} representing the math of the {@link Constraint}. *

* @param level a long integer, the SBML Level to assign to this {@link Constraint} *

* @param version a long integer, the SBML Version to assign to this * {@link Constraint} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Constraint} *

* @note Once a {@link Constraint} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Constraint}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link Constraint} in the * list of constraints within which this {@link Constraint} is embedded (i.e., in * the {@link ListOfConstraints} located in the enclosing {@link Model} instance). */ public"; %javamethodmodifiers Constraint::clone() const " /** * Creates and returns a deep copy of this {@link Constraint}. *

* @return a (deep) copy of this {@link Constraint}. */ public"; %javamethodmodifiers Constraint::getMessage() const " /** * Get the message, if any, associated with this {@link Constraint} *

* @return the message for this {@link Constraint}, as an {@link XMLNode}. */ public"; %javamethodmodifiers Constraint::getMessageString() const " /** * Get the message string, if any, associated with this {@link Constraint} *

* @return the message for this {@link Constraint}, as a string. */ public"; %javamethodmodifiers Constraint::getMath() const " /** * Get the mathematical expression of this {@link Constraint} *

* @return the math for this {@link Constraint}, as an {@link ASTNode}. */ public"; %javamethodmodifiers Constraint::isSetMessage() const " /** * Predicate returning true or false depending on whether a * message has been defined for this {@link Constraint}. *

* @return true if the message of this {@link Constraint} has been set, * false otherwise. */ public"; %javamethodmodifiers Constraint::isSetMath() const " /** * Predicate returning true or false depending on whether a * mathematical formula has been defined for this {@link Constraint}. *

* @return true if the \'math\' subelement for this {@link Constraint} has been * set, false otherwise. */ public"; %javamethodmodifiers Constraint::setMessage(const XMLNode* xhtml) " /** * Sets the message of this {@link Constraint}. *

* The {@link XMLNode} tree passed in xhtml is copied. *

* @param xhtml an XML tree containing XHTML content. */ public"; %javamethodmodifiers Constraint::setMath(const ASTNode* math) " /** * Sets the mathematical expression of this {@link Constraint} to a copy of the * AST given as math. *

* @param math an {@link ASTNode} expression to be assigned as the \'math\' * subelement of this {@link Constraint} */ public"; %javamethodmodifiers Constraint::unsetMessage " /** * Unsets the \'message\' subelement of this {@link Constraint}. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Constraint::getElementName() const " /** * Returns the XML element name of this object, which for {@link Constraint}, is * always \'constraint\'. *

* @return the name of this element, i.e., \'constraint\'. */ public"; %javamethodmodifiers Constraint::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Constraint::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Constraint::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Constraint::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfConstraints::clone() const " /** * Creates and returns a deep copy of this {@link ListOfConstraints} instance. *

* @return a (deep) copy of this {@link ListOfConstraints}. */ public"; %javamethodmodifiers ListOfConstraints::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfConstraints::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Constraint} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfConstraints::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfConstraints}, the XML element name is \'listOfConstraints\'. *

* @return the name of this element, i.e., \'listOfConstraints\'. */ public"; %javamethodmodifiers ListOfConstraints::get(unsigned int n) " /** * Get a {@link Constraint} from the {@link ListOfConstraints}. *

* @param n the index number of the {@link Constraint} to get. *

* @return the nth {@link Constraint} in this {@link ListOfConstraints}. *

* @see #size() */ public"; %javamethodmodifiers ListOfConstraints::get " /** * Get a {@link Constraint} from the {@link ListOfConstraints}. *

* @param n the index number of the {@link Constraint} to get. *

* @return the nth {@link Constraint} in this {@link ListOfConstraints}. *

* @see #size() */ public"; %javamethodmodifiers ListOfConstraints::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfConstraints} items and returns a * pointer to it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfConstraints::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the {@link ListOfConstraints} * in a model is (in SBML Level 2 Version 4) the tenth ListOf___. * (However, it differs for different Levels and Versions of SBML.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfConstraints::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Reaction " /** * LibSBML 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. These * various parts of a reaction are recorded in the {@link Reaction} object and its * supporting object classes: {@link KineticLaw}, {@link SpeciesReference}, * {@link ModifierSpeciesReference}, {@link ListOfSpeciesReferences}, * ListOfModifierSpeciesReferences, and {@link StoichiometryMath}. It also uses * {@link Parameter} and {@link ListOfParameters}. *

* As with other major object in SBML, {@link 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. 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. {@link 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 (e.g., * Section 3.3 in the Level 2 Version 4 specification). *

* The species participating as reactants, products, and/or modifiers in a * reaction are declared using lists of {@link SpeciesReference} and/or * {@link 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 {@link Species} for more information. *
*
Any species appearing in the mathematical formula of the subelement * \'kineticLaw\' (described below) of a {@link Reaction} must be declared in at * least one of that {@link 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 {@link KineticLaw} object in a subelement named * \'kineticLaw\'. It defines the speed at which the process defined by the * reaction takes place. The description of {@link KineticLaw} provides more * details about its use. Note that although the inclusion of a {@link KineticLaw} * object in an instance of a {@link 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—{@link InitialAssignment}, {@link AssignmentRule}, * {@link RateRule}, {@link AlgebraicRule}, {@link 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. *

* {@link Reaction} also has an optional boolean attribute named \'reversible\' for * indicating whether the reaction is reversible. The default is true. * 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., {@link 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 {@link 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 {@link 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. *

* Finally, {@link Reaction} has another optional boolean attribute called \'fast\'. * It is used to indicate that a reaction occurs on a vastly faster time * scale than others 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, 3 and 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\'. *

* Readers are urged to read the SBML specification for more details about * the proper use of {@link Reaction}. *

*/ " %typemap(javaimports) ListOfReactions " /** * LibSBML implementation of SBML\'s ListOfReactions construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Reaction::Reaction( const std::string& sid = "" , const std::string& name = "" , const KineticLaw* kl = 0 , bool reversible = true ) " /** * Creates a new {@link Reaction}, optionally with the given identifier, * {@link KineticLaw} object and value of the \'reversible\' attribute. *

* @param sid an identifier string for the {@link Reaction} *

* @param name a name string for the {@link Reaction} *

* @param kl a {@link KineticLaw} object *

* @param reversible a boolean value for the \'reversible\' flag *

* @param level a long integer, the SBML Level to assign to this {@link Reaction} *

* @param version a long integer, the SBML Version to assign to this * {@link Reaction} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Reaction} *

* @note Once a {@link Reaction} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Reaction}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Reaction::clone() const " /** * Creates and returns a deep copy of this {@link Reaction}. *

* @return a (deep) copy of this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::initDefaults " /** * Initializes certain attributes of this {@link Reaction} object to default * values. *

Sets the \'reversible\' attribute to true *
(SBML Level 1 only) Sets the \'fast\' attribute to false *

* @warning The \'fast\' attribute must be used with care. SBML * definitions before SBML Level 2 Version 2 incorrectly indicated 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, 3 and 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. * 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. */ public"; %javamethodmodifiers Reaction::getKineticLaw() const " /** * Returns the {@link KineticLaw} object contained in this {@link Reaction}. *

* @return the {@link KineticLaw} instance. */ public"; %javamethodmodifiers Reaction::getKineticLaw " /** * Returns the {@link KineticLaw} object contained in this {@link Reaction}. *

* @return the {@link KineticLaw} instance. */ public"; %javamethodmodifiers Reaction::getReversible() const " /** * Returns the value of the \'reversible\' attribute on the {@link Reaction} as a * boolean value. *

* @return the reversibility status of this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getFast() const " /** * Returns the value of the \'fast\' attribute of this {@link Reaction}. *

* @return the \'fast\' status of this {@link Reaction}. *

* @warning SBML definitions before SBML Level 2 Version 2 incorrectly * indicated 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, 3 and 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. 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. */ public"; %javamethodmodifiers Reaction::isSetKineticLaw() const " /** * Predicate returning true or false depending on whether this * {@link Reaction} contains a kinetic law object. *

* @return true if a {@link KineticLaw} is present in this {@link Reaction},, false * otherwise. */ public"; %javamethodmodifiers Reaction::isSetFast() const " /** * Predicate returning true or false depending on the value of * the \'fast\' attribute on this {@link Reaction}. *

* @return 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 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, 3 and 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. 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. Note * also that in SBML Level 1, \'fast\' is defined as optional with a * default of false, which means it is effectively always set. */ public"; %javamethodmodifiers Reaction::setKineticLaw(const KineticLaw* kl) " /** * Sets the \'kineticLaw\' subelement of this {@link Reaction} to a copy of the * given {@link KineticLaw} object. *

* @param kl the {@link KineticLaw} object to use. */ public"; %javamethodmodifiers Reaction::setReversible(bool value) " /** * Sets the value of the \'reversible\' attribute of this {@link Reaction}. *

* @param value the value of the \'reversible\' attribute. */ public"; %javamethodmodifiers Reaction::setFast(bool value) " /** * Sets the value of the \'fast\' attribute of this {@link Reaction}. *

* @param value the value of the \'fast\' attribute. *

* @warning SBML definitions before SBML Level 2 Version 2 incorrectly * indicated 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, 3 and 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. 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. */ public"; %javamethodmodifiers Reaction::unsetKineticLaw " /** * Unsets the \'kineticLaw\' subelement of this {@link Reaction}. *

* @warning In SBML Level 1, \'fast\' is optional with a default of * false, which means it is effectively always set (and reset to false * if this method is called). Further, SBML definitions before SBML * Level 2 Version 2 incorrectly indicated 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, 3 and 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. 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. */ public"; %javamethodmodifiers Reaction::addReactant(const SpeciesReference* sr) " /** * Adds a given {@link SpeciesReference} object as a reactant in this {@link Reaction}. *

* The {@link SpeciesReference} instance in sr is copied. *

* @param sr a {@link SpeciesReference} object referring to a {@link Species} in the * enclosing {@link Model} *

* @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 in this {@link Reaction}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Reaction}. 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 Reaction.createReactant() * for a method that does not lead to these issues. *

* @see #createReactant() */ public"; %javamethodmodifiers Reaction::addProduct(const SpeciesReference* sr) " /** * Adds a given {@link SpeciesReference} object as a product in this {@link Reaction}. *

* The {@link SpeciesReference} instance in sr is copied. *

* @param sr a {@link SpeciesReference} object referring to a {@link Species} in the * enclosing {@link Model} *

* @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 in this {@link Reaction}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Reaction}. 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 Reaction.createProduct() * for a method that does not lead to these issues. *

* @see #createProduct() */ public"; %javamethodmodifiers Reaction::addModifier(const ModifierSpeciesReference* msr) " /** * Adds a given {@link ModifierSpeciesReference} object as a product in this * {@link Reaction}. *

* The {@link ModifierSpeciesReference} instance in msr is copied. *

* @param msr a {@link ModifierSpeciesReference} object referring to a {@link Species} in * the enclosing {@link Model} *

* @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 in this {@link Reaction}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Reaction}. 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 Reaction.createModifier() * for a method that does not lead to these issues. *

* @see #createModifier() */ public"; %javamethodmodifiers Reaction::createReactant " /** * Creates a new {@link SpeciesReference}, adds it to this {@link Reaction}\'s list of * reactants, and returns it. *

* @return a new {@link SpeciesReference} object. */ public"; %javamethodmodifiers Reaction::createProduct " /** * Creates a new {@link SpeciesReference}, adds it to this {@link Reaction}\'s list of * products, and returns it. *

* @return a new {@link SpeciesReference} object. */ public"; %javamethodmodifiers Reaction::createModifier " /** * Creates a new {@link ModifierSpeciesReference}, adds it to this {@link Reaction}\'s * list of modifiers and returns it. *

* @return a new {@link ModifierSpeciesReference} object. */ public"; %javamethodmodifiers Reaction::createKineticLaw " /** * Creates a new {@link KineticLaw} object, installs it as this {@link Reaction}\'s * \'kineticLaw\' subelement, and returns it. *

* If this {@link Reaction} had a previous {@link KineticLaw}, it will be destroyed. *

* @return the new {@link KineticLaw} object */ public"; %javamethodmodifiers Reaction::getListOfReactants() const " /** * Returns the list of reactants in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as reactants in this reaction */ public"; %javamethodmodifiers Reaction::getListOfReactants " /** * Returns the list of reactants in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as reactants in this reaction */ public"; %javamethodmodifiers Reaction::getListOfProducts() const " /** * Returns the list of products in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as products in this reaction */ public"; %javamethodmodifiers Reaction::getListOfProducts " /** * Returns the list of products in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as products in this reaction */ public"; %javamethodmodifiers Reaction::getListOfModifiers() const " /** * Returns the list of modifiers in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as modifiers in this reaction */ public"; %javamethodmodifiers Reaction::getListOfModifiers " /** * Returns the list of modifiers in this {@link Reaction} object. *

* @return the {@link ListOfSpeciesReferences} containing the references to the * species acting as modifiers in this reaction */ public"; %javamethodmodifiers Reaction::getReactant " /** * Returns the nth reactant species in the list of reactants in this * {@link Reaction}. *

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

* @param n the index of the reactant sought. *

* @return the nth reactant (as a {@link SpeciesReference} object) of this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getReactant(unsigned int n) " /** * Returns the nth reactant species in the list of reactants in this * {@link Reaction}. *

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

* @param n the index of the reactant sought. *

* @return the nth reactant (as a {@link SpeciesReference} object) of this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getReactant(const std::string& species) const " /** * Returns the reactant species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the reactant {@link Species} *

* @return a {@link SpeciesReference} object, or NULL if no species with the * given identifier species appears as a reactant in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getReactant(const std::string& species) " /** * Returns the reactant species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the reactant {@link Species} *

* @return a {@link SpeciesReference} object, or NULL if no species with the * given identifier species appears as a reactant in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getProduct " /** * Returns the nth product species in the list of products in this {@link Reaction}. *

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

* @param n the index of the product sought. *

* @return the nth product (as a {@link SpeciesReference} object) of this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getProduct(unsigned int n) " /** * Returns the nth product species in the list of products in this * {@link Reaction}. *

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

* @param n the index of the product sought. *

* @return the nth product (as a {@link SpeciesReference} object) of this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getProduct(const std::string& species) const " /** * Returns the product species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the product {@link Species} *

* @return a {@link SpeciesReference} object, or NULL if no species with the * given identifier species appears as a product in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getProduct(const std::string& species) " /** * Returns the product species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the product {@link Species} *

* @return a {@link SpeciesReference} object, or NULL if no species with the * given identifier species appears as a product in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getModifier " /** * Returns the nth modifier species in the list of modifiers of this {@link Reaction}. *

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

* @param n the index of the modifier species sought *

* @return the nth modifier (as a {@link ModifierSpeciesReference} object) of * this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getModifier(unsigned int n) " /** * Returns the nth modifier species in the list of modifiers of this {@link Reaction}. *

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

* @param n the index of the modifier species sought *

* @return the nth modifier (as a {@link ModifierSpeciesReference} object) of * this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getModifier(const std::string& species) const " /** * Returns the modifier species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the modifier {@link Species} *

* @return a {@link ModifierSpeciesReference} object, or NULL if no species with * the given identifier species appears as a modifier in this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getModifier(const std::string& species) " /** * Returns the modifier species having a specific identifier in this * {@link Reaction}. *

* @param species the identifier of the modifier {@link Species} *

* @return a {@link ModifierSpeciesReference} object, or NULL if no species with * the given identifier species appears as a modifier in this * {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getNumReactants() const " /** * Returns the number of reactant species in this {@link Reaction}. *

* @return the number of reactants in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getNumProducts() const " /** * Returns the number of product species in this {@link Reaction}. *

* @return the number of products in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::getNumModifiers() const " /** * Returns the number of modifier species in this {@link Reaction}. *

* @return the number of modifiers in this {@link Reaction}. */ public"; %javamethodmodifiers Reaction::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Reaction::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Reaction::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Reaction::getElementName() const " /** * Returns the XML element name of this object, which for {@link Reaction}, is * always \'reaction\'. *

* @return the name of this element, i.e., \'reaction\'. */ public"; %javamethodmodifiers Reaction::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Reaction::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Reaction::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Reaction::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfReactions::clone() const " /** * Creates and returns a deep copy of this {@link ListOfReactions} instance. *

* @return a (deep) copy of this {@link ListOfReactions}. */ public"; %javamethodmodifiers ListOfReactions::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfReactions::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Reaction} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfReactions::getElementName() const " /** * Returns the XML element name of this object, which for * {@link ListOfReactions}, is always \'listOfReactions\'. *

* @return the name of this element, i.e., \'listOfReactions\'. */ public"; %javamethodmodifiers ListOfReactions::get(unsigned int n) " /** * Get a {@link Reaction} from the {@link ListOfReactions}. *

* @param n the index number of the {@link Reaction} to get. *

* @return the nth {@link Reaction} in this {@link ListOfReactions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfReactions::get " /** * Get a {@link Reaction} from the {@link ListOfReactions}. *

* @param n the index number of the {@link Reaction} to get. *

* @return the nth {@link Reaction} in this {@link ListOfReactions}. *

* @see #size() */ public"; %javamethodmodifiers ListOfReactions::get(const std::string& sid) " /** * Get a {@link Reaction} from the {@link ListOfReactions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Reaction} to get. *

* @return {@link Reaction} in this {@link ListOfReactions} * with the given id or NULL if no such * {@link Reaction} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfReactions::get(const std::string& sid) const " /** * Get a {@link Reaction} from the {@link ListOfReactions} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Reaction} to get. *

* @return {@link Reaction} in this {@link ListOfReactions} * with the given id or NULL if no such * {@link Reaction} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfReactions::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfReactions} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfReactions::remove(const std::string& sid) " /** * Removes item in this {@link ListOfReactions} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfReactions::getElementPosition() const " /** * @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfReactions::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) KineticLaw " /** * LibSBML implementation of SBML\'s KineticLaw construct. *

* An object of class {@link KineticLaw} is used to describe the rate at which the * process defined by a given {@link Reaction} takes place. {@link KineticLaw} has * subelements called \'math\' (for MathML content) and \'listOfParameters\' * (of class {@link ListOfParameters}), in addition to the attributes and * subelements it inherits from {@link SBase}. *

* {@link KineticLaw}\'s \'math\' subelement for holding a MathML formula defines the * rate of the reaction. The formula may refer to other entities in a * model (Compartment, {@link Species}, {@link Parameter}, {@link FunctionDefinition}, {@link Reaction}), * but the only {@link Species} identifiers that can be used in this formula are * those declared in the lists of reactants, products and modifiers in the * {@link Reaction} structure. {@link Parameter} identifiers may be taken from either the * {@link KineticLaw}\'s list of local parameters (discussed below) or the * parameters defined globally on the {@link Model} instance. *

* {@link KineticLaw}\'s \'listOfParameters\' subelement can contain a list of one or * more {@link Parameter} objects defining new parameters whose identifiers can be * used in the \'math\' formula of that {@link KineticLaw} instance. The {@link Parameter} * objects so defined are only visible within the {@link KineticLaw}; they cannot * be accessed outside. Moreover, if a {@link Parameter} has the same identifier * as a global {@link Parameter} object defined in the enclosing {@link Model}, the * definition inside the {@link KineticLaw} takes precedence (i.e., it shadows the * global definition). *

* The type of structure used to define a parameter inside {@link KineticLaw} is * the same {@link Parameter} structure used to define global parameters. This * simplifies the SBML language and reduces the number of unique types of * data objects. However, there is a difference between local and global * parameters: in the case of parameters defined locally to a {@link KineticLaw}, * there is no means by which the parameter values can be changed. * Consequently, such parameters\' values are always constant, and the * \'constant\' attribute in their definitions must always have a value of * true (either explicitly or left to its default value). See the * definition of {@link Parameter} for more information about the \'constant\' * attribute. *

Units of rate expressions in {@link KineticLaw}

* It is important to make clear that a so-called kinetic law in SBML is * not identical to a traditional rate law. The reason is that SBML * must support multicompartment models, and the units normally used in * traditional rate laws as well as some conventional single-compartment * modeling packages are problematic when used for defining reactions * between multiple compartments. When modeling species as continuous * amounts (e.g., concentrations), the rate laws used are traditionally * expressed in terms of amount of substance concentration per * time, embodying a tacit assumption that reactants and products are * all located in a single, constant volume. Attempting to describe * reactions between multiple volumes using * concentration/time (which is to say, * substance/volume/time) quickly leads to * difficulties, as explained in the SBML Level 2 Version 2, 3 * and 4 specifications. *

* The need to support multicompartment models requires that the reaction * rates in SBML to be expressed in terms of * substance/time, rather than the more typical * substance/size/time. As a result, modelers * and software tools in general cannot insert textbook rate laws * unmodified as the rate expression in the \'math\' subelement of a * {@link KineticLaw}. The unusual term \'kinetic law\' was chosen to alert users to * this difference. *

* Please consult the SBML specification document for more information * about the definition reaction rates in SBML. *

* @note Before SBML Level 2 Version 2, the SBML specification * included two additional attributes on {@link KineticLaw} called \'substanceUnits\' * and \'timeUnits\'. They were removed beginning with SBML Level 2 * Version 2 because further research determined they introduced many * problems. The most significant problem was that their use could easily * lead to the creation of valid models whose reactions nevertheless could * not be integrated into a system of equations without outside knowledge * for converting the quantities used. Examination of real-life models * revealed that a common reason for using \'substanceUnits\' on {@link KineticLaw} * was to set the units of all reactions to the same set of substance * units, something that is better achieved by using {@link UnitDefinition} to * redefine \'substance\' for the whole {@link Model}. */ " %javamethodmodifiers KineticLaw::KineticLaw( const std::string& formula = "" , const std::string& timeUnits = "" , const std::string& substanceUnits = "" ) " /** * Creates a new {@link KineticLaw} object, optionally with values for its \'formula\', * \'timeUnits\' and/or \'substanceUnits\' attributes. *

* This will copy the strings handed in formula, timeUnits and * substanceUnits. This method is functionally equivalent to the following: *

   *   {@link KineticLaw} k = new {@link KineticLaw}();
   *   k.setFormula(formula);
   *   k.setTimeUnits(timeUnits);
   *   k.setSubstanceUnits(substanceUnits);

* @param formula a mathematical expression in text-string form * representing the rate of the reaction. *

* @param timeUnits the identifier of the time units *

* @param substanceUnits the identifier of the substance units *

* @note SBML Level 1 uses a text-string format for mathematical * formulas. SBML Level 2 uses MathML, an XML format for representing * mathematical expressions. LibSBML provides an Abstract Syntax Tree * API for working with mathematical expressions; this API is more * powerful than working with formulas directly in text form, and ASTs * can be translated into either MathML or the text-string syntax. The * libSBML methods that accept text-string formulas directly (such as * this constructor) are provided for SBML Level 1 compatibility, but * developers are encouraged to use the AST mechanisms. See the other * {@link KineticLaw} constructor for a version that takes an {@link ASTNode}. *

* This will copy the strings handed in timeUnits and * substanceUnits. This method is functionally equivalent to the following: *

   *   {@link KineticLaw} k = new {@link KineticLaw}();
   *   k.setMath(math);
   *   k.setTimeUnits(timeUnits);
   *   k.setSubstanceUnits(substanceUnits);

* @param math an {@link ASTNode} representing the rate of the reaction. *

* @param timeUnits the identifier of the time units *

* @param substanceUnits the identifier of the substance units *

* @param level a long integer, the SBML Level to assign to this {@link KineticLaw} *

* @param version a long integer, the SBML Version to assign to this * {@link KineticLaw} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link KineticLaw} *

* @note Once a {@link KineticLaw} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link KineticLaw}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers KineticLaw::clone() const " /** * Creates and returns a deep copy of this {@link KineticLaw} object. *

* @return a (deep) copy of this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getFormula() const " /** * Returns the mathematical formula for this {@link KineticLaw} object and return * it as as a text string. *

* This is fundamentally equivalent to getMath(). This variant is * provided principally for compatibility compatibility with SBML Level * 1. *

* @return a string representing the formula of this {@link KineticLaw}. *

* @see #getMath() *

* @note SBML Level 1 uses a text-string format for mathematical * formulas. SBML Level 2 uses MathML, an XML format for * representing mathematical expressions. LibSBML provides an Abstract * Syntax Tree API for working with mathematical expressions; this API is * more powerful than working with formulas directly in text form, and * ASTs can be translated into either MathML or the text-string syntax. * The libSBML methods that accept text-string formulas directly (such as * this constructor) are provided for SBML Level 1 compatibility, * but developers are encouraged to use the AST mechanisms. */ public"; %javamethodmodifiers KineticLaw::getMath() const " /** * Returns the mathematical formula for this {@link KineticLaw} object and return * it as as an AST. *

* This is fundamentally equivalent to getFormula(). The latter is * provided principally for compatibility compatibility with SBML Level * 1, which represented mathematical formulas in text-string form. *

* @return the {@link ASTNode} representation of the mathematical formula. *

* @see #getFormula() */ public"; %javamethodmodifiers KineticLaw::getTimeUnits() const " /** * Returns the value of the \'timeUnits\' attribute of this {@link KineticLaw} * object. *

* @return the \'timeUnits\' attribute value *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::getSubstanceUnits() const " /** * Returns the value of the \'substanceUnits\' attribute of this {@link KineticLaw} * object. *

* @return the \'substanceUnits\' attribute value *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::isSetFormula() const " /** * Predicate returning true or false depending on whether this * {@link KineticLaw}\'s \'formula\' attribute has been set *

* This is functionally identical to the method isSetMath(). It is * provided in order to mirror the parallel between getFormula() and * getMath(). *

* @return true if the formula (meaning the math subelement) of * this {@link KineticLaw} has been set, false otherwise. *

* @note SBML Level 1 uses a text-string format for mathematical * formulas. SBML Level 2 uses MathML, an XML format for * representing mathematical expressions. LibSBML provides an Abstract * Syntax Tree API for working with mathematical expressions; this API is * more powerful than working with formulas directly in text form, and * ASTs can be translated into either MathML or the text-string syntax. * The libSBML methods that accept text-string formulas directly (such as * this constructor) are provided for SBML Level 1 compatibility, * but developers are encouraged to use the AST mechanisms. */ public"; %javamethodmodifiers KineticLaw::isSetMath() const " /** * Predicate returning true or false depending on whether this * Kinetic\'s \'math\' subelement has been set *

* This is identical to the method isSetFormula(). It is provided * in order to mirror the parallel between getFormula() and getMath(). *

* @return true if the formula (meaning the math subelement) of * this {@link KineticLaw} has been set, false otherwise. */ public"; %javamethodmodifiers KineticLaw::isSetTimeUnits() const " /** * Predicate returning true or false depending on whether this * {@link SpeciesReference}\'s \'timeUnits\' attribute has been set *

* @return true if the \'timeUnits\' attribute of this {@link KineticLaw} object * has been set, false otherwise. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::isSetSubstanceUnits() const " /** * Predicate returning true or false depending on whether this * {@link SpeciesReference}\'s \'substanceUnits\' attribute has been set *

* @return true if the \'substanceUnits\' attribute of this {@link KineticLaw} * object has been set, false otherwise. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::setFormula(const std::string& formula) " /** * Sets the mathematical expression of this {@link KineticLaw} instance to the * given formula. *

* The given formula string is copied. Internally, libSBML stores the * mathematical expression as an {@link ASTNode}. *

* @param formula the mathematical expression to use, represented in * text-string form. *

* @note SBML Level 1 uses a text-string format for mathematical * formulas. SBML Level 2 uses MathML, an XML format for representing * mathematical expressions. LibSBML provides an Abstract Syntax Tree * API for working with mathematical expressions; this API is more * powerful than working with formulas directly in text form, and ASTs * can be translated into either MathML or the text-string syntax. The * libSBML methods that accept text-string formulas directly (such as * this constructor) are provided for SBML Level 1 compatibility, but * developers are encouraged to use the AST mechanisms. */ public"; %javamethodmodifiers KineticLaw::setMath(const ASTNode* math) " /** * Sets the mathematical expression of this {@link KineticLaw} instance to a copy * of the given {@link ASTNode}. *

* This is fundamentally identical to setFormula(). The latter is * provided principally for compatibility compatibility with SBML Level * 1, which represented mathematical formulas in text-string form. *

* @param math an {@link ASTNode} representing a formula tree. */ public"; %javamethodmodifiers KineticLaw::setTimeUnits(const std::string& sid) " /** * Sets the \'timeUnits\' attribute of this {@link KineticLaw} object to a copy of * the identifier in sid. *

* @param sid the identifier of the units to use. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::setSubstanceUnits(const std::string& sid) " /** * Sets the \'substanceUnits\' attribute of this {@link KineticLaw} object to a copy * of the identifier given in sid. *

* @param sid the identifier of the units to use. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::unsetTimeUnits " /** * Unsets the \'timeUnits\' attribugte of this {@link KineticLaw} object. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::unsetSubstanceUnits " /** * Unsets the \'substanceUnits\' attribute of this {@link KineticLaw} object. *

* @warning In SBML Level 2 Version 2, the \'timeUnits\' and * \'substanceUnits\' attributes were removed. For compatibility with new * versions of SBML, users are cautioned to avoid these attributes. */ public"; %javamethodmodifiers KineticLaw::addParameter(const Parameter* p) " /** * Adds a copy of the given {@link Parameter} object to the list of local * parameters in this {@link KineticLaw}. *

* @param p the {@link Parameter} to add *

* @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 in this {@link KineticLaw}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link KineticLaw}. 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 * KineticLaw.createParameter() for ab method that does not lead to * these issues. *

* @see #createParameter() */ public"; %javamethodmodifiers KineticLaw::createParameter " /** * Creates a new {@link Parameter} object, adds it to this {@link KineticLaw}\'s list of * local parameters, and returns the {@link Parameter} object created. *

* @return a new {@link Parameter} object instance *

* @see #addParameter(Parameter p) */ public"; %javamethodmodifiers KineticLaw::getListOfParameters() const " /** * Returns the list of local parameters in this {@link KineticLaw} object. *

* @return the list of Parameters for this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getListOfParameters " /** * Returns the list of local parameters in this {@link KineticLaw} object. *

* @return the list of Parameters for this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getParameter " /** * Returns the nth {@link Parameter} object in the list of local parameters in * this {@link KineticLaw} instance. *

* @param n the index of the {@link Parameter} object sought *

* @return the nth {@link Parameter} of this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getParameter(unsigned int n) " /** * Returns the nth {@link Parameter} object in the list of local parameters in * this {@link KineticLaw} instance. *

* @param n the index of the {@link Parameter} object sought *

* @return the nth {@link Parameter} of this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getParameter(const std::string& sid) const " /** * Returns a local parameter based on its identifier. *

* @param sid the identifier of the {@link Parameter} being sought. *

* @return the {@link Parameter} object in this {@link KineticLaw} instace having the * given \'id\', or NULL if no such {@link Parameter} exists. */ public"; %javamethodmodifiers KineticLaw::getParameter(const std::string& sid) " /** * Returns a local parameter based on its identifier. *

* @param sid the identifier of the {@link Parameter} being sought. *

* @return the {@link Parameter} object in this {@link KineticLaw} instace having the * given \'id\', or NULL if no such {@link Parameter} exists. */ public"; %javamethodmodifiers KineticLaw::getNumParameters() const " /** * Returns the number of local parameters in this {@link KineticLaw} instance. *

* @return the number of Parameters in this {@link KineticLaw}. */ public"; %javamethodmodifiers KineticLaw::getDerivedUnitDefinition " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link KineticLaw}. *

* The units are calculated based on the mathematical expression in the * {@link KineticLaw} and the model quantities referenced by * <ci> elements used within that expression. The * getDerivedUnitDefinition() method returns the calculated units. *

* @warning Note that it is possible the \'math\' expression in the * {@link KineticLaw} contains pure numbers or parameters with undeclared * units. In those cases, it is not possible to calculate the units of * the overall expression without making assumptions. LibSBML does not * make assumptions about the units, and getDerivedUnitDefinition() only * returns the units as far as it is able to determine them. For * example, in an expression X + Y, if X has * unambiguously-defined units and Y does not, it will return * the units of X. It is important that callers also * invoke the method containsUndeclaredUnits() to * determine whether this situation holds. Callers may wish to * take suitable actions in those scenarios. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link KineticLaw}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers KineticLaw::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link KineticLaw}. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link KineticLaw}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers KineticLaw::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether * the math expression of this {@link KineticLaw} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link KineticLaw} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers KineticLaw::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether * the math expression of this {@link KineticLaw} contains * parameters/numbers with undeclared units. *

* @return true if the math expression of this {@link KineticLaw} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by getDerivedUnitDefinition() may not accurately represent * the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers KineticLaw::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers KineticLaw::getElementName() const " /** * Returns the XML element name of this object, which for {@link Species}, is * always \'kineticLaw\'. *

* @return the name of this element, i.e., \'kineticLaw\'. */ public"; %javamethodmodifiers KineticLaw::getElementPosition() const " /** * @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers KineticLaw::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %typemap(javaimports) SimpleSpeciesReference " /** * LibSBML implementation of SBML\'s SimpleSpeciesReference construct. *

* As mentioned in the description of {@link Reaction}, every species that enters * into a given reaction must appear in that reaction\'s lists of reactants, * products and/or modifiers. In an SBML model, all species that may * participate in any reaction are listed in the \'listOfSpecies\' element of * the top-level {@link Model} object. Lists of products, reactants and modifiers * in {@link Reaction} objects do not introduce new species, but rather, they refer * back to those listed in the model\'s top-level \'listOfSpecies\'. For * reactants and products, the connection is made using {@link SpeciesReference} * objects; for modifiers, it is made using {@link ModifierSpeciesReference} * objects. {@link SimpleSpeciesReference} is an abstract type that serves as the * parent class of both {@link SpeciesReference} and {@link ModifierSpeciesReference}. It * is used simply to hold the attributes and elements that are common to * the latter two structures. *

* The {@link SimpleSpeciesReference} structure has a mandatory attribute, * \'species\', which must be a text string conforming to the identifer * syntax permitted in SBML. This attribute is inherited by the * {@link SpeciesReference} and {@link ModifierSpeciesReference} subclasses derived from * {@link SimpleSpeciesReference}. The value of the \'species\' attribute must be * the identifier of a species defined in the enclosing {@link Model}. The species * is thereby declared as participating in the reaction being defined. The * precise role of that species as a reactant, product, or modifier in the * reaction is determined by the subclass of {@link SimpleSpeciesReference} (i.e., * either {@link SpeciesReference} or {@link ModifierSpeciesReference}) in which the * identifier appears. *

* {@link SimpleSpeciesReference} also contains an optional attribute, \'id\', * allowing instances to be referenced from other structures. No SBML * structures currently do this; however, such structures are anticipated * in future SBML Levels. *

* *

*/ " %typemap(javaimports) SpeciesReference " /** * LibSBML implementation of SBML\'s SpeciesReference construct. *

* The {@link Reaction} structure provides a way to express which species act as * reactants and which species act as products in a reaction. In a given * reaction, references to those species acting as reactants and/or * products are made using instances of {@link SpeciesReference} structures in a * {@link Reaction} object\'s lists of reactants and products. *

* The mandatory \'species\' attribute of {@link SpeciesReference} must have as its * value the identifier of an existing species defined in the enclosing * {@link Model}. The species is thereby designated as a reactant or product in * the reaction. Which one it is (i.e., reactant or product) is indicated * by whether the {@link SpeciesReference} appears in the {@link Reaction}\'s \'reactant\' or * \'product\' lists. *

* Product and reactant stoichiometries can be specified using * either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The \'stoichiometry\' attribute is of type * double and should contain values greater than zero (0). The * \'stoichiometryMath\' element is implemented as an element containing a * MathML expression. These two are mutually exclusive; only one of * \'stoichiometry\' or \'stoichiometryMath\' should be defined in a given * {@link SpeciesReference} instance. When neither the attribute nor the element * is present, the value of \'stoichiometry\' in the {@link SpeciesReference} * instance defaults to 1. *

* For maximum interoperability, the \'stoichiometry\' attribute should be * used in preference to \'stoichiometryMath\' when a species\' stoichiometry * is a simple scalar number (integer or decimal). When the stoichiometry * is a rational number, or when it is a more complicated formula, * \'stoichiometryMath\' must be used. The MathML expression in * \'stoichiometryMath\' may also refer to identifiers of entities in a model * (except reaction identifiers). However, the only species identifiers * that can be used in \'stoichiometryMath\' are those referenced in the * {@link Reaction} list of reactants, products and modifiers. *

* The following is a simple example of a species reference for species * X0, with stoichiometry 2, in a list of reactants within a reaction * having the identifier J1: *

 * <model>
 *     ...
 *     <listOfReactions>
 *         <reaction id=\'J1\'>
 *             <listOfReactants>
 *                 <speciesReference species=\'X0\' stoichiometry=\'2\'>
 *             </listOfReactants>
 *             ...
 *         </reaction>
 *         ...
 *     </listOfReactions>
 *     ...
 * </model>

* The following is a more complex example of a species reference for * species X0, with a stoichiometry formula consisting of the parameter * x: *

 * <model>
 *     ...
 *     <listOfReactions>
 *         <reaction id=\'J1\'>
 *             <listOfReactants>
 *                 <speciesReference species=\'X0\'>
 *                     <stoichiometryMath>
 *                         <math xmlns=\'http://www.w3.org/1998/Math/MathML\'>
 *                             <ci>x</ci>
 *                         </math>
 *                     </stoichiometryMath>
 *                 </speciesReference>
 *             </listOfReactants>
 *             ...
 *         </reaction>
 *         ...
 *     </listOfReactions>
 *     ...
 * </model>

* A species can occur more than once in the lists of reactants and * products of a given {@link Reaction} instance. The effective stoichiometry for * a species in a reaction is the sum of the stoichiometry values given on * the {@link SpeciesReference} object in the list of products minus the sum of * stoichiometry values given on the {@link SpeciesReference} objects in the list * of reactants. A positive value indicates the species is effectively a * product and a negative value indicates the species is effectively a * reactant. SBML places no restrictions on the effective stoichiometry of * a species in a reaction; for example, it can be zero. In the following * SBML fragment, the two reactions have the same effective stoichiometry * for all their species: *

 * <reaction id=\'x\'>
 *     <listOfReactants>
 *         <speciesReference species=\'a\'/>
 *         <speciesReference species=\'a\'/>
 *         <speciesReference species=\'b\'/>
 *     </listOfReactants>
 *     <listOfProducts>
 *         <speciesReference species=\'c\'/>
 *         <speciesReference species=\'b\'/>
 *     </listProducts>
 * </reaction>
 * <reaction id=\'y\'>
 *     <listOfReactants>
 *         <speciesReference species=\'a\' stoichiometry=\'2\'/>
 *     </listOfReactants>
 *     <listOfProducts>
 *         <speciesReference species=\'c\'/>
 *     </listProducts>
 * </reaction>

* *

*/ " %typemap(javaimports) ModifierSpeciesReference " /** * LibSBML implementation of SBML\'s ModifierSpeciesReference construct. *

* Sometimes a species appears in the kinetic rate formula of a reaction * but is itself neither created nor destroyed in that reaction (for * example, because it acts as a catalyst or inhibitor). In SBML, all such * species are simply called modifiers without regard to the detailed * role of those species in the model. The {@link Reaction} structure provides a * way to express which species act as modifiers in a given reaction. This * is the purpose of the list of modifiers available in {@link Reaction}. The list * contains instances of {@link ModifierSpeciesReference} structures. *

* The {@link ModifierSpeciesReference} structure inherits the mandatory attribute * \'species\' and optional attributes \'id\' and \'name\' from the parent class * {@link SimpleSpeciesReference}. See the description of {@link SimpleSpeciesReference} * for more information about these. *

* The value of the \'species\' attribute must be the identifier of a species * defined in the enclosing {@link Model}; this species is designated as a modifier * for the current reaction. A reaction may have any number of modifiers. * It is permissible for a modifier species to appear simultaneously in the * list of reactants and products of the same reaction where it is * designated as a modifier, as well as to appear in the list of reactants, * products and modifiers of other reactions in the model. *

* *

*/ " %typemap(javaimports) ListOfSpeciesReferences " /** * LibSBML implementation of SBML\'s ListOfSpeciesReferences construct. *

* The {@link ListOfSpeciesReferences} class is used to store lists of reactants * and products in a {@link Reaction} object. *

* As with the various other ListOf___ classes in SBML, the * {@link ListOfSpeciesReferences} is merely a container used for organizing * instances of other objects, in this case {@link SpeciesReference} objects. * {@link ListOfSpeciesReferences} is derived from the abstract class {@link SBase}, and * inherit the various attributes and subelements of {@link SBase}, such as * \'metaid\' as and \'annotation\'. The ListOf___ classes do not add any * attributes of their own. */ " %javamethodmodifiers SimpleSpeciesReference::SimpleSpeciesReference(const std::string& species = "") " /** * Creates a new {@link SimpleSpeciesReference}, optionally with its \'species\' * attribute set. *

* The \'species\' attribute on {@link SpeciesReference} and * {@link ModifierSpeciesReference} is required to have a value in SBML. * Although the attribute is optional in this constructor, callers should * provide a value or use setSpecies() shortly after creating the object. *

* @param species the identifier of the species to be referenced *

* @param level a long integer, the SBML Level to assign to this {@link SimpleSpeciesReference} *

* @param version a long integer, the SBML Version to assign to this * {@link SimpleSpeciesReference} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link SimpleSpeciesReference} *

* @note Once a {@link SimpleSpeciesReference} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link SimpleSpeciesReference}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers SimpleSpeciesReference::getSpecies() const " /** * Get the value of the \'species\' attribute. *

* @return the value of the attribute \'species\' for this * {@link SimpleSpeciesReference}. */ public"; %javamethodmodifiers SimpleSpeciesReference::isSetSpecies() const " /** * Predicate returning true or false depending on whether this * {@link SimpleSpeciesReference}\'s \'species\' attribute has been set. *

* @return true if the \'species\' attribute of this * {@link SimpleSpeciesReference} has been set, false otherwise. */ public"; %javamethodmodifiers SimpleSpeciesReference::setSpecies(const std::string& sid) " /** * Sets the \'species\' attribute of this {@link SimpleSpeciesReference}. *

* The identifier string passed in sid is copied. *

* @param sid the identifier of a species defined in the enclosing * {@link Model}\'s {@link ListOfSpecies}. */ public"; %javamethodmodifiers SimpleSpeciesReference::isModifier() const " /** * Predicate returning true or false depending on whether this * is a {@link ModifierSpeciesReference}. *

* @return true if this {@link SimpleSpeciesReference}\'s subclass is * ModiferSpeciesReference, false if it is a plain {@link SpeciesReference}. */ public"; %javamethodmodifiers SimpleSpeciesReference::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SimpleSpeciesReference::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::SpeciesReference( const std::string& species = "" , double stoichiometry = 1.0 , int denominator = 1 ) " /** * Creates a new {@link SpeciesReference}, optionally setting its \'species\', * \'stoichiometry\' and \'denominator\' attribute values. *

* The \'denominator\' attribute is only actually written out in the case * of an SBML Level 1 model. In SBML Level 2, rational-number * stoichiometries are written as MathML elements in the * \'stoichiometryMath\' subelement. However, as a convenience to users, * libSBML allows the creation and manipulation of rational-number * stoichiometries by supplying the numerator and denominator directly * rather than having to manually create an {@link ASTNode} structure. LibSBML * will write out the appropriate constructs (either a combination of * \'stoichiometry\' and \'denominator\' in the case of SBML Level 1, or a * \'stoichiometryMath\' subelement in the case of SBML Level 2). *

* @param species the identifier of the species to be referenced *

* @param stoichiometry the (simple) stoichoiometry *

* @param denominator the denominator, in the case where the stoichoiometry * is a rational number *

* @note The \'species\' attribute on {@link SpeciesReference} is required to have * a value in SBML. Although the attribute is optional in this * constructor, callers should provide a value or use setSpecies() * shortly after creating the object. *

* @param level a long integer, the SBML Level to assign to this {@link SpeciesReference} *

* @param version a long integer, the SBML Version to assign to this * {@link SpeciesReference} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link SpeciesReference} *

* @note Once a {@link SpeciesReference} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link SpeciesReference}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers SpeciesReference::clone() const " /** * Creates and returns a deep copy of this {@link SpeciesReference} instance. *

* @return a (deep) copy of this {@link SpeciesReference}. */ public"; %javamethodmodifiers SpeciesReference::initDefaults " /** * Initializes the attributes of this {@link SpeciesReference} to their defaults. *

stoichiometry is set to 1 *
denominator is set to 1 *

* @see #getDenominator() * @see #setDenominator(int value) * @see #getStoichiometry() * @see #setStoichiometry(double value) * @see #getStoichiometryMath() * @see #setStoichiometryMath(StoichiometryMath math) */ public"; %javamethodmodifiers SpeciesReference::getStoichiometry() const " /** * Get the value of the \'stoichiometry\' attribute. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be * used in preference to \'stoichiometryMath\' when a * species\' stoichiometry * is a simple scalar number (integer or * decimal). *

* @return the value of the (scalar) \'stoichiometry\' attribute of this * {@link SpeciesReference}. *

* @see #getStoichiometryMath() */ public"; %javamethodmodifiers SpeciesReference::getStoichiometryMath() const " /** * Get the content of the \'stoichiometryMath\' subelement as an {@link ASTNode} * tree. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or * decimal). *

* @return the content of the \'stoichiometryMath\' subelement of this * {@link SpeciesReference}. */ public"; %javamethodmodifiers SpeciesReference::getStoichiometryMath " /** * Get the content of the \'stoichiometryMath\' subelement as an {@link ASTNode} * tree. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or * decimal). *

* @return the content of the \'stoichiometryMath\' subelement of this * {@link SpeciesReference}. */ public"; %javamethodmodifiers SpeciesReference::getDenominator() const " /** * Get the value of the \'denominator\' attribute, for the case of a * rational-numbered stoichiometry or a model in SBML Level 1. *

* @return the value of the \'denominator\' attribute of this * {@link SpeciesReference}. */ public"; %javamethodmodifiers SpeciesReference::isSetStoichiometryMath() const " /** * Predicate returning true or false depending on whether this * {@link SpeciesReference}\'s \'stoichiometryMath\' subelement has been set *

* @return true if the \'stoichiometryMath\' subelement of this * {@link SpeciesReference} has been set, false otherwise. */ public"; %javamethodmodifiers SpeciesReference::setStoichiometry(double value) " /** * Sets the value of the \'stoichiometry\' attribute of this * {@link SpeciesReference}. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or * decimal). *

* @param value the new value of the \'stoichiometry\' attribute */ public"; %javamethodmodifiers SpeciesReference::setStoichiometryMath(const StoichiometryMath* math) " /** * Sets the \'stoichiometryMath\' subelement of this {@link SpeciesReference}. *

* The Abstract Syntax Tree in math is copied. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or * decimal). *

* @param math the {@link StoichiometryMath} expression that is to be copied as the * content of the \'stoichiometryMath\' subelement. */ public"; %javamethodmodifiers SpeciesReference::setDenominator(int value) " /** * Set the value of the \'denominator\' attribute, for the case of a * rational-numbered stoichiometry or a model in SBML Level 1. *

* @param value the scalar value */ public"; %javamethodmodifiers SpeciesReference::unsetStoichiometryMath " /** * Unsets the \'stoichiometryMath\' subelement of this {@link SpeciesReference}. *

* In SBML Level 2, Product and reactant stoichiometries can be specified * using either \'stoichiometry\' or \'stoichiometryMath\' in a * {@link SpeciesReference} object. The former is to be used when a * stoichiometry is simply a scalar number, while the latter is for * occasions when it needs to be a rational number or it needs to * reference other mathematical expressions. The \'stoichiometry\' * attribute is of type double and should contain values greater than * zero (0). The \'stoichiometryMath\' element is implemented as an * element containing a MathML expression. These two are mutually * exclusive; only one of \'stoichiometry\' or \'stoichiometryMath\' should * be defined in a given {@link SpeciesReference} instance. When neither the * attribute nor the element is present, the value of \'stoichiometry\' in * the {@link SpeciesReference} instance defaults to 1. For maximum * interoperability between different software tools, the \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or * decimal). *

*/ public"; %javamethodmodifiers SpeciesReference::createStoichiometryMath " /** * Creates a new, empty {@link StoichiometryMath}, adds it to this {@link SpeciesReference} * and returns the {@link StoichiometryMath}. *

* @return the newly created {@link StoichiometryMath} object instance *

* @see Reaction#addReactant(SpeciesReference sr) * @see Reaction#addProduct(SpeciesReference sr) */ public"; %javamethodmodifiers SpeciesReference::setAnnotation(const XMLNode* annotation) " /** * Sets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation. *

* @param annotation an XML structure that is to be used as the content * of the \'annotation\' subelement of this object *

* @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) */ public"; %javamethodmodifiers SpeciesReference::setAnnotation(const std::string& annotation) " /** * Sets the value of the \'annotation\' subelement of this SBML object to a * copy of annotation. *

* @param annotation an XML string that is to be used as the content * of the \'annotation\' subelement of this object *

* @see #appendAnnotation(XMLNode annotation) * @see #appendAnnotation(String annotation) */ public"; %javamethodmodifiers SpeciesReference::appendAnnotation(const XMLNode* annotation) " /** * Appends annotation content to any existing content in the \'annotation\' * subelement of this object. *

* The content in annotation is copied. Unlike setAnnotation(), this * method allows other annotations to be preserved when an application * adds its own data. *

* @param annotation an XML structure that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #setAnnotation(String annotation) * @see #setAnnotation(XMLNode annotation) */ public"; %javamethodmodifiers SpeciesReference::appendAnnotation(const std::string& annotation) " /** * Appends annotation content to any existing content in the \'annotation\' * subelement of this object. *

* The content in annotation is copied. Unlike setAnnotation(), this * method allows other annotations to be preserved when an application * adds its own data. *

* @param annotation an XML string that is to be copied and appended * to the content of the \'annotation\' subelement of this object *

* @see #setAnnotation(String annotation) * @see #setAnnotation(XMLNode annotation) */ public"; %javamethodmodifiers SpeciesReference::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers SpeciesReference::getElementName() const " /** * Returns the XML element name of this object, which for * {@link SpeciesReference}, is always \'speciesReference\'. *

* @return the name of this element, i.e., \'speciesReference\'. */ public"; %javamethodmodifiers SpeciesReference::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::sortMath " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::syncAnnotation " /** *

* Synchronizes the annotation of this SBML object. *

* Annotation element (XMLNode mAnnotation) is synchronized with the * current {@link CVTerm} objects (List mCVTerm) and id string (std.string mId) * Currently, this method is called in getAnnotation, isSetAnnotation, * and writeElements methods.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::syncAnnotation " /** *

* Synchronizes the annotation of this SBML object. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::syncAnnotation " /** *

* Synchronizes the annotation of this SBML object. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers SpeciesReference::syncAnnotation " /** *

* Synchronizes the annotation of this SBML object. *

* @deprecated libSBML internal */ public"; %javamethodmodifiers ModifierSpeciesReference::ModifierSpeciesReference(const std::string& species = "") " /** * Creates a new ModiferSpeciesReference, optionally with its \'species\' * attribute set. *

* @param species the identifier of the species to be referenced *

* @param level a long integer, the SBML Level to assign to this {@link ModifierSpeciesReference} *

* @param version a long integer, the SBML Version to assign to this * {@link ModifierSpeciesReference} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link ModifierSpeciesReference} *

* @note Once a {@link ModifierSpeciesReference} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link ModifierSpeciesReference}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers ModifierSpeciesReference::clone() const " /** * Creates and returns a deep copy of this {@link ModifierSpeciesReference} * instance. *

* @return a (deep) copy of this {@link ModifierSpeciesReference}. */ public"; %javamethodmodifiers ModifierSpeciesReference::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ModifierSpeciesReference::getElementName() const " /** * Returns the XML element name of this object, which for {@link Species}, is * always \'modifierSpeciesReference\'. *

* @return the name of this element, i.e., \'modifierSpeciesReference\'. */ public"; %javamethodmodifiers ModifierSpeciesReference::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ModifierSpeciesReference::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpeciesReferences::ListOfSpeciesReferences " /** * Creates a new, empty {@link ListOfSpeciesReferences}. */ public"; %javamethodmodifiers ListOfSpeciesReferences::clone() const " /** * Creates and returns a deep copy of this {@link ListOfSpeciesReferences} * instance. *

* @return a (deep) copy of this {@link ListOfSpeciesReferences}. */ public"; %javamethodmodifiers ListOfSpeciesReferences::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpeciesReferences::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link SpeciesReference} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfSpeciesReferences::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfSpeciesReferences}, the XML element name is * \'listOfSpeciesReferences\'. *

* @return the name of this element, i.e., \'listOfSpeciesReferences\'. */ public"; %javamethodmodifiers ListOfSpeciesReferences::get(unsigned int n) " /** * Get a {@link SpeciesReference} from the {@link ListOfSpeciesReferences}. *

* @param n the index number of the {@link SpeciesReference} to get. *

* @return the nth {@link SpeciesReference} in this {@link ListOfSpeciesReferences}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesReferences::get " /** * Get a {@link SpeciesReference} from the {@link ListOfSpeciesReferences}. *

* @param n the index number of the {@link SpeciesReference} to get. *

* @return the nth {@link SpeciesReference} in this {@link ListOfSpeciesReferences}. *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesReferences::get(const std::string& sid) " /** * Get a {@link SpeciesReference} from the {@link ListOfSpeciesReferences} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link SpeciesReference} to get. *

* @return {@link SpeciesReference} in this {@link ListOfSpeciesReferences} * with the given id or NULL if no such * {@link SpeciesReference} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpeciesReferences::get(const std::string& sid) const " /** * Get a {@link SpeciesReference} from the {@link ListOfSpeciesReferences} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link SpeciesReference} to get. *

* @return {@link SpeciesReference} in this {@link ListOfSpeciesReferences} * with the given id or NULL if no such * {@link SpeciesReference} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfSpeciesReferences::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfSpeciesReferences} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfSpeciesReferences::remove(const std::string& sid) " /** * Removes item in this {@link ListOfSpeciesReferences} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfSpeciesReferences::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpeciesReferences::setType(SpeciesType type) " /** * Sets type of this {@link ListOfSpeciesReferences}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfSpeciesReferences::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Event " /** * LibSBML implementation of SBML\'s Event construct. *

* An {@link Event} object defines when the event can occur, the variables that are * affected by the event, and how the variables are affected. *

* An {@link Event} definition has several parts: an optional identifier (defined * by the attribute \'id\'), an optional name (defined by the attribute * \'name\'), a required trigger condition (defined by an object of class * {@link Trigger}), and at least one {@link EventAssignment}. In addition, an event can * include an optional delay (defined by an object of class {@link Delay}). *

* The operation of {@link Event} is divided into two phases (even when the event * is not delayed): one when the event is fired, and the other when the * event is executed. {@link Trigger} objects define the conditions for firing * an event, {@link Delay} objects define when the event is actually executed, and * {@link EventAssignment} objects define the effects of executing the event. * Please consult the descriptions of {@link Trigger}, {@link Delay} and {@link EventAssignment} * for more information. *

* The optional {@link Delay} on {@link Event} means there are two times to consider when * computing the results of an event: the time at which the event * fires, and the time at which assignments are executed. * It is also possible to distinguish between the time at which the * {@link EventAssignment}\'s expression is calculated, and the time at which the * assignment is made: the expression could be evaluated at the same time * the assignments are performed, i.e., when the event is * executed, but it could also be defined to be evaluated at the * time the event fired. *

* In SBML Level 2 versions prior to Version 4, the semantics of * {@link Event} time delays were defined such that the expressions in the event\'s * assignments were always evaluated at the time the event was * fired. This definition made it difficult to define an event * whose assignment formulas were meant to be evaluated at the time the * event was executed (i.e., after the time period defined by the * value of the {@link Delay} element). In SBML Level 2 Version 4, the * attribute \'useValuesFromTriggerTime\' on {@link Event} allows a model to indicate * the time at which the event\'s assignments are intended to be evaluated. * The default value is true, which corresponds to the interpretation of * event assignments prior to Version 4: the values of the assignment * formulas are computed at the moment the event fired, not after the * delay. If \'useValuesFromTriggerTime\'=false, it means that the * formulas in the event\'s assignments are to be computed after the delay, * at the time the event is executed. *

SBML version differences

* Definitions of {@link Event} in SBML Level 2 Versions 1 and 2 included an * additional attribute called \'timeUnits\', which allowed the time units of * the {@link Delay} to be set explicitly. Versions 3 and 4 do not * define this attribute. The LibSBML supports this attribute for * compatibility with previous versions of SBML Level 2; however, if a * Version 3 or 4 model sets the attribute, the * consistency-checking method SBMLDocument.checkConsistency() will report * an error. *

* The attribute \'useValuesFromTriggerTime\' was introduced in SBML * Level 2 Version 4. Models defined in prior Versions of SBML * Level 2 cannot use this attribute, and * SBMLDocument.checkConsistency() will report an error if they do. *

*/ " %typemap(javaimports) ListOfEvents " /** * LibSBML implementation of SBML\'s ListOfEvents construct. *

* The relationship between the lists and the rest of an SBML model is * illustrated by the following (for SBML Level 2 Version 4): *

* *

* @see ListOfFunctionDefinitions * @see ListOfUnitDefinitions * @see ListOfCompartmentTypes * @see ListOfSpeciesTypes * @see ListOfCompartments * @see ListOfSpecies * @see ListOfParameters * @see ListOfInitialAssignments * @see ListOfRules * @see ListOfConstraints * @see ListOfReactions * @see ListOfEvents */ " %javamethodmodifiers Event::Event( const std::string& id = "", const std::string& name = "") " /** * Creates a new {@link Event}, optionally with specific values of id and * name attributes. *

* @param id a string, the identifier to assign to this {@link Event} * @param name a string, the name to be assigned to this {@link Event} *

* @param level a long integer, the SBML Level to assign to this {@link Event} *

* @param version a long integer, the SBML Version to assign to this * {@link Event} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Event} *

* @note Once a {@link Event} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Event}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link Event} in the list * of events within which this {@link Event} is embedded. */ public"; %javamethodmodifiers Event::clone() const " /** * Creates and returns a deep copy of this {@link Event}. *

* @return a (deep) copy of this {@link Event}. */ public"; %javamethodmodifiers Event::getTrigger() const " /** * Get the event trigger portion of this {@link Event}. *

* @return the {@link Trigger} object of this {@link Event}. */ public"; %javamethodmodifiers Event::getTrigger " /** * Get the event trigger portion of this {@link Event}. *

* @return the {@link Trigger} object of this {@link Event}. */ public"; %javamethodmodifiers Event::getDelay() const " /** * Get the assignment delay portion of this {@link Event}, if there is one. *

* @return the delay of this {@link Event} if one is defined, or NULL if none * is defined. */ public"; %javamethodmodifiers Event::getDelay " /** * Get the assignment delay portion of this {@link Event}, if there is one. *

* @return the delay of this {@link Event} if one is defined, or NULL if none * is defined. */ public"; %javamethodmodifiers Event::getTimeUnits() const " /** * Get the value of the \'timeUnits\' attribute of this {@link Event}, if it has one. *

* @return the value of the attribute \'timeUnits\' as a string. *

* @warning Definitions of {@link Event} in SBML Level 2 Versions 1 * and 2 included the additional attribute called \'timeUnits\', but * it was removed in SBML Level 2 Version 3. LibSBML supports * this attribute for compatibility with previous versions of SBML * Level 2, but its use is discouraged since models in Level 2 * Versions 3 and 4 cannot contain it. If a Version 3 * or 4 model sets the attribute, the consistency-checking method * SBMLDocument.checkConsistency() will report an error. */ public"; %javamethodmodifiers Event::getUseValuesFromTriggerTime() const " /** * Get the value of the \'useValuesFromTriggerTime\' attribute of this {@link Event}. *

* @return the value of the attribute \'useValuesFromTriggerTime\' as a boolean. *

* @warning The attribute \'useValuesFromTriggerTime\' was introduced in * SBML Level 2 Version 4. It is not valid in models defined * using SBML Level 2 versions prior to Version 4. If a * Version 1– 3 model sets the attribute, the * consistency-checking method SBMLDocument.checkConsistency() will * report an error. */ public"; %javamethodmodifiers Event::isSetTrigger() const " /** * Predicate for testing whether the trigger for this {@link Event} has been set. *

* @return true if the trigger of this {@link Event} has been set, false * otherwise. */ public"; %javamethodmodifiers Event::isSetDelay() const " /** * Predicate for testing whether the delay for this {@link Event} has been set. *

* @return true if the delay of this {@link Event} has been set, false * otherwise. */ public"; %javamethodmodifiers Event::isSetTimeUnits() const " /** * Predicate for testing whether the \'timeUnits\' attribute of this {@link Event} * has been set. *

* @return true if the \'timeUnits\' attribute of this {@link Event} has been * set, false otherwise. *

* @warning Definitions of {@link Event} in SBML Level 2 Versions 1 * and 2 included the additional attribute called \'timeUnits\', but * it was removed in SBML Level 2 Version 3. LibSBML supports * this attribute for compatibility with previous versions of SBML * Level 2, but its use is discouraged since models in Level 2 * Versions 3 and 4 cannot contain it. If a Version 3 * or 4 model sets the attribute, the consistency-checking method * SBMLDocument.checkConsistency() will report an error. */ public"; %javamethodmodifiers Event::setTrigger(const Trigger* trigger) " /** * Sets the trigger definition of this {@link Event} to a copy of the given * {@link Trigger} object instance. *

* @param trigger the {@link Trigger} object instance to use. */ public"; %javamethodmodifiers Event::setDelay(const Delay* delay) " /** * Sets the delay definition of this {@link Event} to a copy of the given {@link Delay} * object instance. *

* @param delay the {@link Delay} object instance to use */ public"; %javamethodmodifiers Event::setTimeUnits(const std::string& sid) " /** * Sets the \'timeUnits\' attribute of this {@link Event} to a copy of sid. *

* @param sid the identifier of the time units to use. *

* @warning Definitions of {@link Event} in SBML Level 2 Versions 1 * and 2 included the additional attribute called \'timeUnits\', but * it was removed in SBML Level 2 Version 3. LibSBML supports * this attribute for compatibility with previous versions of SBML * Level 2, but its use is discouraged since models in Level 2 * Versions 3 and 4 cannot contain it. If a Version 3 * or 4 model sets the attribute, the consistency-checking method * SBMLDocument.checkConsistency() will report an error. */ public"; %javamethodmodifiers Event::setUseValuesFromTriggerTime(bool value) " /** * Sets the \'useValuesFromTriggerTime\' attribute of this {@link Event} to a value. *

* @param value the value of useValuesFromTriggerTime to use. *

* @warning The attribute \'useValuesFromTriggerTime\' was introduced in * SBML Level 2 Version 4. It is not valid in models defined * using SBML Level 2 versions prior to Version 4. If a * Version 1– 3 model sets the attribute, the * consistency-checking method SBMLDocument.checkConsistency() will * report an error. */ public"; %javamethodmodifiers Event::unsetDelay " /** * Unsets the {@link Delay} of this {@link Event}. *

* @warning Definitions of {@link Event} in SBML Level 2 Versions 1 and 2 * included the attribute called \'timeUnits\', but it was removed in SBML * Level 2 Version 3. LibSBML supports this attribute for * compatibility with previous versions of SBML Level 2, but its use * is discouraged since models in Level 2 Version 3 and * Version 4 cannot contain it. If a Version 3 or 4 model * sets this attribute, the consistency-checking method * SBMLDocument.checkConsistency() will report an error. */ public"; %javamethodmodifiers Event::addEventAssignment(const EventAssignment* ea) " /** * Appends a copy of the given {@link EventAssignment} to this {@link Event}. *

* @param ea the {@link EventAssignment} object to add. *

* @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 in this {@link Event}. Changes made to the original object * instance (such as resetting attribute values) will not affect the * instance in the {@link Event}. 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 Event.createEventAssignment() * for a method that does not lead to these issues. *

* @see #createEventAssignment() */ public"; %javamethodmodifiers Event::createEventAssignment " /** * Creates a new, empty {@link EventAssignment}, adds it to this {@link Event}\'s list of * event assignments and returns the {@link EventAssignment}. *

* @return the newly created {@link EventAssignment} object instance *

* @see #addEventAssignment(EventAssignment ea) */ public"; %javamethodmodifiers Event::createTrigger " /** * Creates a new, empty {@link Trigger}, adds it to this {@link Event} and * returns the {@link Trigger}. *

* @return the newly created {@link Trigger} object instance */ public"; %javamethodmodifiers Event::createDelay " /** * Creates a new, empty {@link Delay}, adds it to this {@link Event} and * returns the {@link Delay}. *

* @return the newly created {@link Delay} object instance */ public"; %javamethodmodifiers Event::getListOfEventAssignments() const " /** * Returns the list of event assignments for this {@link Event}. *

* @return the list of EventAssignments for this {@link Event}. */ public"; %javamethodmodifiers Event::getListOfEventAssignments " /** * Returns the list of event assignments for this {@link Event}. *

* @return the list of EventAssignments for this {@link Event}. */ public"; %javamethodmodifiers Event::getEventAssignment " /** * Return a specific {@link EventAssignment} object of this {@link Event}. *

* @param n an integer, the index of the {@link EventAssignment} object to return *

* @return the nth {@link EventAssignment} of this {@link Event}. */ public"; %javamethodmodifiers Event::getEventAssignment(unsigned int n) " /** * Return a specific {@link EventAssignment} object of this {@link Event}. *

* @param n an integer, the index of the {@link EventAssignment} object to return *

* @return the nth {@link EventAssignment} of this {@link Event}. */ public"; %javamethodmodifiers Event::getEventAssignment(const std::string& variable) const " /** * Return the event assignment indicated by the given variable. *

* @param variable a string, the identifier of the variable whose * {@link EventAssignment} is being sought. *

* @return the {@link EventAssignment} for the given variable, or NULL if * no such {@link EventAssignment} exits. */ public"; %javamethodmodifiers Event::getEventAssignment(const std::string& variable) " /** * Return the event assignment indicated by the given variable. *

* @param variable a string, the identifier of the variable whose * {@link EventAssignment} is being sought. *

* @return the {@link EventAssignment} for the given variable, or NULL if * no such {@link EventAssignment} exits. */ public"; %javamethodmodifiers Event::getNumEventAssignments() const " /** * Returns the number of {@link EventAssignment} objects attached to this * {@link Event}. *

* @return the number of EventAssignments in this {@link Event}. */ public"; %javamethodmodifiers Event::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::getTypeCode() const " /** * Returns the libSBML type code of this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Event::getElementName() const " /** * Returns the XML element name of this object, which for {@link Event}, is * always \'event\'. *

* @return the name of this element, i.e., \'event\'. */ public"; %javamethodmodifiers Event::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::setInternalIdOnly " /** * sets the mInternalIdOnly flag

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Event::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfEvents::clone() const " /** * Creates and returns a deep copy of this {@link ListOfEvents}. *

* @return a (deep) copy of this {@link ListOfEvents}. */ public"; %javamethodmodifiers ListOfEvents::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfEvents::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link Event} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfEvents::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfEvents}, the XML element name is \'listOfEvents\'. *

* @return the name of this element, i.e., \'listOfEvents\'. */ public"; %javamethodmodifiers ListOfEvents::get(unsigned int n) " /** * Get a {@link Event} from the {@link ListOfEvents}. *

* @param n the index number of the {@link Event} to get. *

* @return the nth {@link Event} in this {@link ListOfEvents}. *

* @see #size() */ public"; %javamethodmodifiers ListOfEvents::get " /** * Get a {@link Event} from the {@link ListOfEvents}. *

* @param n the index number of the {@link Event} to get. *

* @return the nth {@link Event} in this {@link ListOfEvents}. *

* @see #size() */ public"; %javamethodmodifiers ListOfEvents::get(const std::string& sid) " /** * Get a {@link Event} from the {@link ListOfEvents} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Event} to get. *

* @return {@link Event} in this {@link ListOfEvents} * with the given id or NULL if no such * {@link Event} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfEvents::get(const std::string& sid) const " /** * Get a {@link Event} from the {@link ListOfEvents} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link Event} to get. *

* @return {@link Event} in this {@link ListOfEvents} * with the given id or NULL if no such * {@link Event} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfEvents::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfEvents} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfEvents::remove(const std::string& sid) " /** * Removes item in this {@link ListOfEvents} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfEvents::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* The ordering of elements in the XML form of SBML is generally fixed * for most components in SBML. So, for example, the {@link ListOfEvents} in a * model is (in SBML Level 2 Version 4) the twelfth ListOf___. * (However, it differs for different Levels and Versions of SBML, so * calling code should not hardwire this number.) *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfEvents::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) EventAssignment " /** * LibSBML implementation of SBML\'s EventAssignment construct for Event *

* An {@link Event} object defines when the event can occur, the variables that are * affected by the event, and how the variables are affected. The purpose * of the {@link EventAssignment} object class is to define how variables are * affected by an {@link Event}. In every instance of an {@link Event} definition in a * model, the object\'s {@link ListOfEventAssignments} must have a non-empty list of * one or more elements of class {@link EventAssignment}. *

* The operation of an {@link Event} is divided into two phases (regardless of * whether a delay is involved): one phase when the event is fired, and * the other when the event is executed. {@link EventAssignment} objects are * interpreted when an event is executed. The effects are described below. *

* {@link EventAssignment} is derived from {@link SBase} and adds one attribute * (\'variable\') and one subelement (\'math\', containing MathML content). * The attribute \'variable\' is required to have a value. Its type is the * SBML type SId and can contain the identifier of an existing * {@link Compartment}, {@link Species} or (global) {@link Parameter} instance defined in the * model. *

Effects of event assignments

* An SBML event assignment has effect when the event is executed; that * is, at the end of any given delay period (if defined) following the * moment that the {@link Event} is triggered. When the event fires, the effect is * to change the value of the model component identified by the \'variable\' * attribute. *

* Certain restrictions are placed on what can appear in \'variable\': *

The object identified by the value of the {@link EventAssignment} attribute * \'variable\' must not have its \'constant\' attribute set to or default to * true. (Constants cannot be affected by events.) *
*
The \'variable\' attribute must not contain the identifier of a * reaction; only species, compartment and parameter values may be set by * an {@link Event}. *
*
The value of every \'variable\' attribute must be unique among the set * of {@link EventAssignment} structures within a given {@link Event} structure. In other * words, a single event cannot have multiple {@link EventAssignment} objects * assigning the same variable. (All of them would be performed at the * same time when that particular {@link Event} triggers, resulting in * indeterminacy.) However, separate {@link Event} instances can refer to the * same variable. *
*
A variable cannot be assigned a value in an {@link EventAssignment} object * instance and also be assigned a value by an {@link AssignmentRule}; i.e., the * value of an {@link EventAssignment}\'s \'variable\' attribute cannot be the same as * the value of a {@link AssignmentRule}\' \'variable\' attribute. (Assignment rules * hold at all times, therefore it would be inconsistent to also define an * event that reassigns the value of the same variable.) *

* Note that the time of assignment of the object identified by the * value of the \'variable\' attribute is always the time at which the {@link Event} * is executed, not when it is fired. The timing is * controlled by the optional {@link Delay} in an {@link Event}. The time of * assignment is not affected by the \'useValuesFromTriggerTime\' * attribute on {@link Event} mdash;that attribute affects the time at which the * {@link EventAssignment}\'s \'math\' expression is evaluated. In other * words, SBML allows decoupling the time at which the * \'variable\' is assigned from the time at which its value * expression is calculated. *

The \'math\' subelement in an {@link EventAssignment}

* The MathML expression contained in an {@link EventAssignment} defines the new * value of the variable being assigned by the {@link Event}. The order of the * {@link EventAssignment} structures is not significant; the effect of one * assignment cannot affect the result of another assignment. *

* The time at which this expression is evaluated is determined by {@link Event}\'s * \'useValuesFromTriggerTime\' attribute. If the attribute value is true * (the default), the expression must be evaluated when the event is * fired; more precisely, the values of identifiers occurring in * MathML ci attributes in the {@link EventAssignment}\'s \'math\' expression are * the values they have at the point when the event fired. If, * instead, \'useValuesFromTriggerTime\'\'s value is false, it means the * values at execution time should be used; that is, the values of * identifiers occurring in MathML ci attributes in the * {@link EventAssignment}\'s \'math\' expression are the values they have at the * point when the event executed. *

* Between Version 4 and previous versions of SBML Level 2, the * requirements regarding the matching of units between an * EvengAssignment\'s formula and the units of the object identified by the * \'variable\' attribute changed. Previous versions required consistency, * but in Version 4, unit consistency is only recommended. More * precisely:

In the case of a species, an {@link EventAssignment} sets * the referenced species\' quantity (concentration or amount of substance) * to the value determined by the formula in the {@link EventAssignment}\'s \'math\' * subelement. The units of the \'math\' formula should (in SBML * Level 2 Version 4) or must (in previous Versions) be identical * to the units of the species. *
*
In the case of a compartment, an {@link EventAssignment} sets the * referenced compartment\'s size to the size determined by the formula in * the \'math\' subelement of the {@link EventAssignment}. The overall units of the * formula should (in SBML Level 2 Version 4) or must (in * previous Versions) be identical to the units specified for the size of * the compartment identified by the {@link EventAssignment}\'s \'variable\' * attribute. *
*
In the case of a parameter, an {@link EventAssignment} sets the referenced * parameter\'s value to that determined by the formula in \'math\'. The * overall units of the formula should (in SBML Level 2 * Version 4) or must (in previous Versions) be identical to the units * defined for the parameter. *

* Note that the formula placed in the \'math\' element has no assumed * units. The consistency of the units of the formula, and the units * of the entity which the assignment affects, must be explicitly * established just as in the case of the value of the {@link Delay} subelement. * An approach similar to the one discussed in the context of {@link Delay} may be * used for the formula of an {@link EventAssignment}. *

Semantics of {@link Event} and {@link EventAssignment}

* Readers are urged to consult the SBML specification for important * information about the interpretation of {@link Event} and {@link EventAssignment}. *

*/ " %typemap(javaimports) ListOfEventAssignments " /** * LibSBML implementation of SBML\'s ListOfEventAssignments construct. *

* {@link ListOfEventAssignments} is entirely contained within {@link Event}. */ " %javamethodmodifiers EventAssignment::EventAssignment(const std::string& variable = "", const ASTNode* math = NULL) " /** * Creates a new {@link EventAssignment}, optionally with its \'variable\' * attribute and math subelement set. *

* @param variable the identifier of a {@link Species}, {@link Compartment} or {@link Parameter} * object. *

* @param math the top {@link ASTNode} of an abstract syntax tree defining the * mathematical formula used as the expression for the event assignment\'s * effect. *

* @note Although the value of the \'variable\' attribute is optional in * this constructor, it is worth emphasizing that valid {@link EventAssignment} * definitions must have a value for this attribute. If no variable is * provided at the time of creation, the value is left as the empty * string. Callers are cautioned to set the value * using {@link EventAssignment#setVariable(String sid)} * soon after invoking this constructor. *

* @param level a long integer, the SBML Level to assign to this {@link EventAssignment} *

* @param version a long integer, the SBML Version to assign to this * {@link EventAssignment} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link EventAssignment} *

* @note Once a {@link EventAssignment} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link EventAssignment}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(), which indicates * whether the Visitor would like to visit the next {@link EventAssignment} in * the list within which this {@link EventAssignment} is embedded (i.e., in the * {@link ListOfEventAssignments} located in the enclosing {@link Event} instance). */ public"; %javamethodmodifiers EventAssignment::clone() const " /** * Creates and returns a deep copy of this {@link EventAssignment}. *

* @return a (deep) copy of this {@link EventAssignment}. */ public"; %javamethodmodifiers EventAssignment::getVariable() const " /** * Get the value of this {@link EventAssignment}\'s \'variable\' attribute. *

* @return the identifier stored in the \'variable\' attribute of this * {@link EventAssignment}. */ public"; %javamethodmodifiers EventAssignment::getMath() const " /** * Get the mathematical expression in this {@link EventAssignment}\'s \'math\' * subelement. *

* @return the top {@link ASTNode} of an abstract syntax tree representing the * mathematical formula in this {@link EventAssignment}. */ public"; %javamethodmodifiers EventAssignment::isSetVariable() const " /** * Predicate for testing whether the attribute \'variable\' of this * {@link EventAssignment} has been set. *

* @return true if the \'variable\' attribute of this {@link EventAssignment} * has been set, false otherwise. */ public"; %javamethodmodifiers EventAssignment::isSetMath() const " /** * Predicate for testing whether the \'math\' subelement of this * {@link EventAssignment} has been set. *

* @return true if this {@link EventAssignment} has a \'math\' subelement, * false otherwise. */ public"; %javamethodmodifiers EventAssignment::setVariable(const std::string& sid) " /** * Sets the attribute \'variable\' of this {@link EventAssignment} to a copy of * the given identifier string. *

* @param sid the identifier of a {@link Compartment}, {@link Species} or (global) * {@link Parameter} defined in this model. */ public"; %javamethodmodifiers EventAssignment::setMath(const ASTNode* math) " /** * Sets the \'math\' subelement of this {@link EventAssignment} to a copy of the * given {@link ASTNode}. *

* @param math an {@link ASTNode} that will be copied and stored as the * mathematical formula for this {@link EventAssignment}. */ public"; %javamethodmodifiers EventAssignment::getDerivedUnitDefinition " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link EventAssignment}. *

* The units are calculated based on the mathematical expression in the * {@link EventAssignment} and the model quantities referenced by * <ci> elements used within that expression. The * EventAssignment.getDerivedUnitDefinition() method returns the * calculated units. *

* @warning Note that it is possible the \'math\' expression in the * {@link EventAssignment} contains literal numbers or parameters with undeclared * units. In those cases, it is not possible to calculate the units of * the overall expression without making assumptions. LibSBML does not * make assumptions about the units, and * EventAssignment.getDerivedUnitDefinition() only returns the units as * far as it is able to determine them. For example, in an expression * X + Y, if X has unambiguously-defined units and * Y does not, it will return the units of X. When * using this method, it is critical that callers also invoke the * method EventAssignment.containsUndeclaredUnits() to * determine whether this situation holds. Callers should take * suitable action in those situations. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link EventAssignment}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers EventAssignment::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this * {@link EventAssignment}. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link EventAssignment}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers EventAssignment::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether the math * expression of this {@link EventAssignment} contains literal numbers or * parameters with undeclared units. *

* The EventAssignment.getDerivedUnitDefinition() method returns what * libSBML computes to be the units of the \'math\', to the extent that * libSBML can compute them. However, if the expression contains literal * numbers or parameters with undeclared units, libSBML may not be able * to compute the full units of the expression and will only return what * it can compute. Callers should always use * EventAssignment.containsUndeclaredUnits() when using * EventAssignment.getDerivedUnitDefinition() to decide whether the * returned units may be incomplete. *

* @return true if the math expression of this {@link EventAssignment} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by EventAssignment.getDerivedUnitDefinition() may not * accurately represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers EventAssignment::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether the math * expression of this {@link EventAssignment} contains literal numbers or * parameters with undeclared units. *

* @return true if the math expression of this {@link EventAssignment} * includes parameters/numbers * with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by EventAssignment.getDerivedUnitDefinition() may not * accurately represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers EventAssignment::getTypeCode() const " /** * Returns the libSBML type code of this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers EventAssignment::getElementName() const " /** * Returns the XML element name of this object, which for * {@link EventAssignment}, is always \'eventAssignment\'. *

* @return the name of this element, i.e., \'eventAssignment\'. */ public"; %javamethodmodifiers EventAssignment::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers EventAssignment::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers EventAssignment::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers EventAssignment::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfEventAssignments::clone() const " /** * Creates and returns a deep copy of this {@link ListOfEventAssignments}. *

* @return a (deep) copy of this {@link ListOfEventAssignments}. */ public"; %javamethodmodifiers ListOfEventAssignments::getTypeCode() const " /** * Returns the libSBML type code for this SBML object. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfEventAssignments::getItemTypeCode() const " /** * Returns the libSBML type code for the objects contained in this {@link ListOf} * (i.e., {@link EventAssignment} objects, if the list is non-empty). *

* @return the SBML type code for the objects contained in this {@link ListOf} * instance, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers ListOfEventAssignments::getElementName() const " /** * Returns the XML element name of this object. *

* For {@link ListOfEventAssignments}, the XML element name is * \'listOfEventAssignments\'. *

* @return the name of this element, i.e., \'listOfEventAssignments\'. */ public"; %javamethodmodifiers ListOfEventAssignments::get(unsigned int n) " /** * Get a {@link EventAssignment} from the {@link ListOfEventAssignments}. *

* @param n the index number of the {@link EventAssignment} to get. *

* @return the nth {@link EventAssignment} in this {@link ListOfEventAssignments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfEventAssignments::get " /** * Get a {@link EventAssignment} from the {@link ListOfEventAssignments}. *

* @param n the index number of the {@link EventAssignment} to get. *

* @return the nth {@link EventAssignment} in this {@link ListOfEventAssignments}. *

* @see #size() */ public"; %javamethodmodifiers ListOfEventAssignments::get(const std::string& sid) " /** * Get a {@link EventAssignment} from the {@link ListOfEventAssignments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link EventAssignment} to get. *

* @return {@link EventAssignment} in this {@link ListOfEventAssignments} * with the given id or NULL if no such * {@link EventAssignment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfEventAssignments::get(const std::string& sid) const " /** * Get a {@link EventAssignment} from the {@link ListOfEventAssignments} * based on its identifier. *

* @param sid a string representing the identifier * of the {@link EventAssignment} to get. *

* @return {@link EventAssignment} in this {@link ListOfEventAssignments} * with the given id or NULL if no such * {@link EventAssignment} exists. *

* @see #get(long n) * @see #size() */ public"; %javamethodmodifiers ListOfEventAssignments::remove(unsigned int n) " /** * Removes the nth item from this {@link ListOfEventAssignments} items and returns a pointer to * it. *

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

* @param n the index of the item to remove *

* @see #size() */ public"; %javamethodmodifiers ListOfEventAssignments::remove(const std::string& sid) " /** * Removes item in this {@link ListOfEventAssignments} items with the given identifier. *

* The caller owns the returned item and is responsible for deleting it. * If none of the items in this list have the identifier sid, then * NULL is returned. *

* @param sid the identifier of the item to remove *

* @return the item removed. As mentioned above, the caller owns the * returned item. */ public"; %javamethodmodifiers ListOfEventAssignments::getElementPosition() const " /** * Get the ordinal position of this element in the containing object * (which in this case is the {@link Model} object). *

* @return the ordinal position of the element with respect to its * siblings, or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ListOfEventAssignments::createObject(XMLInputStream& stream) " /** * @return the SBML object corresponding to next {@link XMLToken} in the * XMLInputStream or NULL if the token was not recognized.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Trigger " /** * LibSBML implementation of SBML\'s Trigger construct for Event. *

* An {@link Event} object defines when the event can occur, the variables that * are affected by the event, and how the variables are affected. The * {@link Trigger} construct in SBML is used to define a mathematical expression * that determines when an {@link Event} fires. *

* A {@link Trigger} contains one subelement named \'math\' containing a MathML * expression. The expression must evaluate to a value of type boolean. * The exact moment at which the expression evaluates to true is the * time point when the {@link Event} is fired. *

* An event only fires when its {@link Trigger} expression makes the transition in * value from false to true. The event will also fire at any future * time points when the trigger expression makes this transition; in other * words, an event can fire multiple times during a simulation if its * trigger condition makes the transition from false to true more * than once. *

* An important question is whether an event can fire prior to, or at, * initial simulation time, that is t < 0. The answer is no: * an event can only be triggered immediately after initial simulation time * i.e., t > 0. *

* @see Event * @see Delay * @see EventAssignment */ " %javamethodmodifiers Trigger::Trigger(const ASTNode* math = NULL) " /** * Creates a new {@link Trigger}, optionally with the given math. *

* @param math an {@link ASTNode} representing the mathematical formula for * the trigger expression. *

* @param level a long integer, the SBML Level to assign to this {@link Trigger} *

* @param version a long integer, the SBML Version to assign to this * {@link Trigger} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Trigger} *

* @note Once a {@link Trigger} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Trigger}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Trigger::clone() const " /** * Creates and returns a deep copy of this {@link Trigger}. *

* @return a (deep) copy of this {@link Trigger}. */ public"; %javamethodmodifiers Trigger::getMath() const " /** * Get the mathematical formula for the trigger and return it * as an AST. *

* @return the math of this {@link Trigger}. */ public"; %javamethodmodifiers Trigger::isSetMath() const " /** * Predicate to test whether the math for this trigger has been set. *

* @return true if the formula (meaning the \'math\' subelement) of * this {@link Trigger} has been set, false otherwise. */ public"; %javamethodmodifiers Trigger::setMath(const ASTNode* math) " /** * Sets the trigger expression of this {@link Trigger} instance to a copy of the given * {@link ASTNode}. *

* @param math an {@link ASTNode} representing a formula tree. */ public"; %javamethodmodifiers Trigger::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::getTypeCode() const " /** * Returns the libSBML type code of this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Trigger::getElementName() const " /** * Returns the XML element name of this object, which for {@link Trigger}, is * always \'trigger\'. *

* @return the name of this element, i.e., \'trigger\'. */ public"; %javamethodmodifiers Trigger::getElementPosition() const " /** * Returns the position of this element. *

* @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Trigger::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %typemap(javaimports) Delay " /** * LibSBML implementation of SBML\'s Delay construct for Event. *

* An {@link Event} object defines when the event can occur, the variables that * are affected by the event, and how the variables are affected. The * effect of the event can optionally be delayed after the occurrence of * the condition which invokes it. An event delay is defined using an * object of class {@link Delay}. *

* The object class {@link Delay} is derived from {@link SBase} and adds a single * subelement called \'math\'. This subelement is used to hold MathML * content. The mathematical formula represented by \'math\' must evaluate * to a numerical value. It is used as the length of time between when the * event has fired and when the event\'s assignments are actually * executed. If no delay is present on a given {@link Event}, a time delay of zero * is assumed. *

* The expression in \'math\' must be evaluated at the time the rule is * fired. The expression must always evaluate to a positive number * (otherwise, a nonsensical situation could arise where an event is * defined to fire before it is triggered!). *

The units of the mathematical expression in a {@link Delay}

* In SBML Level 2 versions before Version 4, the units of the * numerical value computed by the {@link Delay}\'s \'math\' expression were * required to be in units of time or the model is considered to have a * unit consistency error. In Version 4, this requirement is relaxed. * The Version 4 specification only stipulates that the units of the * numerical value computed by a {@link Delay} instance\'s \'math\' expression * should match the model\'s units of time (meaning the definition of the * time units in the model). Depending on which Version of SBML * Level 2 is in use, libSBML may or may not flag unit inconsistencies * as errors or just warnings. *

* Note that units are not predefined or assumed for the contents * of \'math\' in a {@link Delay} object; rather, they must be defined explicitly for * each instance of a {@link Delay} object in a model. This is an important point * to bear in mind when literal numbers are used in delay expressions. For * example, the following {@link Event} instance would result in a warning logged * by SBMLDocument.checkConsistency() about the fact that libSBML cannot * verify the consistency of the units of the expression. The reason is * that the formula inside the \'math\' element does not have any declared * units, whereas what is expected in this context is units of time: *

 * <model>
 *     ...
 *     <listOfEvents>
 *         <event>
 *             ...
 *             <delay>
 *                 <math xmlns=\'http://www.w3.org/1998/Math/MathML\'>
 *                     <cn> 1 </cn>
 *                 </math>
 *             </delay>
 *             ...
 *         </event>
 *     </listOfEvents>
 *     ...
 * </model>

* The <cn> 1 </cn> within the mathematical formula * of the delay above has no units declared. To make the * expression have the needed units of time, literal numbers should be * avoided in favor of defining {@link Parameter} objects for each quantity, and * declaring units for the {@link Parameter} values. The following fragment of * SBML illustrates this approach: *

 * <model>
 *     ...
 *     <listOfParameters>
 *         <parameter id=\'transcriptionDelay\' value=\'10\' units=\'time\'/>
 *     </listOfParameters>
 *     ...
 *     <listOfEvents>
 *         <event>
 *             ...
 *             <delay>
 *                 <math xmlns=\'http://www.w3.org/1998/Math/MathML\'>
 *                     <ci> transcriptionDelay </ci>
 *                 </math>
 *             </delay>
 *             ...
 *         </event>
 *     </listOfEvents>
 *     ...
 * </model>

*/ " %javamethodmodifiers Delay::Delay(const ASTNode* math = NULL) " /** * Creates a new {@link Delay}, optionally with the given math. *

* @param math an {@link ASTNode} representing the mathematical formula for * the delay expression. *

* @param level a long integer, the SBML Level to assign to this {@link Delay} *

* @param version a long integer, the SBML Version to assign to this * {@link Delay} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link Delay} *

* @note Once a {@link Delay} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link Delay}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers Delay::clone() const " /** * Creates and returns a deep copy of this {@link Delay}. *

* @return a (deep) copy of this {@link Delay}. */ public"; %javamethodmodifiers Delay::getMath() const " /** * Get the mathematical formula for the delay and return it * as an AST. *

* @return the math of this {@link Delay}. */ public"; %javamethodmodifiers Delay::isSetMath() const " /** * Predicate to test whether the formula for this delay has been set. *

* @return true if the formula (meaning the math subelement) of * this {@link Delay} has been set, false otherwise. */ public"; %javamethodmodifiers Delay::setMath(const ASTNode* math) " /** * Sets the delay expression of this {@link Delay} instance to a copy of the given * {@link ASTNode}. *

* @param math an {@link ASTNode} representing a formula tree. */ public"; %javamethodmodifiers Delay::getDerivedUnitDefinition " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this {@link Delay}. *

* (Prior to SBML Level 2 Version 2, there existed an attribute * on {@link Event} called \'timeUnits\'. This attribute could be used to set the * intended units of the delay expression. For such models, this will * return a {@link UnitDefinition} object that corresponds to the declared * \'timeUnits\' units.) *

* @warning Note that it is possible the \'math\' expression in the {@link Delay} * contains literal numbers or parameters with undeclared units. In * those cases, it is not possible to calculate the units of the overall * expression without making assumptions. LibSBML does not make * assumptions about the units, and Delay.getDerivedUnitDefinition() * only returns the units as far as it is able to determine them. For * example, in an expression X + Y, if X has * unambiguously-defined units and Y does not, it will return * the units of X. When using this method, it is * critical that callers also invoke the method * Delay.containsUndeclaredUnits() to determine whether this * situation holds. Callers should take suitable action in * those situations. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link Delay}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers Delay::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} that expresses the units * of measurement assumed for the \'math\' expression of this {@link Delay}. *

* @return a {@link UnitDefinition} that expresses the units of the math * expression of this {@link Delay}. *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers Delay::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether * the \'math\' expression in this {@link Delay} instance contains * parameters with undeclared units or literal numbers. *

* {@link Delay} elements in SBML express a time delay for an {@link Event}. Beginning * with SBML Level 2 Version 2, the units of that time are * calculated based on the mathematical expression and the model * quantities referenced by <ci> elements used within * that expression. The Delay.getDerivedUnitDefinition() method returns * what libSBML computes the units to be, to the extent that libSBML can * compute them. However, if the expression contains literal numbers or * parameters with undeclared units, libSBML may not be able to compute * the full units of the expression and will only return what it can * compute. Callers should always use Delay.containsUndeclaredUnits() * when using Delay.getDerivedUnitDefinition() to decide whether the * returned units may be incomplete. *

* @return true if the math expression of this {@link Delay} includes * numbers/parameters with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by Delay.getDerivedUnitDefinition() may not accurately * represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers Delay::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether * the \'math\' expression in this {@link Delay} instance contains * parameters with undeclared units or literal numbers. *

* @return true if the math expression of this {@link Delay} includes * numbers/parameters with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by Delay.getDerivedUnitDefinition() may not accurately * represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers Delay::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::getTypeCode() const " /** * Returns the libSBML type code of this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers Delay::getElementName() const " /** * Returns the XML element name of this object, which for {@link Delay}, is * always \'delay\'. *

* @return the name of this element, i.e., \'delay\'. *

* @see #getTypeCode() */ public"; %javamethodmodifiers Delay::getElementPosition() const " /** * Returns the position of this element. *

* @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers Delay::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %typemap(javaimports) SBO " /** * Methods for interacting with Systems Biology Ontology (%SBO) terms. *

*/ " %javamethodmodifiers SBO::readTerm(const XMLAttributes& attributes, SBMLErrorLog* log) " /** * Reads (and checks) sboTerm from the given {@link XMLAttributes} set. *

* @return the sboTerm as an integer or -1 if the sboTerm was not in the * correct format or not found.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::writeTerm(XMLOutputStream& stream, int sboTerm) " /** * Writes sboTerm as an XMLAttribute to the given XMLOutputStream.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::isQuantitativeParameter(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a QuantitativeParameter, false otherwise */ public"; %javamethodmodifiers SBO::isParticipantRole(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a ParticipantRole, false otherwise */ public"; %javamethodmodifiers SBO::isModellingFramework(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a ModellingFramework, false otherwise */ public"; %javamethodmodifiers SBO::isMathematicalExpression(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a MathematicalExpression, false otherwise */ public"; %javamethodmodifiers SBO::isKineticConstant(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a KineticConstant, false otherwise */ public"; %javamethodmodifiers SBO::isReactant(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Reactant, false otherwise */ public"; %javamethodmodifiers SBO::isProduct(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Product, false otherwise */ public"; %javamethodmodifiers SBO::isModifier(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Modifier, false otherwise */ public"; %javamethodmodifiers SBO::isRateLaw(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a RateLaw, false otherwise */ public"; %javamethodmodifiers SBO::isEvent(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a {@link Event}, false otherwise */ public"; %javamethodmodifiers SBO::isPhysicalParticipant(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a PhysicalParticipant, false otherwise */ public"; %javamethodmodifiers SBO::isParticipant(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Participant, false otherwise */ public"; %javamethodmodifiers SBO::isInteraction(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Interaction, false otherwise */ public"; %javamethodmodifiers SBO::isEntity(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a Entity, false otherwise */ public"; %javamethodmodifiers SBO::isFunctionalEntity(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a FunctionalEntity, false otherwise */ public"; %javamethodmodifiers SBO::isMaterialEntity(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a MaterialEntity, false otherwise */ public"; %javamethodmodifiers SBO::isConservationLaw(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a ConservationLaw, false otherwise */ public"; %javamethodmodifiers SBO::isSteadyStateExpression(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a SteadyStateExpression, false otherwise */ public"; %javamethodmodifiers SBO::isFunctionalCompartment(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a FunctionalCompartment, false otherwise */ public"; %javamethodmodifiers SBO::isContinuousFramework(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a ContinuousFramework, false otherwise */ public"; %javamethodmodifiers SBO::isDiscreteFramework(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a DiscreteFramework, false otherwise */ public"; %javamethodmodifiers SBO::isLogicalFramework(unsigned int term) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. *

* @return true if the term is-a LogicalFramework, false otherwise */ public"; %javamethodmodifiers SBO::isObselete(unsigned int term) " /** * Function for checking whether the {@link SBO} term is obselete. *

* @return true if the term is-a Obsolete, false otherwise */ public"; %javamethodmodifiers SBO::intToString(int sboTerm) " /** * Returns the integer as a correctly formatted {@link SBO} string. *

* @return the given integer sboTerm as a zero-padded seven digit string. *

* @note If the sboTerm is not in the correct range ([0 -- 9999999]), an empty * string is returned. */ public"; %javamethodmodifiers SBO::isChildOf(unsigned int term, unsigned int parent) " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. * * @return true if the term is-a parent, false otherwise

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::populateSBOTree " /** * Function for checking the {@link SBO} term is from correct part of {@link SBO}. * populates the parent-child map

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::checkTerm(const std::string& sboTerm) " /** * @return true if sboTerm is in the correct format (a zero-padded, seven * digit string), false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::checkTerm(int sboTerm) " /** * @return true if sboTerm is in the range [0 -- 9999999], false * otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBO::stringToInt(const std::string& sboTerm) " /** * @return the given string sboTerm as an integer. If the sboTerm is not * in the correct format (a zero-padded, seven digit string), -1 is * returned.

* @deprecated libSBML internal */ public"; %typemap(javaimports) StoichiometryMath " /** * LibSBML implementation of SBML\'s StoichiometryMath construct. *

* In SBML Level 2, product and reactant stoichiometries can be specified * using either the \'stoichiometry\' attribute or a \'stoichiometryMath\' * element in a {@link SpeciesReference} object. The \'stoichiometry\' attribute is * of type double and should contain values greater than zero (0). The * \'stoichiometryMath\' element is implemented as an element containing a * MathML expression. These two are mutually exclusive; only one of * \'stoichiometry\' or \'stoichiometryMath\' should be defined in a given * {@link SpeciesReference} instance. When neither the attribute nor the element * is present, the value of \'stoichiometry\' in the enclosing * {@link SpeciesReference} instance defaults to 1. *

* For maximum interoperability, {@link SpeciesReference}\'s \'stoichiometry\' * attribute should be used in preference to \'stoichiometryMath\' when a * species\' stoichiometry is a simple scalar number (integer or decimal). * When the stoichiometry is a rational number, or when it is a more * complicated formula, \'stoichiometryMath\' must be used. The MathML * expression in \'stoichiometryMath\' may also refer to identifiers of * entities in a model (except reaction identifiers). However, the only * species identifiers that can be used in \'stoichiometryMath\' are those * referenced in the enclosing {@link Reaction}\'s list of reactants, products and * modifiers. *

* The \'stoichiometry\' attribute and the \'stoichiometryMath\' element, when * either is used, is each interpreted as a factor applied to the reaction * rate to produce the rate of change of the species identified by the * \'species\' attribute in the enclosing {@link SpeciesReference}. This is the * normal interpretation of a stoichiometry, but in SBML, one additional * consideration has to be taken into account. The reaction rate, which is * the result of the {@link KineticLaw}\'s \'math\' element, is always in the model\'s * substance per time units. However, the rate of change of the * species will involve the species\' substance units (i.e., the units * identified by the {@link Species} object\'s \'substanceUnits\' attribute), and * these units may be different from the model\'s default substance * units. If the units are different, the stoichiometry must * incorporate a conversion factor for converting the model\'s substance * units to the species\' substance units. The conversion factor is * assumed to be included in the scalar value of the \'stoichiometry\' * attribute if \'stoichiometry\' is used. If instead \'stoichiometryMath\' is * used, then the product of the model\'s \'substance\' units times the * \'stoichiometryMath\' units must match the substance units of the * species. Note that in either case, if the species\' units and the * model\'s default substance units are the same, the stoichiometry ends * up being a dimensionless number and equivalent to the standard chemical * stoichiometry found in textbooks. Examples and more explanations of * this are given in the SBML specification. *

* The following is a simple example of a species reference for species * \'X0\', with stoichiometry 2, in a list of reactants within a reaction * having the identifier \'J1\': *

 * <model>
 *     ...
 *     <listOfReactions>
 *         <reaction id=\'J1\'>
 *             <listOfReactants>
 *                 <speciesReference species=\'X0\' stoichiometry=\'2\'>
 *             </listOfReactants>
 *             ...
 *         </reaction>
 *         ...
 *     </listOfReactions>
 *     ...
 * </model>

* The following is a more complex example of a species reference for * species \'X0\', with a stoichiometry formula consisting of * a rational number: *

 * <model>
 *     ...
 *     <listOfReactions>
 *         <reaction id=\'J1\'>
 *             <listOfReactants>
 *                 <speciesReference species=\'X0\'>
 *                     <stoichiometryMath>
 *                         <math xmlns=\'http://www.w3.org/1998/Math/MathML\'> 
 *                             <cn type=\'rational\'> 3 <sep/> 2 </cn>
 *                         </math>
 *                     </stoichiometryMath>
 *                 </speciesReference>
 *             </listOfReactants>
 *             ...
 *         </reaction>
 *         ...
 *     </listOfReactions>
 *     ...
 * </model>

* Additional discussions of stoichiometries and implications for species * and reactions are included in the documentation of {@link SpeciesReference} * class. *

* @see SpeciesReference * @see Reaction */ " %javamethodmodifiers StoichiometryMath::StoichiometryMath(const ASTNode* math = NULL) " /** * Creates a new {@link StoichiometryMath} object, optionally with the given math. *

* @param math an {@link ASTNode} representing the mathematical formula for * the stoichiometry expression. *

* @param level a long integer, the SBML Level to assign to this {@link StoichiometryMath} *

* @param version a long integer, the SBML Version to assign to this * {@link StoichiometryMath} *

* @param xmlns {@link XMLNamespaces}, a pointer to an array of {@link XMLNamespaces} to * assign to this {@link StoichiometryMath} *

* @note Once a {@link StoichiometryMath} has been added to an {@link SBMLDocument}, the level, * version and xmlns namespaces for the document override those used * to create the {@link StoichiometryMath}. Despite this, the ability to supply the values * at creation time is an important aid to creating 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 {@link SBMLDocument}. *

* @param sbmlns an {@link SBMLNamespaces} object. *

* @param v the {@link SBMLVisitor} instance to be used. *

* @return the result of calling v.visit(). */ public"; %javamethodmodifiers StoichiometryMath::clone() const " /** * Creates and returns a deep copy of this {@link StoichiometryMath} object. *

* @return a (deep) copy of this {@link StoichiometryMath}. */ public"; %javamethodmodifiers StoichiometryMath::getMath() const " /** * Retrieves the mathematical formula within this {@link StoichiometryMath} and * return it as an AST. *

* @return the math of this {@link StoichiometryMath}. */ public"; %javamethodmodifiers StoichiometryMath::isSetMath() const " /** * Predicate to test whether the math for this {@link StoichiometryMath} object * has been set. *

* @return true if the formula (meaning the math subelement) of * this {@link StoichiometryMath} has been set, false otherwise. */ public"; %javamethodmodifiers StoichiometryMath::setMath(const ASTNode* math) " /** * Sets the \'math\' expression of this {@link StoichiometryMath} instance to a * copy of the given {@link ASTNode}. *

* @param math an {@link ASTNode} representing a formula tree. */ public"; %javamethodmodifiers StoichiometryMath::getDerivedUnitDefinition " /** * Calculates and returns a {@link UnitDefinition} object that expresses the * units returned by the math expression in this {@link StoichiometryMath} * object. *

* The units are calculated based on the mathematical expression in the * {@link StoichiometryMath} and the model quantities referenced by * <ci> elements used within that expression. The * StoichiometryMath.getDerivedUnitDefinition() method returns the * calculated units. *

* @warning Note that it is possible the \'math\' expression in the * {@link StoichiometryMath} instance contains literal numbers or parameters with * undeclared units. In those cases, it is not possible to calculate the * units of the overall expression without making assumptions. LibSBML * does not make assumptions about the units, and * StoichiometryMath.getDerivedUnitDefinition() only returns the units * as far as it is able to determine them. For example, in an expression * X + Y, if X has unambiguously-defined units and * Y does not, it will return the units of X. When * using this method, it is critical that callers also invoke the * method StoichiometryMath.containsUndeclaredUnits() * to determine whether this situation holds. Callers * should take suitable action in those situations. *

* @return a {@link UnitDefinition} that expresses the units of the math *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers StoichiometryMath::getDerivedUnitDefinition() const " /** * Calculates and returns a {@link UnitDefinition} object that expresses the * units returned by the math expression in this {@link StoichiometryMath} * object. *

* @return a {@link UnitDefinition} that expresses the units of the math *

* @see #containsUndeclaredUnits() */ public"; %javamethodmodifiers StoichiometryMath::containsUndeclaredUnits " /** * Predicate returning true or false depending on whether the math * expression of this {@link StoichiometryMath} object contains literal numbers * or parameters with undeclared units. *

* The StoichiometryMath.getDerivedUnitDefinition() method returns what * libSBML computes the units of the Stoichiometry to be, to the extent * that libSBML can compute them. However, if the expression contains * literal numbers or parameters with undeclared units, libSBML may not * be able to compute the full units of the expression and will only * return what it can compute. Callers should always use * StoichiometryMath.containsUndeclaredUnits() when using * StoichiometryMath.getDerivedUnitDefinition() to decide whether the * returned units may be incomplete. *

* @return true if the math expression of this {@link StoichiometryMath} * includes numbers/parameters with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by StoichiometryMath.getDerivedUnitDefinition() may not * accurately represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers StoichiometryMath::containsUndeclaredUnits() const " /** * Predicate returning true or false depending on whether the math * expression of this {@link StoichiometryMath} object contains literal numbers * or parameters with undeclared units. *

* @return true if the math expression of this {@link StoichiometryMath} * includes numbers/parameters with undeclared units, false otherwise. *

* @note A return value of true indicates that the {@link UnitDefinition} * returned by StoichiometryMath.getDerivedUnitDefinition() may not * accurately represent the units of the expression. *

* @see #getDerivedUnitDefinition() */ public"; %javamethodmodifiers StoichiometryMath::setSBMLDocument(SBMLDocument* d) " /** * Sets the parent {@link SBMLDocument} of this SBML object. *

* @param d the {@link SBMLDocument} to use.

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::setParentSBMLObject(SBase* sb) " /** * Sets the parent SBML object of this SBML object. *

* @param sb the SBML object to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::getTypeCode() const " /** * Returns the libSBML type code of this object instance. *

* @return the SBML type code for this object, or SBML_UNKNOWN (default). *

* @see #getElementName() */ public"; %javamethodmodifiers StoichiometryMath::getElementName() const " /** * Returns the XML element name of this object, which for {@link StoichiometryMath}, is * always \'stoichiometryMath\'. *

* @return the name of this element, i.e., \'stoichiometryMath\'. */ public"; %javamethodmodifiers StoichiometryMath::getElementPosition() const " /** * Returns the position of this element. *

* @return the ordinal position of the element with respect to its * siblings or -1 (default) to indicate the position is not significant.

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::writeElements(XMLOutputStream& stream) const " /** * Subclasses should override this method to write out their contained * SBML objects as XML elements. Be sure to call your parents * implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::readOtherXML(XMLInputStream& stream) " /** * Subclasses should override this method to read (and store) XHTML, * MathML, etc. directly from the XMLInputStream. *

* @return true if the subclass read from the stream, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::readAttributes(const XMLAttributes& attributes) " /** * Subclasses should override this method to read values from the given * {@link XMLAttributes} set into their specific fields. Be sure to call your * parents implementation of this method as well.

* @deprecated libSBML internal */ public"; %javamethodmodifiers StoichiometryMath::writeAttributes(XMLOutputStream& stream) const " /** * Subclasses should override this method to write their XML attributes * to the XMLOutputStream. Be sure to call your parents implementation * of this method as well.

* @deprecated libSBML internal */ public"; %typemap(javaimports) SBMLNamespaces " /** * Class to store SBML level, version and namespace information. *

* There are differences in the definitions of components between different * SBML Levels, as well as Versions within Levels. For example, the * \'sboTerm\' attribute was not introduced until Level 2 * Version 2, and then only on certain component classes; the SBML * Level 2 Version 3 specification moved the \'sboTerm\' attribute * to the {@link SBase} class, thereby allowing nearly all components to have {@link SBO} * annotations. As a result of differences such as those, libSBML needs to * track the SBML Level and Version of every object created. *

* The purpose of the {@link SBMLNamespaces} object class is to make it easier to * communicate SBML Level and Version data between libSBML constructors and * other methods. The {@link SBMLNamespaces} object class tracks 3-tuples * (triples) consisting of SBML Level, Version, and the corresponding SBML * XML namespace. (The plural name is not a mistake, because in SBML * Level 3, objects may have extensions added by Level 3 packages * used by a given model; however, until the introduction of SBML * Level 3, the {@link SBMLNamespaces} object only records one SBML * Level/Version/namespace combination at a time.) Most constructors for * SBML objects in libSBML take a {@link SBMLNamespaces} object as an argument, * thereby allowing the constructor to produce the proper combination of * attributes and other internal data structures for the given SBML * Level and Version. */ " %javamethodmodifiers SBMLNamespaces::SBMLNamespaces(unsigned int level = SBML_DEFAULT_LEVEL, unsigned int version = SBML_DEFAULT_VERSION) " /** * Creates a new {@link SBMLNamespaces} object corresponding to the given SBML * level and version. *

* {@link SBMLNamespaces} objects are used in libSBML to communicate SBML Level * and Version data between constructors and other methods. The * {@link SBMLNamespaces} object class tracks 3-tuples (triples) consisting of * SBML Level, Version, and the corresponding SBML XML namespace. Most * constructors for SBML objects in libSBML take a {@link SBMLNamespaces} object * as an argument, thereby allowing the constructor to produce the proper * combination of attributes and other internal data structures for the * given SBML Level and Version. *

* The plural name \'{@link SBMLNamespaces}\' is not a mistake, because in SBML * Level 3, objects may have extensions added by Level 3 * packages used by a given model; however, until the introduction of * SBML Level 3, the {@link SBMLNamespaces} object only records one SBML * Level/Version/namespace combination at a time. *

* @param level the SBML level * @param version the SBML version *

* @return a string representing the SBML namespace that reflects the * SBML Level and Version specified. */ public"; %javamethodmodifiers SBMLNamespaces::getLevel " /** * Get the SBML Level of this {@link SBMLNamespaces} object. *

* @return the SBML Level of this {@link SBMLNamespaces} object. */ public"; %javamethodmodifiers SBMLNamespaces::getVersion " /** * Get the SBML Version of this {@link SBMLNamespaces} object. *

* @return the SBML Version of this {@link SBMLNamespaces} object. */ public"; %javamethodmodifiers SBMLNamespaces::getNamespaces " /** * Get the XML namespaces list for this {@link SBMLNamespaces} object. *

* The plural is not a mistake, because in SBML Level 3, objects may * have extensions added by Level 3 packages used by a given model, * and therefore there may be multiple XML namespaces involved too. * However, until the introduction of SBML Level 3, the * {@link SBMLNamespaces} object only records one SBML Level/Version/namespace * combination at a time, and so this method will also only return * a list of one item. *

* @return the XML namespaces of this {@link SBMLNamespaces} object. */ public"; %javamethodmodifiers SBMLNamespaces::getNamespaces " /** * Get the XML namespaces list for this {@link SBMLNamespaces} object. *

* @return the XML namespaces of this {@link SBMLNamespaces} object.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLNamespaces::getNamespaces " /** * Get the XML namespaces list for this {@link SBMLNamespaces} object. *

* @return the XML namespaces of this {@link SBMLNamespaces} object.

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBMLNamespaces::getNamespaces " /** * Get the XML namespaces list for this {@link SBMLNamespaces} object. *

* @return the XML namespaces of this {@link SBMLNamespaces} object.

* @deprecated libSBML internal */ public"; %javamethodmodifiers readMathML(XMLInputStream& stream) " /** * Reads the MathML from the given XMLInputStream, constructs a corresponding * abstract syntax tree and returns a pointer to the root of the tree.

* @deprecated libSBML internal */ public"; %javamethodmodifiers writeMathML(const ASTNode* node, XMLOutputStream& stream) " /** * Writes the given {@link ASTNode} (and its children) to the XMLOutputStream as * MathML.

* @deprecated libSBML internal */ public"; %javamethodmodifiers readMathMLFromString(const char *xml) " /** * Reads the MathML from the given XML string, constructs a corresponding * abstract syntax tree, and returns a pointer to the root of the tree. *

* @param xml a string containing a full MathML expression *

* @return the root of an AST corresponding to the given mathematical * expression */ public"; %javamethodmodifiers writeMathMLToString(const ASTNode_t* node) " /** * Writes the given {@link ASTNode} (and its children) to a string as MathML, and * returns the string. *

* @param node the root of an AST to write out to the stream. *

* @return a string containing the written-out MathML representation * of the given AST *

* @note The string is owned by the caller and should be freed (with * free()) when no longer needed. */ public"; %typemap(javaimports) ASTNode " /** * A node in the Abstract Syntax Tree (AST) representation of a * mathematical expression. *

* Abstract Syntax Trees (ASTs) are a simple kind of data structure used in * libSBML for storing mathematical expressions. The {@link ASTNode} is the * cornerstone of libSBML\'s AST representation. ASTNodes represent the * most basic, indivisible part of a mathematical formula and come in many * types. For instance, there are node types to represent numbers (with * subtypes to distinguish integer, real, and rational numbers), names * (e.g., constants or variables), simple mathematical operators, logical * or relational operators and functions. LibSBML ASTs provide a canonical, * in-memory representation for all mathematical formulas regardless of * their original format (which might be MathML or might be text strings). *

* An AST node in libSBML is a recursive structure containing a pointer * to the node\'s value (which might be, for example, a number or a symbol) * and a list of children nodes. Each {@link ASTNode} node may have none, one, * two, or more child depending on its type. The following diagram * illustrates an example of how the mathematical expression \'1 + * 2\' is represented as an AST with one plus node having two * integer children nodes for the numbers 1 and * 2. The figure also shows the corresponding MathML * representation: *

* *

* The following are other noteworthy points about the AST representation * in libSBML: *

A numerical value represented in MathML as a real number with an * exponent is preserved as such in the AST node representation, even if * the number could be stored in a double data type. This is done * so that when an SBML model is read in and then written out again, the * amount of change introduced by libSBML to the SBML during the round-trip * activity is minimized. *
*
Rational numbers are represented in an AST node using separate * numerator and denominator values. These can be retrieved using the * methods ASTNode.getNumerator() and ASTNode.getDenominator(). *
*
The children of an {@link ASTNode} are other {@link ASTNode} objects. The list of * children is empty for nodes that are leaf elements, such as numbers. * For nodes that are actually roots of expression subtrees, the list of * children points to the parsed objects that make up the rest of the * expression. *

The set of possible ASTNode types

* Every {@link ASTNode} has an associated * type code to indicate, for example, whether it holds a number or stands for * an arithmetic operator. The type is recorded as a value drawn from a * set of static integer constants defined in the class {@link * libsbmlConstants}. Their names begin with the characters AST_. The * list of possible types is quite long, because it covers all the * mathematical functions that are permitted in SBML. The values are shown * in the following table; their names hopefully evoke the construct that * they represent: *


`AST_UNKNOWN`	`AST_FUNCTION_ARCCOTH`	`AST_FUNCTION_POWER`
`AST_PLUS`	`AST_FUNCTION_ARCCSC`	`AST_FUNCTION_ROOT`
`AST_MINUS`	`AST_FUNCTION_ARCCSCH`	`AST_FUNCTION_SEC`
`AST_TIMES`	`AST_FUNCTION_ARCSEC`	`AST_FUNCTION_SECH`
`AST_DIVIDE`	`AST_FUNCTION_ARCSECH`	`AST_FUNCTION_SIN`
`AST_POWER`	`AST_FUNCTION_ARCSIN`	`AST_FUNCTION_SINH`
`AST_INTEGER`	`AST_FUNCTION_ARCSINH`	`AST_FUNCTION_TAN`
`AST_REAL`	`AST_FUNCTION_ARCTAN`	`AST_FUNCTION_TANH`
`AST_REAL_E`	`AST_FUNCTION_ARCTANH`	`AST_LOGICAL_AND`
`AST_RATIONAL`	`AST_FUNCTION_CEILING`	`AST_LOGICAL_NOT`
`AST_NAME`	`AST_FUNCTION_COS`	`AST_LOGICAL_OR`
`AST_NAME_TIME`	`AST_FUNCTION_COSH`	`AST_LOGICAL_XOR`
`AST_CONSTANT_E`	`AST_FUNCTION_COT`	`AST_RELATIONAL_EQ`
`AST_CONSTANT_FALSE`	`AST_FUNCTION_COTH`	`AST_RELATIONAL_GEQ`
`AST_CONSTANT_PI`	`AST_FUNCTION_CSC`	`AST_RELATIONAL_GT`
`AST_CONSTANT_TRUE`	`AST_FUNCTION_CSCH`	`AST_RELATIONAL_LEQ`
`AST_LAMBDA`	`AST_FUNCTION_EXP`	`AST_RELATIONAL_LT`
`AST_FUNCTION`	`AST_FUNCTION_FACTORIAL`	`AST_RELATIONAL_NEQ`
`AST_FUNCTION_ABS`	`AST_FUNCTION_FLOOR`
`AST_FUNCTION_ARCCOS`	`AST_FUNCTION_LN`
`AST_FUNCTION_ARCCOSH`	`AST_FUNCTION_LOG`
`AST_FUNCTION_ARCCOT`	`AST_FUNCTION_PIECEWISE`

* The types have the following meanings: *

If the node is basic mathematical operator (e.g., \'+\'), then the * node\'s type will be AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE, * or AST_POWER, as appropriate. *
*
If the node is a predefined function or operator from SBML Level 1 * (in the string-based formula syntax used in Level 1) or SBML Level 2 * (in the subset of MathML used in SBML Level 2), then the node\'s type * will be either AST_FUNCTION_x, * AST_LOGICAL_x, or * AST_RELATIONAL_x, as appropriate. (Examples: * AST_FUNCTION_LOG, AST_RELATIONAL_LEQ.) *
*
If the node refers to a user-defined function, the node\'s type will * be AST_NAME (because it holds the name of the function). *
*
If the node is a lambda expression, its type will be AST_LAMBDA. *
*
If the node is a predefined constant (\'ExponentialE\', \'Pi\', * \'True\' or \'False\'), then the node\'s type will be AST_CONSTANT_E, * AST_CONSTANT_PI, AST_CONSTANT_TRUE, or AST_CONSTANT_FALSE. *
*
(Level 2 only) If the node is the special MathML csymbol time, * the value of the node will be AST_NAME_TIME. (Note, however, that the * MathML csymbol delay is translated into a node of type * AST_FUNCTION_DELAY. The difference is due to the fact that time is a * single variable, whereas delay is actually a function taking * arguments.) *
*
If the node contains a numerical value, its type will be * AST_INTEGER, AST_REAL, AST_REAL_E, or AST_RATIONAL, * as appropriate. *

Converting between ASTs and text strings

* * The text-string form of mathematical formulas produced by * libsbml.formulaToString() and read by * libsbml.parseFormula() are simple C-inspired * infix notation taken from SBML Level 1. A formula in this * text-string form can be handed to a program that understands SBML * Level 1 mathematical expressions, or used as part of a translation * system. The libSBML distribution comes with an example program in the * \'examples\' subdirectory called translateMath that implements an * interactive command-line demonstration of translating infix formulas * into MathML and vice-versa. *

* The formula strings may contain operators, function calls, symbols, and * white space characters. The allowable white space characters are tab * and space. The following are illustrative examples of formulas * expressed in the syntax: *

0.10 * k4^2

(vm * s1)/(km + s1)

* The following table shows the precedence rules in this syntax. In the * Class column, operand implies the construct is an operand, * prefix implies the operation is applied to the following arguments, * unary implies there is one argument, and binary implies there are * two arguments. The values in the Precedence column show how the order * of different types of operation are determined. For example, the * expression a * b + c is evaluated as (a * b) + c * because the * operator has higher precedence. The * Associates column shows how the order of similar precedence operations * is determined; for example, a - b + c is evaluated as (a - * b) + c because the + and - operators are * left-associative. The precedence and associativity rules are taken from * the C programming language, except for the symbol ^, which * is used in C for a different purpose. (Exponentiation can be invoked * using either ^ or the function power.) *

A table of the expression operators and their precedence in the text-string format for mathematical expressions used by SBML_parseFormula().
Token	Operation	Class	Precedence	Associates
name	symbol reference	operand	6	n/a
`(`expression`)`	expression grouping	operand	6	n/a
`f(`...`)`	function call	prefix	6	left
`-`	negation	unary	5	right
`^`	power	binary	4	left
`*`	multiplication	binary	3	left
`/`	divison	binary	3	left
`+`	addition	binary	2	left
`-`	subtraction	binary	2	left
`,`	argument delimiter	binary	1	left

* A program parsing a formula in an SBML model should assume that names * appearing in the formula are the identifiers of {@link Species}, {@link Parameter}, * {@link Compartment}, {@link FunctionDefinition}, or {@link Reaction} objects defined in a model. * When a function call is involved, the syntax consists of a function * identifier, followed by optional white space, followed by an opening * parenthesis, followed by a sequence of zero or more arguments separated * by commas (with each comma optionally preceded and/or followed by zero * or more white space characters), followed by a closing parenthesis. * There is an almost one-to-one mapping between the list of predefined * functions available, and those defined in MathML. All of the MathML * functions are recognized; this set is larger than the functions defined * in SBML Level 1. In the subset of functions that overlap between * MathML and SBML Level 1, there exist a few differences. The * following table summarizes the differences between the predefined * functions in SBML Level 1 and the MathML equivalents in SBML * Level 2: *

Table comparing the names of certain functions in the SBML text-string formula syntax and MathML. The left column shows the names of functions recognized by SBML_parseFormula(); the right column shows their equivalent function names in MathML 2.0, used in SBML Level 2.
Text string formula functions	MathML equivalents in SBML Level 2
`acos`	`arccos`
`asin`	`arcsin`
`atan`	`arctan`
`ceil`	`ceiling`
`log`	`ln`
`log10(x)`	`log(10, x)`
`pow(x, y)`	`power(x, y)`
`sqr(x)`	`power(x, 2)`
`sqrt(x)`	`root(2, x)`

*/ " %javamethodmodifiers ASTNode::ASTNode(ASTNodeType_t type = AST_UNKNOWN) " /** * Creates and returns a new {@link ASTNode}. *

* By default, the returned node will have a type of AST_UNKNOWN. The * calling code should set the node type to something else as soon as * possible using {@link ASTNode#setType(int)} *

* @param token the Token to add. */ public"; %javamethodmodifiers ASTNode::ASTNode(const ASTNode& orig) " /** * Copy constructor; Creates a deep copy of the given {@link ASTNode}. *

* @param orig the {@link ASTNode} to be copied. */ public"; %javamethodmodifiers ASTNode::freeName " /** * Frees the name of this {@link ASTNode} and sets it to NULL. *

* This operation is only applicable to ASTNodes corresponding to * operators, numbers, or AST_UNKNOWN. This method will have no * effect on other types of nodes. */ public"; %javamethodmodifiers ASTNode::canonicalize " /** * Converts this {@link ASTNode} to a canonical form and returns true (non-zero) * if successful, false (zero) otherwise. *

* The rules determining the canonical form conversion are as follows: *

If the node type is AST_NAME and the node name matches * \'ExponentialE\', \'Pi\', \'True\' or \'False\' the node type is * converted to the corresponding AST_CONSTANT_x type. *
*
If the node type is an AST_FUNCTION and the node name matches * an SBML Level 1 or Level 2 (MathML) function name, logical * operator name, or relational operator name, the node is converted to * the correspnding AST_FUNCTION_x or * AST_LOGICAL_x type. *
*

* SBML Level 1 function names are searched first; thus, for * example, canonicalizing log will result in a node type of * AST_FUNCTION_LN. (See the SBML Level 1 Specification, Appendix * C.) *

* Sometimes canonicalization of a node results in a structural converion * of the node as a result of adding a child. For example, a node with * the SBML Level 1 function name sqr and a single child node * (the argument) will be transformed to a node of type * AST_FUNCTION_POWER with two children. The first child will remain * unchanged, but the second child will be an {@link ASTNode} of type * AST_INTEGER and a value of 2. The function names that result in * structural changes are: log10, sqr, and sqrt. *

* See the SBML Level 1 and Level 2 (all versions) * specification documents for more information. */ public"; %javamethodmodifiers ASTNode::addChild(ASTNode* child) " /** * Adds the given node as a child of this {@link ASTNode}. Child nodes are added * in-order from left to right. *

* @param child the {@link ASTNode} instance to add */ public"; %javamethodmodifiers ASTNode::prependChild(ASTNode* child) " /** * Adds the given node as a child of this {@link ASTNode}. This method adds * child nodes from right to left. *

* @param child the {@link ASTNode} instance to add */ public"; %javamethodmodifiers ASTNode::removeChild(unsigned int n) " /** * Removes child n of this {@link ASTNode}. *

* @param n long the index of the child to remove *

* @return int indicating the success or failure of the operation *

* @note removing a child from an {@link ASTNode} may result in an * inaccurate representation. */ public"; %javamethodmodifiers ASTNode::replaceChild(unsigned int n, ASTNode *newChild) " /** * Replaces the nth child of this {@link ASTNode} with the given {@link ASTNode}. *

* @param n long the index of the child to replace * @param newChild {@link ASTNode} to replace the nth child *

* @return int indicating the success or failure of the operation *

* @note replacing a child within an {@link ASTNode} may result in an * inaccurate representation. */ public"; %javamethodmodifiers ASTNode::insertChild(unsigned int n, ASTNode *newChild) " /** * Insert the given {@link ASTNode} at point n in the list of children * of this {@link ASTNode}. *

* @param n long the index of the {@link ASTNode} being added * @param newChild {@link ASTNode} to insert as the nth child *

* @return int indicating the success or failure of the operation *

* @note inserting a child within an {@link ASTNode} may result in an * inaccurate representation. */ public"; %javamethodmodifiers ASTNode::deepCopy() const " /** * Creates a recursive copy of this node and all its children. *

* @return a copy of this {@link ASTNode} and all its children. The caller owns * the returned {@link ASTNode} and is reponsible for deleting it. */ public"; %javamethodmodifiers ASTNode::getChild " /** * Get a child of this node according to an index number. *

* @param n the index of the child to get *

* @return the nth child of this {@link ASTNode} or NULL if this node has no nth * child (n > getNumChildren() - 1). */ public"; %javamethodmodifiers ASTNode::getLeftChild() const " /** * Get the left child of this node. *

* @return the left child of this {@link ASTNode}. This is equivalent to * getChild(0); */ public"; %javamethodmodifiers ASTNode::getRightChild() const " /** * Get the right child of this node. *

* @return the right child of this {@link ASTNode}, or NULL if this node has no * right child. If getNumChildren() > 1, then * this is equivalent to: *

   * getChild( getNumChildren() - 1 );

*/ public"; %javamethodmodifiers ASTNode::getNumChildren() const " /** * Get the number of children that this node has. *

* @return the number of children of this {@link ASTNode}, or 0 is this node has * no children. */ public"; %javamethodmodifiers ASTNode::addSemanticsAnnotation(XMLNode* sAnnotation) " /** * Adds the given {@link XMLNode} as a semantic annotation of this {@link ASTNode}. *

* @param sAnnotation the annotation to add. */ public"; %javamethodmodifiers ASTNode::getNumSemanticsAnnotations() const " /** * Get the number of semantic annotation elements inside this node. *

* @return the number of annotations of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::getSemanticsAnnotation " /** * Get the nth semantic annotation of this node. *

* @return the nth annotation of this {@link ASTNode}, or NULL if this node has no nth * annotation (n > getNumChildren() - 1). */ public"; %javamethodmodifiers ASTNode::getListOfNodes(ASTNodePredicate predicate) const " /** * Performs a depth-first search of the tree rooted at node and returns * the {@link List} of nodes where predicate(node) returns true * (non-zero). *

* The typedef for ASTNodePredicate is: *

   * int (*ASTNodePredicate) (const ASTNode_t *node);

* where a return value of non-zero represents true and zero represents * false. *

* @param predicate the predicate to use *

* @return the list of nodes for which the predicate returned true * (non-zero). The {@link List} returned is owned by the caller and should be * deleted after the caller is done using it. The ASTNodes in the list; * however, are not owned by the caller (as they still belong to the tree * itself) and therefore should not be deleted. */ public"; %javamethodmodifiers ASTNode::fillListOfNodes(ASTNodePredicate predicate, List* lst) const " /** * This method is identical in functionality to * ASTNode.getListOfNodes(), except the {@link List} is passed-in by the caller. */ public"; %javamethodmodifiers ASTNode::getCharacter() const " /** * Get the value of this node as a single character. This function * should be called only when ASTNode.getType() is one of AST_PLUS, * AST_MINUS, AST_TIMES, AST_DIVIDE or AST_POWER. *

* @return the value of this {@link ASTNode} as a single character */ public"; %javamethodmodifiers ASTNode::getInteger() const " /** * Get the value of this node as an integer. This function should be * called only when getType() == AST_INTEGER. *

* @return the value of this {@link ASTNode} as a (long) integer. */ public"; %javamethodmodifiers ASTNode::getName() const " /** * Get the value of this node as a string. This function may be called * on nodes that are not operators (isOperator() == false) * or numbers (isNumber() == false). *

* @return the value of this {@link ASTNode} as a string. */ public"; %javamethodmodifiers ASTNode::getNumerator() const " /** * Get the value of the numerator of this node. This function * should be called only when getType() == AST_RATIONAL. *

* @return the value of the numerator of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::getDenominator() const " /** * Get the value of the denominator of this node. This function * should be called only when getType() == AST_RATIONAL. *

* @return the value of the denominator of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::getReal() const " /** * Get the real-numbered value of this node. This function * should be called only when isReal() == true. *

* This function performs the necessary arithmetic if the node type is * AST_REAL_E (mantissa * 10^exponent) or * AST_RATIONAL (numerator / denominator). *

* @return the value of this {@link ASTNode} as a real (double). */ public"; %javamethodmodifiers ASTNode::getMantissa() const " /** * Get the mantissa value of this node. This function should be called * only when getType() returns AST_REAL_E or AST_REAL. If * getType() returns AST_REAL, this method is identical to getReal(). *

* @return the value of the mantissa of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::getExponent() const " /** * Get the exponent value of this {@link ASTNode}. This function should be * called only when getType() returns AST_REAL_E or AST_REAL. *

* @return the value of the exponent of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::getPrecedence() const " /** * Get the precedence of this node in the infix math syntax of SBML * Level 1. For more information about the infix syntax, see the * discussion about text string formulas at * the top of the documentation for {@link ASTNode}. *

* @return an integer indicating the precedence of this {@link ASTNode} */ public"; %javamethodmodifiers ASTNode::getType() const " /** * Get the type of this {@link ASTNode}. The value returned is one of the * enumeration values such as AST_LAMBDA, AST_PLUS, etc. *

* @return the type of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::isBoolean() const " /** * Predicate returning true (non-zero) if this node has a boolean type (a * logical operator, a relational operator, or the constants true or * false). *

* @return true if this {@link ASTNode} is a boolean, false otherwise. */ public"; %javamethodmodifiers ASTNode::isConstant() const " /** * Predicate returning true (non-zero) if this node represents a MathML * constant (e.g., true, Pi). *

* @return true if this {@link ASTNode} is a MathML constant, false otherwise. */ public"; %javamethodmodifiers ASTNode::isFunction() const " /** * Predicate returning true (non-zero) if this node represents a MathML * function (e.g., abs()), or an SBML Level 1 * function, or a user-defined function. *

* @return true if this {@link ASTNode} is a function, false otherwise. */ public"; %javamethodmodifiers ASTNode::isInfinity() const " /** * Predicate returning true (non-zero) if this node represents * the special IEEE 754 value infinity, false (zero) otherwise. *

* @return true if this {@link ASTNode} is the special IEEE 754 value infinity, * false otherwise. */ public"; %javamethodmodifiers ASTNode::isInteger() const " /** * Predicate returning true (non-zero) if this node contains an integer * value, false (zero) otherwise. *

* @return true if this {@link ASTNode} is of type AST_INTEGER, false otherwise. */ public"; %javamethodmodifiers ASTNode::isLambda() const " /** * Predicate returning true (non-zero) if this node is a MathML * <lambda>, false (zero) otherwise. *

* @return true if this {@link ASTNode} is of type AST_LAMBDA, false otherwise. */ public"; %javamethodmodifiers ASTNode::isLog10() const " /** * Predicate returning true (non-zero) if this node represents a * log10() function, false (zero) otherwise. More precisely, this * predicate returns true if the node type is AST_FUNCTION_LOG with * two children, the first of which is an AST_INTEGER equal to 10. *

* @return true if the given {@link ASTNode} represents a log10() function, false * otherwise. */ public"; %javamethodmodifiers ASTNode::isLogical() const " /** * Predicate returning true (non-zero) if this node is a MathML logical * operator (i.e., and, or, not, xor). *

* @return true if this {@link ASTNode} is a MathML logical operator */ public"; %javamethodmodifiers ASTNode::isName() const " /** * Predicate returning true (non-zero) if this node is a user-defined * variable name in SBML L1, L2 (MathML), or the special symbols delay * or time. The predicate returns false (zero) otherwise. *

* @return true if this {@link ASTNode} is a user-defined variable name in SBML * L1, L2 (MathML) or the special symbols delay or time. */ public"; %javamethodmodifiers ASTNode::isNaN() const " /** * Predicate returning true (non-zero) if this node represents the * special IEEE 754 value \'not a number\' (NaN), false (zero) otherwise. *

* @return true if this {@link ASTNode} is the special IEEE 754 NaN */ public"; %javamethodmodifiers ASTNode::isNegInfinity() const " /** * Predicate returning true (non-zero) if this node represents the * special IEEE 754 value \'negative infinity\', false (zero) otherwise. *

* @return true if this {@link ASTNode} is the special IEEE 754 value negative * infinity, false otherwise. */ public"; %javamethodmodifiers ASTNode::isNumber() const " /** * Predicate returning true (non-zero) if this node contains a number, * false (zero) otherwise. This is functionally equivalent to the * following code: *

   *   isInteger() || isReal()

* @return true if this {@link ASTNode} is a number, false otherwise. */ public"; %javamethodmodifiers ASTNode::isOperator() const " /** * Predicate returning true (non-zero) if this node is a mathematical * operator, meaning, +, -, *, * / or ^ (power). *

* @return true if this {@link ASTNode} is an operator. */ public"; %javamethodmodifiers ASTNode::isPiecewise() const " /** * Predicate returning true (non-zero) if this node is the MathML * <piecewise> construct, false (zero) otherwise. *

* @return true if this {@link ASTNode} is a MathML piecewise function */ public"; %javamethodmodifiers ASTNode::isRational() const " /** * Predicate returning true (non-zero) if this node represents a rational * number, false (zero) otherwise. *

* @return true if this {@link ASTNode} is of type AST_RATIONAL. */ public"; %javamethodmodifiers ASTNode::isReal() const " /** * Predicate returning true (non-zero) if this node can represent a real * number, false (zero) otherwise. More precisely, this node must be of * one of the following types: AST_REAL, AST_REAL_E or * AST_RATIONAL. *

* @return true if the value of this {@link ASTNode} can represented as a real * number, false otherwise. */ public"; %javamethodmodifiers ASTNode::isRelational() const " /** * Predicate returning true (non-zero) if this node is a MathML * relational operator, meaning ==, >=, * >, <, and !=. *

* @return true if this {@link ASTNode} is a MathML relational operator, false * otherwise */ public"; %javamethodmodifiers ASTNode::isSqrt() const " /** * Predicate returning true (non-zero) if this node represents a square * root function, false (zero) otherwise. More precisely, the node type * must be AST_FUNCTION_ROOT with two children, the first of which is * an AST_INTEGER node having value equal to 2. *

* @return true if the given {@link ASTNode} represents a sqrt() function, false * otherwise. */ public"; %javamethodmodifiers ASTNode::isUMinus() const " /** * Predicate returning true (non-zero) if this node is a unary minus * operator, false (zero) otherwise. A node is defined as a unary minus * node if it is of type AST_MINUS and has exactly one child. *

* For numbers, unary minus nodes can be \'collapsed\' by negating the * number. In fact, SBML_parseFormula() does this during its parse. * However, unary minus nodes for symbols (AST_NAMES) cannot be * \'collapsed\', so this predicate function is necessary. *

* @return true if this {@link ASTNode} is a unary minus, false otherwise. */ public"; %javamethodmodifiers ASTNode::isUnknown() const " /** * Predicate returning true (non-zero) if this node has an unknown type. *

* \'Unknown\' nodes have the type AST_UNKNOWN. Nodes with unknown * types will not appear in an {@link ASTNode} tree returned by libSBML based * upon valid SBML input; the only situation in which a node with type * AST_UNKNOWN may appear is immediately after having create a new, * untyped node using the {@link ASTNode} constructor. Callers creating nodes * should endeavor to set the type to a valid node type as soon as * possible after creating new nodes. *

* @return true if this {@link ASTNode} is of type AST_UNKNOWN, false otherwise. */ public"; %javamethodmodifiers ASTNode::setCharacter(char value) " /** * Sets the value of this {@link ASTNode} to the given character. If character * is one of +, -, @c *, @c / or ^, the node type will be set * accordingly. For all other characters, the node type will be set to * AST_UNKNOWN. *

* @param value the character value to which the node\'s value should be * set. */ public"; %javamethodmodifiers ASTNode::setName(const char *name) " /** * Sets the value of this {@link ASTNode} to the given name. *

* The node type will be set (to AST_NAME) only if the * {@link ASTNode} was previously an operator (isOperator(node) == * true) or number (isNumber(node) == true). This * allows names to be set for AST_FUNCTIONs and the like. *

* @param name the string containing the name to which this node\'s value * should be set */ public"; %javamethodmodifiers ASTNode::setValue(int value) " /** * Sets the value of this {@link ASTNode} to the given integer and sets the node * type to AST_INTEGER. *

* @param value the integer to which this node\'s value should be set */ public"; %javamethodmodifiers ASTNode::setValue(long value) " /** * Sets the value of this {@link ASTNode} to the given (long) integer and sets * the node type to AST_INTEGER. *

* @param value the integer to which this node\'s value should be set */ public"; %javamethodmodifiers ASTNode::setValue(long numerator, long denominator) " /** * Sets the value of this {@link ASTNode} to the given rational in two parts: the * numerator and denominator. The node type is set to AST_RATIONAL. *

* @param numerator the numerator value of the rational * @param denominator the denominator value of the rational */ public"; %javamethodmodifiers ASTNode::setValue(double value) " /** * Sets the value of this {@link ASTNode} to the given real (double) and sets * the node type to AST_REAL. *

* This is functionally equivalent to: *

   * setValue(value, 0);

* @param value the double format number to which this node\'s value * should be set */ public"; %javamethodmodifiers ASTNode::setValue(double mantissa, long exponent) " /** * Sets the value of this {@link ASTNode} to the given real (double) in two * parts: the mantissa and the exponent. The node type is set to * AST_REAL_E. *

* @param mantissa the mantissa of this node\'s real-numbered value * @param exponent the exponent of this node\'s real-numbered value */ public"; %javamethodmodifiers ASTNode::setType(ASTNodeType_t type) " /** * Sets the type of this {@link ASTNode} to the given ASTNodeType_t. A side-effect of doing this * is that any numerical values previously stored in this node are reset * to zero. *

* @param type the type to which this node should be set */ public"; %javamethodmodifiers ASTNode::swapChildren(ASTNode *that) " /** * Swap the children of this {@link ASTNode} with the children of that {@link ASTNode}. *

* @param that the other node whose children should be used to replace * this node\'s children */ public"; %javamethodmodifiers ASTNode::setSemanticsFlag " /** * Sets the flag indicating that this {@link ASTNode} has semantics attached

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::unsetSemanticsFlag " /** * Unsets the flag indicating that this {@link ASTNode} has semantics attached

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::getSemanticsFlag() const " /** * gets the flag indicating that this {@link ASTNode} has semantics attached

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::setDefinitionURL(XMLAttributes url) " /** * sets the definitionURL attributes

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::getDefinitionURL() const " /** * Gets the MathML definitionURL attribute value. */ public"; %javamethodmodifiers ASTNode::replaceArgument(const std::string bvar, ASTNode * arg) " /** * Replaces occurences of a name within this {@link ASTNode} with the name/value/formula * represented by the second argument {@link ASTNode} * e.g. if the formula in this {@link ASTNode} is x + y; bvar is x and arg is an * {@link ASTNode} representing the real value 3 ReplaceArgument substitutes 3 for * x within this {@link ASTNode} *

* @param bvar a string representing the variable name to be substituted * @param arg an {@link ASTNode} representing the name/value/formula to substitute */ public"; %javamethodmodifiers ASTNode::ReplaceArgument(const std::string bvar, ASTNode * arg) " /** * Replaces occurences of a name within this {@link ASTNode} with the name/value/formula * represented by the second argument {@link ASTNode} * e.g. if the formula in this {@link ASTNode} is x + y; bvar is x and arg is an * {@link ASTNode} representing the real value 3 ReplaceArgument substitutes 3 for * x within this {@link ASTNode} *

* @param bvar a string representing the variable name to be substituted * @param arg an {@link ASTNode} representing the name/value/formula to substitute

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::setParentSBMLObject(SBase * sb) " /** * Sets the parent SBML object. *

* @param sb the parent SBML object of this {@link ASTNode}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::getParentSBMLObject() const " /** * Returns the parent SBML object. *

* @return the parent SBML object of this {@link ASTNode}. */ public"; %javamethodmodifiers ASTNode::ReduceToBinary " /** * Returns the parent SBML object. *

* @return the parent SBML object of this {@link ASTNode}.

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::reduceToBinary " /** * Reduces this {@link ASTNode} to a binary tree * e.g. if the formula in this {@link ASTNode} is and(x, y, z) then the * formula of the reduced node would be and(and(x, y), z) */ public"; %javamethodmodifiers ASTNode::setUserData(void *userData) " /** * Sets the user data of this node. This can be used by the application * developer to attach custom information to the node. In case of a deep * copy this attribute will passed as it is. The attribute will be never * interpreted by this class. *

* @param userData specifies the new user data. */ public"; %javamethodmodifiers ASTNode::*getUserData() const " /** * Returns the user data that has been previously set via setUserData(). *

* @return the user data of this node. NULL if no user data has been. * @see ASTNode#setUserData */ public"; %javamethodmodifiers ASTNode::canonicalizeConstant " /** * Internal helper function for canonicalize().

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::canonicalizeFunction " /** * Internal helper function for canonicalize().

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::canonicalizeFunctionL1 " /** * Internal helper function for canonicalize().

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::canonicalizeLogical " /** * Internal helper function for canonicalize().

* @deprecated libSBML internal */ public"; %javamethodmodifiers ASTNode::canonicalizeRelational " /** * Internal helper function for canonicalize().

* @deprecated libSBML internal */ public"; %javamethodmodifiers SBML_parseFormula(const char *formula) " /** * Parses a text-string mathematical formula and returns a representation * as an Abstract Syntax Tree. *

* The text-string form of * mathematical formulas produced by libsbml.formulaToString() and read by * libsbml.parseFormula() are * simple C-inspired infix notation taken from SBML Level 1. A * formula in this text-string form therefore can be handed to a program * that understands SBML Level 1 mathematical expressions, or used as * part of a formula translation system. The syntax is described in detail * in the documentation for {@link ASTNode}. *

* @param formula the string containing the mathematical formula. *

* @return an {@link ASTNode} (the root of the expression tree). If the formula * contains a grammatical error, NULL is returned. */ public"; %javamethodmodifiers SBML_formulaToString(const ASTNode_t *tree) " /** * Converts an {@link ASTNode} formula to a text string using a specific * syntax for mathematical formulas. *

* The text-string form of * mathematical formulas produced by * libsbml.formulaToString() and read by * * libsbml.parseFormula() are * simple C-inspired infix notation taken from SBML Level 1. A * formula in this text-string form therefore can be handed to a program * that understands SBML Level 1 mathematical expressions, or used as * part of a formula translation system. The syntax is described in detail * in the documentation for {@link ASTNode}. *

* @param tree the root of the {@link ASTNode} formula expression tree *

* @return the formula from the given AST as an SBML Level 1 text-string * mathematical formula. The caller owns the returned string and is * responsible for freeing it when it is no longer needed. */ public"; %typemap(javaimports) XMLAttributes " /** * Representation of attributes on an XML node. *

*/ " %javamethodmodifiers XMLAttributes::XMLAttributes " /** * Creates a new empty {@link XMLAttributes} set. */ public"; %javamethodmodifiers XMLAttributes::XMLAttributes(const XMLAttributes& orig) " /** * Copy constructor; creates a copy of this {@link XMLAttributes} set. */ public"; %javamethodmodifiers XMLAttributes::clone() const " /** * Creates and returns a deep copy of this {@link XMLAttributes} set. *

* @return a (deep) copy of this {@link XMLAttributes} set. */ public"; %javamethodmodifiers XMLAttributes::add( const std::string& name , const std::string& value , const std::string& namespaceURI = "" , const std::string& prefix = "") " /** * Adds an attribute (a name/value pair) to this {@link XMLAttributes} set optionally * with a prefix and URI defining a namespace. *

* @param name a string, the local name of the attribute. * @param value a string, the value of the attribute. * @param namespaceURI a string, the namespace URI of the attribute. * @param prefix a string, the prefix of the namespace *

* @note if local name with the same namespace URI already exists in this * attribute set, its value and prefix will be replaced. *

* @note if local name with the same namespace URI already exists in this attribute set, * its value and prefix will be replaced. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a string, the value of the attribute. */ public"; %javamethodmodifiers XMLAttributes::addResource(const std::string& name, const std::string& value) " /** * Adds an name/value pair to this {@link XMLAttributes} set. *

* This method is similar to the add method but an attribute with same name wont * be overwritten. This facilitates the addition of multiple resource attributes * in {@link CVTerm} class. *

* @param name a string, the name of the attribute. * @param value a string, the value of the attribute. *

* @note This function is only internally used to store multiple rdf:resource * attributes in {@link CVTerm} class, and thus should not be used for other purposes.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::removeResource(int n) " /** * Removes an attribute with the given index from this {@link XMLAttributes} set. *

* @param n an integer the index of the resource to be deleted */ public"; %javamethodmodifiers XMLAttributes::remove(int n) " /** * Removes an attribute with the given index from this {@link XMLAttributes} set. * (This function is an alias of XMLAttributes.removeResource() ). *

* @param n an integer the index of the resource to be deleted */ public"; %javamethodmodifiers XMLAttributes::remove(const std::string& name, const std::string& uri = "") " /** * Removes an attribute with the given local name and namespace URI from * this {@link XMLAttributes} set. *

* @param name a string, the local name of the attribute. * @param uri a string, the namespace URI of the attribute. */ public"; %javamethodmodifiers XMLAttributes::remove(const XMLTriple& triple) " /** * Removes an attribute with the given {@link XMLTriple} from this {@link XMLAttributes} set. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. */ public"; %javamethodmodifiers XMLAttributes::clear " /** * Clears (deletes) all attributes in this {@link XMLAttributes} object. */ public"; %javamethodmodifiers XMLAttributes::getIndex(const std::string& name) const " /** * Return the index of an attribute with the given name. *

* @note A namespace bound to the name is not checked by this function. * Thus, if there are multiple attributes with the given local name and * different namespaces, the smallest index among those attributes will * be returned. {@link XMLAttributes#getIndex(String name, String uri)} or * {@link XMLAttributes#getIndex(XMLTriple triple)} should be used to get an index of an * attribute with the given local name and namespace. *

* @param name a string, the local name of the attribute for which the * index is required. *

* @return the index of an attribute with the given local name, or -1 if not present. */ public"; %javamethodmodifiers XMLAttributes::getIndex(const std::string& name, const std::string& uri) const " /** * Return the index of an attribute with the given local name and namespace URI. *

* @param name a string, the local name of the attribute. * @param uri a string, the namespace URI of the attribute. *

* @return the index of an attribute with the given local name and namespace URI, * or -1 if not present. */ public"; %javamethodmodifiers XMLAttributes::getIndex(const XMLTriple& triple) const " /** * Return the index of an attribute with the given {@link XMLTriple}. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute for which * the index is required. *

* @return the index of an attribute with the given {@link XMLTriple}, or -1 if not present. */ public"; %javamethodmodifiers XMLAttributes::getLength() const " /** * Return the number of attributes in the set. *

* @return the number of attributes in this {@link XMLAttributes} set. */ public"; %javamethodmodifiers XMLAttributes::getName(int index) const " /** * Return the local name of an attribute in this {@link XMLAttributes} set (by position). *

* @param index an integer, the position of the attribute whose local name is * required. *

* @return the local name of an attribute in this list (by position). *

* @note If index is out of range, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(int index)} to test for the attribute * existence. */ public"; %javamethodmodifiers XMLAttributes::getPrefix(int index) const " /** * Return the prefix of an attribute in this {@link XMLAttributes} set (by position). *

* @param index an integer, the position of the attribute whose prefix is * required. *

* @return the namespace prefix of an attribute in this list (by * position). *

* @note If index is out of range, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(int index)} to test for the attribute * existence. */ public"; %javamethodmodifiers XMLAttributes::getPrefixedName(int index) const " /** * Return the prefixed name of an attribute in this {@link XMLAttributes} set (by position). *

* @param index an integer, the position of the attribute whose prefixed * name is required. *

* @return the prefixed name of an attribute in this list (by * position). *

* @note If index is out of range, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(int index)} to test for attribute existence. */ public"; %javamethodmodifiers XMLAttributes::getURI(int index) const " /** * Return the namespace URI of an attribute in this {@link XMLAttributes} set (by position). *

* @param index an integer, the position of the attribute whose namespace URI is * required. *

* @return the namespace URI of an attribute in this list (by position). *

* @note If index is out of range, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(int index)} to test for attribute existence. */ public"; %javamethodmodifiers XMLAttributes::getValue(int index) const " /** * Return the value of an attribute in this {@link XMLAttributes} set (by position). *

* @param index an integer, the position of the attribute whose value is * required. *

* @return the value of an attribute in the list (by position). *

* @note If index is out of range, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(int index)} to test for attribute existence. */ public"; %javamethodmodifiers XMLAttributes::getValue(const std::string name) const " /** * Return an attribute\'s value by name. *

* @param name a string, the local name of the attribute whose value is required. *

* @return The attribute value as a string. *

* @note If an attribute with the given local name does not exist, an * empty string will be returned. Use {@link XMLAttributes#hasAttribute(String name, String uri)} * to test for attribute existence. A namespace bound to the local name * is not checked by this function. Thus, if there are multiple * attributes with the given local name and different namespaces, the * value of an attribute with the smallest index among those attributes * will be returned. {@link XMLAttributes#getValue(String name)} or * {@link XMLAttributes#getValue(XMLTriple triple)} should be used to get a value of an * attribute with the given local name and namespace. */ public"; %javamethodmodifiers XMLAttributes::getValue(const std::string name, const std::string uri) const " /** * Return a value of an attribute with the given local name and namespace URI. *

* @param name a string, the local name of the attribute whose value is required. * @param uri a string, the namespace URI of the attribute. *

* @return The attribute value as a string. *

* @note If an attribute with the given local name and namespace URI does * not exist, an empty string will be returned. Use * {@link XMLAttributes#hasAttribute(String name, String uri)} * to test for attribute existence. */ public"; %javamethodmodifiers XMLAttributes::getValue(const XMLTriple& triple) const " /** * Return a value of an attribute with the given {@link XMLTriple}. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute whose * value is required. *

* @return The attribute value as a string. *

* @note If an attribute with the given {@link XMLTriple} does not exist, an * empty string will be returned. Use * {@link XMLAttributes#hasAttribute(XMLTriple triple)} to test for attribute existence. */ public"; %javamethodmodifiers XMLAttributes::hasAttribute(int index) const " /** * Predicate returning true or false depending on whether * an attribute with the given index exists in this {@link XMLAttributes}. *

* @param index an integer, the position of the attribute. *

* @return true if an attribute with the given index exists in this * {@link XMLAttributes}, false otherwise. */ public"; %javamethodmodifiers XMLAttributes::hasAttribute(const std::string name, const std::string uri="") const " /** * Predicate returning true or false depending on whether * an attribute with the given local name and namespace URI exists in this * {@link XMLAttributes}. *

* @param name a string, the local name of the attribute. * @param uri a string, the namespace URI of the attribute. *

* @return true if an attribute with the given local name and namespace * URI exists in this {@link XMLAttributes}, false otherwise. */ public"; %javamethodmodifiers XMLAttributes::hasAttribute(const XMLTriple& triple) const " /** * Predicate returning true or false depending on whether * an attribute with the given XML triple exists in this {@link XMLAttributes}. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute *

* @return true if an attribute with the given XML triple exists in this * {@link XMLAttributes}, false otherwise. *

*/ public"; %javamethodmodifiers XMLAttributes::isEmpty() const " /** * Predicate returning true or false depending on whether * this {@link XMLAttributes} set is empty. *

* @return true if this {@link XMLAttributes} set is empty, false otherwise. */ public"; %javamethodmodifiers XMLAttributes::readInto( const std::string& name , bool& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute name into value. If the given local * name was not found or value could be interpreted as a boolean, value * is not modified. *

* According to the W3C XML Schema, valid boolean values are: \'true\', * \'false\', \'1\', and \'0\' (case-insensitive). For more information, see: * http://www.w3.org/TR/xmlschema-2/#boolean *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param name a string, the local name of the attribute. * @param value a boolean, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, bool&, ...)} should * be used to read a value for an attribute name with a prefix and * namespace. *

* According to the W3C XML Schema, valid boolean values are: \'true\', * \'false\', \'1\', and \'0\' (case-insensitive). For more information, see: * http://www.w3.org/TR/xmlschema-2/#boolean *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a boolean, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* According to the W3C XML Schema, valid doubles are the same as valid * doubles for C and the special values \'INF\', \'-INF\', and \'NaN\' * (case-sensitive). For more information, see: * http://www.w3.org/TR/xmlschema-2/#double *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param name a string, the local name of the attribute. * @param value a double, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, double&, ...)} * should be used to read a value for an attribute name with a prefix and * namespace. *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a double, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a long. For more information, * see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param name a string, the local name of the attribute. * @param value a long, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, long&, ...)} should * be used to read a value for an attribute name with a prefix and * namespace. *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a long, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a int. For more information, * see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param name a string, the local name of the attribute. * @param value an integer, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, int&, ...)} should * be used to read a value for an attribute name with a prefix and * namespace. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a int. For more information, * see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value an integer, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a long. For more * information, see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param name a string, the local name of the attribute. * @param value a long integereger, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, long&, * ...)} should be used to read a value for an attribute name with a * prefix and namespace. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a long. For more * information, see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a long integereger, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* If an {@link XMLErrorLog} is passed in and required is true, missing * attributes are logged. *

* @param name a string, the local name of the attribute. * @param value a string, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @note A namespace bound to the given local name is not checked by this * function. {@link XMLAttributes#readInto(const {@link XMLTriple}, std.string&, ...)} * should be used to read a value for an attribute name with a prefix and * namespace. *

* If an {@link XMLErrorLog} is passed in and required is true, missing * attributes are logged. *

* @param triple an {@link XMLTriple}, the XML triple of the attribute. * @param value a string, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise. *

* @param stream XMLOutputStream, stream to which this {@link XMLAttributes} * set is to be written.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::setErrorLog(XMLErrorLog* log) " /** * (Optional) Sets the log used when logging attributeTypeError() and * attributeRequired() errors. *

* @param log the log to use

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::attributeTypeError( const std::string& name , DataType type , XMLErrorLog* log ) const " /** * Logs an attribute datatype error. *

* @param name name of the attribute * @param type the datatype of the attribute value. * @param log the {@link XMLErrorLog} where the error should be logged

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::attributeRequiredError( const std::string& name, XMLErrorLog* log ) const " /** * Logs an error indicating a required attribute was missing. * Used internally. *

* @param name name of the attribute * @param log the {@link XMLErrorLog} where the error should be logged

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto( int index , const std::string& name , bool& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute with the given index into value. * If the attribute was not found or value could be interpreted as a boolean, * value is not modified. *

* According to the W3C XML Schema, valid boolean values are: \'true\', * \'false\', \'1\', and \'0\' (case-insensitive). For more information, see: * http://www.w3.org/TR/xmlschema-2/#boolean *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value a boolean, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto( int index , const std::string& name , double& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute with the given index into value. * If name was not found or value could be interpreted as a double, value * is not modified. *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value a double, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto( int index , const std::string& name , long& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute with the given index into value. * If the attribute was not found or value could be interpreted as a long, * value is not modified. *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value a long, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto( int index , const std::string& name , int& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute with the given index into value. * If the attribute was not found or value could be interpreted as an integer, * value is not modified. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a int. For more information, * see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value an integer, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto " /** * Reads the value for the attribute with the given index into value. * If the attribute was not found or value could be interpreted as an * long, value is not modified. *

* According to the W3C XML Schema valid integers include zero, *all* * positive and *all* negative whole numbers. For practical purposes, we * limit values to what can be stored in a long. For more * information, see: http://www.w3.org/TR/xmlschema-2/#integer *

* If an {@link XMLErrorLog} is passed in datatype format errors are logged. If * required is true, missing attributes are also logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value a long integereger, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *

* @returns true if the attribute was read into value, false otherwise.

* @deprecated libSBML internal */ public"; %javamethodmodifiers XMLAttributes::readInto( int index , const std::string& name , std::string& value , XMLErrorLog* log = 0 , bool required = false ) const " /** * Reads the value for the attribute with the given index into value. * If the attribute was not found, value is not modified. *

* If an {@link XMLErrorLog} is passed in and required is true, missing * attributes are logged. *

* @param index a int, the index of the attribute. * @param name a string, the name of the attribute * (only used for an error message (if error detected)) * @param value a string, the value of the attribute. * @param log an {@link XMLErrorLog}, the error log. * @param required a boolean, indicating whether the attribute is required. *