001/* ----------------------------------------------------------------------------
002 * This file was automatically generated by SWIG (http://www.swig.org).
003 * Version 2.0.11
004 *
005 * Do not make changes to this file unless you know what you are doing--modify
006 * the SWIG interface file instead.
007 * ----------------------------------------------------------------------------- */
008
009package org.sbml.libsbml;
010
011/** 
012 * 
013 * Methods for interacting with Systems Biology Ontology terms.
014 * <p>
015 * <p style='color: #777; font-style: italic'>
016This class of objects is defined by libSBML only and has no direct
017equivalent in terms of SBML components.  This class is not prescribed by
018the SBML specifications, although it is used to implement features
019defined in SBML.
020</p>
021
022 * <p>
023 * The values of 'id' attributes on SBML components allow the components to
024 * be cross-referenced within a model. The values of 'name' attributes on
025 * SBML components provide the opportunity to assign them meaningful labels
026 * suitable for display to humans.  The specific identifiers and labels
027 * used in a model necessarily must be unrestricted by SBML, so that
028 * software and users are free to pick whatever they need.  However, this
029 * freedom makes it more difficult for software tools to determine, without
030 * additional human intervention, the semantics of models more precisely
031 * than the semantics provided by the SBML object classes defined in other
032 * sections of this document.  For example, there is nothing inherent in a
033 * parameter with identifier <code>k</code> that would indicate to a
034 * software tool it is a first-order rate constant (if that's what
035 * <code>k</code> happened to be in some given model).  However, one may
036 * need to convert a model between different representations (e.g.,
037 * Henri-Michaelis-Menten versus elementary steps), or to use it with
038 * different modeling approaches (discrete or continuous).  One may also
039 * need to relate the model components with other description formats such
040 * as SBGN (<a target='_blank'
041 * href='http://www.sbgn.org/'>http://www.sbgn.org/</a>) using deeper
042 * semantics.  Although an advanced software tool <em>might</em> be able to
043 * deduce the semantics of some model components through detailed analysis
044 * of the kinetic rate expressions and other parts of the model, this
045 * quickly becomes infeasible for any but the simplest of models.
046 * <p>
047 * An approach to solving this problem is to associate model components
048 * with terms from carefully curated controlled vocabularies (CVs).  This
049 * is the purpose of the optional 'sboTerm' attribute provided on the SBML
050 * class {@link SBase}.  The 'sboTerm' attribute always refers to terms belonging
051 * to the Systems Biology Ontology (SBO).
052 * <p>
053 * <h2>Use of {@link SBO}</h2>
054 * <p>
055 * Labeling model components with terms from shared controlled vocabularies
056 * allows a software tool to identify each component using identifiers that
057 * are not tool-specific.  An example of where this is useful is the desire
058 * by many software developers to provide users with meaningful names for
059 * reaction rate equations.  Software tools with editing interfaces
060 * frequently provide these names in menus or lists of choices for users.
061 * However, without a standardized set of names or identifiers shared
062 * between developers, a given software package cannot reliably interpret
063 * the names or identifiers of reactions used in models written by other
064 * tools.
065 * <p>
066 * The first solution that might come to mind is to stipulate that certain
067 * common reactions always have the same name (e.g., 'Michaelis-Menten'), but
068 * this is simply impossible to do: not only do humans often disagree on
069 * the names themselves, but it would not allow for correction of errors or
070 * updates to the list of predefined names except by issuing new releases
071 * of the SBML specification&mdash;to say nothing of many other limitations
072 * with this approach.  Moreover, the parameters and variables that appear
073 * in rate expressions also need to be identified in a way that software
074 * tools can interpret mechanically, implying that the names of these
075 * entities would also need to be regulated.
076 * <p>
077 * The Systems Biology Ontology (SBO) provides terms for identifying most
078 * elements of SBML. The relationship implied by an 'sboTerm' on an SBML
079 * model component is <em>is-a</em> between the characteristic of the
080 * component meant to be described by SBO on this element and the SBO
081 * term identified by the value of the 'sboTerm'. By adding SBO term
082 * references on the components of a model, a software tool can provide
083 * additional details using independent, shared vocabularies that can
084 * enable <em>other</em> software tools to recognize precisely what the
085 * component is meant to be.  Those tools can then act on that information.
086 * For example, if the SBO identifier <code>'SBO:0000049'</code> is assigned
087 * to the concept of 'first-order irreversible mass-action kinetics,
088 * continuous framework', and a given {@link KineticLaw} object in a model has an
089 * 'sboTerm' attribute with this value, then regardless of the identifier
090 * and name given to the reaction itself, a software tool could use this to
091 * inform users that the reaction is a first-order irreversible mass-action
092 * reaction.  This kind of reverse engineering of the meaning of reactions
093 * in a model would be difficult to do otherwise, especially for more
094 * complex reaction types.
095 * <p>
096 * The presence of SBO labels on {@link Compartment}, {@link Species}, and {@link Reaction}
097 * objects in SBML can help map those entities to equivalent concepts in
098 * other standards, such as (but not limited to) BioPAX (<a target='_blank'
099 * href='http://www.biopax.org/'>http://www.biopax.org/</a>), PSI-MI (<a
100 * target='_blank'
101 * href='http://www.psidev.info/index.php?q=node/60'>http://www.psidev.info</a>),
102 * or the Systems Biology Graphical Notation (SBGN, <a target='_blank'
103 * href='http://www.sbgn.org/'>http://www.sbgn.org/</a>).  Such mappings
104 * can be used in conversion procedures, or to build interfaces, with SBO
105 * becoming a kind of 'glue' between standards of representation.
106 * <p>
107 * The presence of the label on a kinetic expression can also allow
108 * software tools to make more intelligent decisions about reaction rate
109 * expressions.  For example, an application could recognize certain types
110 * of reaction formulas as being ones it knows how to solve with optimized
111 * procedures.  The application could then use internal, optimized code
112 * implementing the rate formula indexed by identifiers such as
113 * <code>'SBO:0000049'</code> appearing in SBML models.
114 * <p>
115 * Finally, SBO labels may be very valuable when it comes to model
116 * integration, by helping identify interfaces, convert mathematical
117 * expressions and parameters etc.
118 * <p>
119 * Although the use of SBO can be beneficial, it is critical to keep in
120 * mind that the presence of an 'sboTerm' value on an object <em>must not
121 * change the fundamental mathematical meaning</em> of the model.  An SBML
122 * model must be defined such that it stands on its own and does not depend
123 * on additional information added by SBO terms for a correct mathematical
124 * interpretation.  SBO term definitions will not imply any alternative
125 * mathematical semantics for any SBML object labeled with that term.  Two
126 * important reasons motivate this principle.  First, it would be too
127 * limiting to require all software tools to be able to understand the SBO
128 * vocabularies in addition to understanding SBML.  Supporting SBO is not
129 * only additional work for the software developer; for some kinds of
130 * applications, it may not make sense.  If SBO terms on a model are
131 * optional, it follows that the SBML model <em>must</em> remain
132 * unambiguous and fully interpretable without them, because an application
133 * reading the model may ignore the terms.  Second, we believe allowing the
134 * use of 'sboTerm' to alter the mathematical meaning of a model would
135 * allow too much leeway to shoehorn inconsistent concepts into SBML
136 * objects, ultimately reducing the interoperability of the models.
137 * <p>
138 * <h2>Relationships between {@link SBO} and SBML</h2>
139 * <p>
140 * The goal of SBO labeling for SBML is to clarify to the fullest extent
141 * possible the nature of each element in a model.  The approach taken in
142 * SBO begins with a hierarchically-structured set of controlled
143 * vocabularies with six main divisions: (1) entity, (2) participant role,
144 * (3) quantitative parameter, (4) modeling framework, (5) mathematical
145 * expression, and (6) interaction.  The web site for SBO (<a
146 * target='_blank'
147 * href='http://biomodels.net/sbo'>http://biomodels.net</a>) should be
148 * consulted for the current version of the ontology.
149 * <p>
150 * The Systems Biology Ontology (SBO) is not part of SBML; it is being
151 * developed separately, to allow the modeling community to evolve the
152 * ontology independently of SBML.  However, the terms in the ontology are
153 * being designed keeping SBML components in mind, and are classified into
154 * subsets that can be directly related with SBML components such as
155 * reaction rate expressions, parameters, and others.  The use of 'sboTerm'
156 * attributes is optional, and the presence of 'sboTerm' on an element does
157 * not change the way the model is <em>interpreted</em>.  Annotating SBML
158 * elements with SBO terms adds additional semantic information that may
159 * be used to <em>convert</em> the model into another model, or another
160 * format.  Although SBO support provides an important source of
161 * information to understand the meaning of a model, software does not need
162 * to support 'sboTerm' to be considered SBML-compliant.
163 * <p>
164 */
165
166public class SBO {
167   private long swigCPtr;
168   protected boolean swigCMemOwn;
169
170   protected SBO(long cPtr, boolean cMemoryOwn)
171   {
172     swigCMemOwn = cMemoryOwn;
173     swigCPtr    = cPtr;
174   }
175
176   protected static long getCPtr(SBO obj)
177   {
178     return (obj == null) ? 0 : obj.swigCPtr;
179   }
180
181   protected static long getCPtrAndDisown (SBO obj)
182   {
183     long ptr = 0;
184
185     if (obj != null)
186     {
187       ptr             = obj.swigCPtr;
188       obj.swigCMemOwn = false;
189     }
190
191     return ptr;
192   }
193
194  protected void finalize() {
195    delete();
196  }
197
198  public synchronized void delete() {
199    if (swigCPtr != 0) {
200      if (swigCMemOwn) {
201        swigCMemOwn = false;
202        libsbmlJNI.delete_SBO(swigCPtr);
203      }
204      swigCPtr = 0;
205    }
206  }
207
208  
209/**
210   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
211   * <p>
212   * @return <code>true</code> if <code>term</code> is-a SBO <em>'quantiative parameter'</em>, <code>false</code>
213   * otherwise.
214   * <p>
215   * @note Because this is a <em>static</em> method, the
216   * non-C++ language interfaces for libSBML will contain two variants.  One
217   * will be a static method on the class (i.e., {@link SBO}), and the other will
218   * be a standalone top-level function with the name
219   * SBO_isQuantitativeParameter(). They are functionally identical. 
220   */ public
221 static boolean isQuantitativeParameter(long term) {
222    return libsbmlJNI.SBO_isQuantitativeParameter(term);
223  }
224
225  
226/**
227   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
228   * <p>
229   * @return <code>true</code> if <code>term</code> is-a SBO <em>'participant role'</em>, <code>false</code> otherwise.
230   * <p>
231   * @note Because this is a <em>static</em> method, the
232   * non-C++ language interfaces for libSBML will contain two variants.  One
233   * will be a static method on the class (i.e., {@link SBO}), and the other will
234   * be a standalone top-level function with the name
235   * SBO_isParticipantRole(). They are functionally identical. 
236   */ public
237 static boolean isParticipantRole(long term) {
238    return libsbmlJNI.SBO_isParticipantRole(term);
239  }
240
241  
242/**
243   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
244   * <p>
245   * @return <code>true</code> if <code>term</code> is-a SBO <em>'modeling framework'</em>, <code>false</code> otherwise.
246   * <p>
247   * @note Because this is a <em>static</em> method, the
248   * non-C++ language interfaces for libSBML will contain two variants.  One
249   * will be a static method on the class (i.e., {@link SBO}), and the other will
250   * be a standalone top-level function with the name
251   * SBO_isModellingFramework(). They are functionally identical. 
252   */ public
253 static boolean isModellingFramework(long term) {
254    return libsbmlJNI.SBO_isModellingFramework(term);
255  }
256
257  
258/**
259   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
260   * <p>
261   * @return <code>true</code> if <code>term</code> is-a SBO <em>'mathematical expression'</em>, <code>false</code> otherwise.
262   * <p>
263   * @note Because this is a <em>static</em> method, the
264   * non-C++ language interfaces for libSBML will contain two variants.  One
265   * will be a static method on the class (i.e., {@link SBO}), and the other will
266   * be a standalone top-level function with the name
267   * SBO_isMathematicalExpression(). They are functionally identical. 
268   */ public
269 static boolean isMathematicalExpression(long term) {
270    return libsbmlJNI.SBO_isMathematicalExpression(term);
271  }
272
273  
274/**
275   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
276   * <p>
277   * @return <code>true</code> if <code>term</code> is-a SBO <em>'kinetic constant'</em>, <code>false</code> otherwise.
278   * <p>
279   * @note Because this is a <em>static</em> method, the
280   * non-C++ language interfaces for libSBML will contain two variants.  One
281   * will be a static method on the class (i.e., {@link SBO}), and the other will
282   * be a standalone top-level function with the name
283   * SBO_isKineticConstant(). They are functionally identical. 
284   */ public
285 static boolean isKineticConstant(long term) {
286    return libsbmlJNI.SBO_isKineticConstant(term);
287  }
288
289  
290/**
291   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
292   * <p>
293   * @return <code>true</code> if <code>term</code> is-a SBO <em>'reactant'</em>, <code>false</code> otherwise.
294   * <p>
295   * @note Because this is a <em>static</em> method, the
296   * non-C++ language interfaces for libSBML will contain two variants.  One
297   * will be a static method on the class (i.e., {@link SBO}), and the other will
298   * be a standalone top-level function with the name
299   * SBO_isReactant(). They are functionally identical. 
300   */ public
301 static boolean isReactant(long term) {
302    return libsbmlJNI.SBO_isReactant(term);
303  }
304
305  
306/**
307   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
308   * <p>
309   * @return <code>true</code> if <code>term</code> is-a SBO <em>'product'</em>, <code>false</code> otherwise.
310   * <p>
311   * @note Because this is a <em>static</em> method, the
312   * non-C++ language interfaces for libSBML will contain two variants.  One
313   * will be a static method on the class (i.e., {@link SBO}), and the other will
314   * be a standalone top-level function with the name
315   * SBO_isProduct(). They are functionally identical. 
316   */ public
317 static boolean isProduct(long term) {
318    return libsbmlJNI.SBO_isProduct(term);
319  }
320
321  
322/**
323   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
324   * <p>
325   * @return <code>true</code> if <code>term</code> is-a SBO <em>'modifier'</em>, <code>false</code> otherwise.
326   * <p>
327   * @note Because this is a <em>static</em> method, the
328   * non-C++ language interfaces for libSBML will contain two variants.  One
329   * will be a static method on the class (i.e., {@link SBO}), and the other will
330   * be a standalone top-level function with the name
331   * SBO_isModifier(). They are functionally identical. 
332   */ public
333 static boolean isModifier(long term) {
334    return libsbmlJNI.SBO_isModifier(term);
335  }
336
337  
338/**
339   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
340   * <p>
341   * @return <code>true</code> if <code>term</code> is-a SBO <em>'rate law'</em>, <code>false</code> otherwise.
342   * <p>
343   * @note Because this is a <em>static</em> method, the
344   * non-C++ language interfaces for libSBML will contain two variants.  One
345   * will be a static method on the class (i.e., {@link SBO}), and the other will
346   * be a standalone top-level function with the name
347   * SBO_isRateLaw(). They are functionally identical. 
348   */ public
349 static boolean isRateLaw(long term) {
350    return libsbmlJNI.SBO_isRateLaw(term);
351  }
352
353  
354/**
355   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
356   * <p>
357   * @return <code>true</code> if <code>term</code> is-a SBO <em>'event'</em>, <code>false</code> otherwise.
358   * <p>
359   * @note Because this is a <em>static</em> method, the
360   * non-C++ language interfaces for libSBML will contain two variants.  One
361   * will be a static method on the class (i.e., {@link SBO}), and the other will
362   * be a standalone top-level function with the name
363   * SBO_isEvent(). They are functionally identical. 
364   */ public
365 static boolean isEvent(long term) {
366    return libsbmlJNI.SBO_isEvent(term);
367  }
368
369  
370/**
371    * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
372    * <p>
373    * @return <code>true</code> if <code>term</code> is-a SBO <em>'physical participant</em>, <code>false</code> otherwise.
374   * <p>
375   * @note Because this is a <em>static</em> method, the
376   * non-C++ language interfaces for libSBML will contain two variants.  One
377   * will be a static method on the class (i.e., {@link SBO}), and the other will
378   * be a standalone top-level function with the name
379   * SBO_isPhysicalParticipant(). They are functionally identical. 
380    */ public
381 static boolean isPhysicalParticipant(long term) {
382    return libsbmlJNI.SBO_isPhysicalParticipant(term);
383  }
384
385  
386/**
387    * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
388    * <p>
389    * @return <code>true</code> if <code>term</code> is-a SBO <em>'participant'</em>, <code>false</code> otherwise.
390   * <p>
391   * @note Because this is a <em>static</em> method, the
392   * non-C++ language interfaces for libSBML will contain two variants.  One
393   * will be a static method on the class (i.e., {@link SBO}), and the other will
394   * be a standalone top-level function with the name
395   * SBO_isParticipant(). They are functionally identical. 
396    */ public
397 static boolean isParticipant(long term) {
398    return libsbmlJNI.SBO_isParticipant(term);
399  }
400
401  
402/**
403   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
404   * <p>
405   * @return <code>true</code> if <code>term</code> is-a SBO <em>'interaction'</em>, <code>false</code> otherwise.
406   * <p>
407   * @note Because this is a <em>static</em> method, the
408   * non-C++ language interfaces for libSBML will contain two variants.  One
409   * will be a static method on the class (i.e., {@link SBO}), and the other will
410   * be a standalone top-level function with the name
411   * SBO_isInteraction(). They are functionally identical. 
412   */ public
413 static boolean isInteraction(long term) {
414    return libsbmlJNI.SBO_isInteraction(term);
415  }
416
417  
418/**
419   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
420   * <p>
421   * @return <code>true</code> if <code>term</code> is-a SBO <em>'entity'</em>, <code>false</code> otherwise.
422   * <p>
423   * @note Because this is a <em>static</em> method, the
424   * non-C++ language interfaces for libSBML will contain two variants.  One
425   * will be a static method on the class (i.e., {@link SBO}), and the other will
426   * be a standalone top-level function with the name
427   * SBO_isEntity(). They are functionally identical. 
428   */ public
429 static boolean isEntity(long term) {
430    return libsbmlJNI.SBO_isEntity(term);
431  }
432
433  
434/**
435   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
436   * <p>
437   * @return <code>true</code> if <code>term</code> is-a SBO <em>'functional entity'</em>, <code>false</code> otherwise.
438   * <p>
439   * @note Because this is a <em>static</em> method, the
440   * non-C++ language interfaces for libSBML will contain two variants.  One
441   * will be a static method on the class (i.e., {@link SBO}), and the other will
442   * be a standalone top-level function with the name
443   * SBO_isFunctionalEntity(). They are functionally identical. 
444   */ public
445 static boolean isFunctionalEntity(long term) {
446    return libsbmlJNI.SBO_isFunctionalEntity(term);
447  }
448
449  
450/**
451   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
452   * <p>
453   * @return <code>true</code> if <code>term</code> is-a SBO <em>'material entity'</em>, <code>false</code> otherwise.
454   * <p>
455   * @note Because this is a <em>static</em> method, the
456   * non-C++ language interfaces for libSBML will contain two variants.  One
457   * will be a static method on the class (i.e., {@link SBO}), and the other will
458   * be a standalone top-level function with the name
459   * SBO_isMaterialEntity(). They are functionally identical. 
460   */ public
461 static boolean isMaterialEntity(long term) {
462    return libsbmlJNI.SBO_isMaterialEntity(term);
463  }
464
465  
466/**
467   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
468   * <p>
469   * @return <code>true</code> if <code>term</code> is-a SBO <em>'conservation law'</em>, <code>false</code> otherwise.
470   * <p>
471   * @note Because this is a <em>static</em> method, the
472   * non-C++ language interfaces for libSBML will contain two variants.  One
473   * will be a static method on the class (i.e., {@link SBO}), and the other will
474   * be a standalone top-level function with the name
475   * SBO_isConservationLaw(). They are functionally identical. 
476   */ public
477 static boolean isConservationLaw(long term) {
478    return libsbmlJNI.SBO_isConservationLaw(term);
479  }
480
481  
482/**
483   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
484   * <p>
485   * @return <code>true</code> if <code>term</code> is-a SBO <em>'steady state expression'</em>, <code>false</code> otherwise.
486   * <p>
487   * @note Because this is a <em>static</em> method, the
488   * non-C++ language interfaces for libSBML will contain two variants.  One
489   * will be a static method on the class (i.e., {@link SBO}), and the other will
490   * be a standalone top-level function with the name
491   * SBO_isSteadyStateExpression(). They are functionally identical. 
492   */ public
493 static boolean isSteadyStateExpression(long term) {
494    return libsbmlJNI.SBO_isSteadyStateExpression(term);
495  }
496
497  
498/**
499   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
500   * <p>
501   * @return <code>true</code> if <code>term</code> is-a SBO <em>'functional compartment'</em>, <code>false</code> otherwise.
502   * <p>
503   * @note Because this is a <em>static</em> method, the
504   * non-C++ language interfaces for libSBML will contain two variants.  One
505   * will be a static method on the class (i.e., {@link SBO}), and the other will
506   * be a standalone top-level function with the name
507   * SBO_isFunctionalCompartment(). They are functionally identical. 
508   */ public
509 static boolean isFunctionalCompartment(long term) {
510    return libsbmlJNI.SBO_isFunctionalCompartment(term);
511  }
512
513  
514/**
515   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
516   * <p>
517   * @return <code>true</code> if <code>term</code> is-a SBO <em>'continuous framework'</em>, <code>false</code> otherwise.
518   * <p>
519   * @note Because this is a <em>static</em> method, the
520   * non-C++ language interfaces for libSBML will contain two variants.  One
521   * will be a static method on the class (i.e., {@link SBO}), and the other will
522   * be a standalone top-level function with the name
523   * SBO_isContinuousFramework(). They are functionally identical. 
524   */ public
525 static boolean isContinuousFramework(long term) {
526    return libsbmlJNI.SBO_isContinuousFramework(term);
527  }
528
529  
530/**
531   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
532   * <p>
533   * @return <code>true</code> if <code>term</code> is-a SBO <em>'discrete framework'</em>, <code>false</code> otherwise.
534   * <p>
535   * @note Because this is a <em>static</em> method, the
536   * non-C++ language interfaces for libSBML will contain two variants.  One
537   * will be a static method on the class (i.e., {@link SBO}), and the other will
538   * be a standalone top-level function with the name
539   * SBO_isDiscreteFramework(). They are functionally identical. 
540   */ public
541 static boolean isDiscreteFramework(long term) {
542    return libsbmlJNI.SBO_isDiscreteFramework(term);
543  }
544
545  
546/**
547   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
548   * <p>
549   * @return <code>true</code> if <code>term</code> is-a SBO <em>'logical framework'</em>, <code>false</code> otherwise.
550   * <p>
551   * @note Because this is a <em>static</em> method, the
552   * non-C++ language interfaces for libSBML will contain two variants.  One
553   * will be a static method on the class (i.e., {@link SBO}), and the other will
554   * be a standalone top-level function with the name
555   * SBO_isLogicalFramework(). They are functionally identical. 
556   */ public
557 static boolean isLogicalFramework(long term) {
558    return libsbmlJNI.SBO_isLogicalFramework(term);
559  }
560
561  
562/**
563   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
564   * <p>
565   * @return <code>true</code> if <code>term</code> is-a SBO <em>'metadata representation'</em>, <code>false</code> otherwise.
566   * <p>
567   * @note Because this is a <em>static</em> method, the
568   * non-C++ language interfaces for libSBML will contain two variants.  One
569   * will be a static method on the class (i.e., {@link SBO}), and the other will
570   * be a standalone top-level function with the name
571   * SBO_isMetadataRepresentation(). They are functionally identical. 
572   */ public
573 static boolean isMetadataRepresentation(long term) {
574    return libsbmlJNI.SBO_isMetadataRepresentation(term);
575  }
576
577  
578/**
579   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
580   * <p>
581   * @return <code>true</code> if <code>term</code> is-a SBO <em>'occurring entity representation'</em>, <code>false</code> otherwise.
582   * <p>
583   * @note Because this is a <em>static</em> method, the
584   * non-C++ language interfaces for libSBML will contain two variants.  One
585   * will be a static method on the class (i.e., {@link SBO}), and the other will
586   * be a standalone top-level function with the name
587   * SBO_isOccurringEntityRepresentation(). They are functionally identical. 
588   */ public
589 static boolean isOccurringEntityRepresentation(long term) {
590    return libsbmlJNI.SBO_isOccurringEntityRepresentation(term);
591  }
592
593  
594/**
595   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
596   * <p>
597   * @return <code>true</code> if <code>term</code> is-a SBO <em>'physical entity representation'</em>, <code>false</code> otherwise.
598   * <p>
599   * @note Because this is a <em>static</em> method, the
600   * non-C++ language interfaces for libSBML will contain two variants.  One
601   * will be a static method on the class (i.e., {@link SBO}), and the other will
602   * be a standalone top-level function with the name
603   * SBO_isPhysicalEntityRepresentation(). They are functionally identical. 
604   */ public
605 static boolean isPhysicalEntityRepresentation(long term) {
606    return libsbmlJNI.SBO_isPhysicalEntityRepresentation(term);
607  }
608
609  
610/**
611   * Returns <code>true</code> if the given term identifier comes from the stated branch of SBO.
612   * <p>
613   * @return <code>true</code> if <code>term</code> is-a SBO <em>'systems description parameter'</em>, <code>false</code> otherwise.
614   * <p>
615   * @note Because this is a <em>static</em> method, the
616   * non-C++ language interfaces for libSBML will contain two variants.  One
617   * will be a static method on the class (i.e., {@link SBO}), and the other will
618   * be a standalone top-level function with the name
619   * SBO_isSystemsDescriptionParameter(). They are functionally identical. 
620   */ public
621 static boolean isSystemsDescriptionParameter(long term) {
622    return libsbmlJNI.SBO_isSystemsDescriptionParameter(term);
623  }
624
625  
626/**
627   * Predicate for checking whether the given term is obsolete.
628   * <p>
629   * @return <code>true</code> if <code>term</code> is-a SBO <em>'obsolete'</em> term, <code>false</code> otherwise.
630   * <p>
631   * @note Because this is a <em>static</em> method, the
632   * non-C++ language interfaces for libSBML will contain two variants.  One
633   * will be a static method on the class (i.e., {@link SBO}), and the other will
634   * be a standalone top-level function with the name
635   * SBO_isObselete(). They are functionally identical. 
636   */ public
637 static boolean isObselete(long term) {
638    return libsbmlJNI.SBO_isObselete(term);
639  }
640
641  
642/**
643   * Returns the integer as a correctly formatted SBO identifier string.
644   * <p>
645   * @return the given integer sboTerm as a zero-padded seven digit string.
646   * <p>
647   * @note If the sboTerm is not in the correct range
648   * (0000000&ndash;9999999), an empty string is returned.
649   * <p>
650   * @note Because this is a <em>static</em> method, the
651   * non-C++ language interfaces for libSBML will contain two variants.  One
652   * will be a static method on the class (i.e., {@link SBO}), and the other will
653   * be a standalone top-level function with the name
654   * SBO_intToString(). They are functionally identical. 
655   */ public
656 static String intToString(int sboTerm) {
657    return libsbmlJNI.SBO_intToString(sboTerm);
658  }
659
660  
661/**
662   * Returns the string as a correctly formatted SBO integer portion.
663   * <p>
664   * @return the given string sboTerm as an integer.  If the sboTerm is not
665   * in the correct format (a zero-padded, seven digit string), <code>-1</code> is
666   * returned.
667   * <p>
668   * @note Because this is a <em>static</em> method, the
669   * non-C++ language interfaces for libSBML will contain two variants.  One
670   * will be a static method on the class (i.e., {@link SBO}), and the other will
671   * be a standalone top-level function with the name
672   * SBO_stringToInt(). They are functionally identical. 
673   */ public
674 static int stringToInt(String sboTerm) {
675    return libsbmlJNI.SBO_stringToInt(sboTerm);
676  }
677
678  
679/**
680   * Checks the format of the given SBO identifier string.
681   * <p>
682   * @return <code>true</code> if sboTerm is in the correct format (a zero-padded, seven
683   * digit string), <code>false</code> otherwise.
684   * <p>
685   * @note Because this is a <em>static</em> method, the
686   * non-C++ language interfaces for libSBML will contain two variants.  One
687   * will be a static method on the class (i.e., {@link SBO}), and the other will
688   * be a standalone top-level function with the name
689   * SBO_checkTerm(). They are functionally identical. 
690   */ public
691 static boolean checkTerm(String sboTerm) {
692    return libsbmlJNI.SBO_checkTerm__SWIG_0(sboTerm);
693  }
694
695  
696/**
697   * Checks the format of the given SBO identifier, given in the form of
698   * the integer portion alone.
699   * <p>
700   * @return <code>true</code> if sboTerm is in the range (0000000&ndash;9999999), <code>false</code>
701   * otherwise.
702   * <p>
703   * @note Because this is a <em>static</em> method, the
704   * non-C++ language interfaces for libSBML will contain two variants.  One
705   * will be a static method on the class (i.e., {@link SBO}), and the other will
706   * be a standalone top-level function with the name
707   * SBO_checkTerm(). They are functionally identical. 
708   */ public
709 static boolean checkTerm(int sboTerm) {
710    return libsbmlJNI.SBO_checkTerm__SWIG_1(sboTerm);
711  }
712
713  public SBO() {
714    this(libsbmlJNI.new_SBO(), true);
715  }
716
717}