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—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–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–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}