001/* ---------------------------------------------------------------------------- 002 * This file was automatically generated by SWIG (http://www.swig.org). 003 * Version 3.0.12 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 * <span class="pkg-marker pkg-color-fbc"><a href="group__fbc.html">fbc</a></span> 013 {@link Association} between gene products and reactions 014 <p> 015 * In Version 2 of the SBML Level 3 <a href='../../../extensions-summary.html#fbc'>Flux Balance Constraints</a> (“fbc”) 016 * package specification, {@link GeneProductAssociation} is a class derived from 017 * {@link SBase} used to associate one more genes or gene products with reactions. 018 * {@link GeneProductAssociation} objects are essentially containers, with one such 019 * container optionally attached as a subelement to a {@link Reaction} object in a 020 * model. The container can contain one of three kinds of objects, all of 021 * which are subclasses of the libSBML parent class {@link FbcAssociation}. (Note 022 * that this class is named <em>Association</em> in the “fbc” 023 * Version 2 specification, but in libSBML is named {@link FbcAssociation} to 024 * avoid a name conflict with an existing class.) 025 <p> 026 * One of the kinds of {@link FbcAssociation} subclasses that can appear in a 027 * {@link GeneProductAssociation} is {@link GeneProductRef}. This class of objects 028 * references a {@link GeneProduct} declared in a {@link ListOfGeneProducts} attached to the 029 * enclosing {@link Model} object. In the “fbc” approach, when more than 030 * one gene (or gene product) is present in an association, they are written 031 * as logical expressions using Boolean logical operators <em>and</em> and 032 * <em>or</em> through the classes (in libSBML) {@link FbcAnd} and {@link FbcOr}. (In the 033 * “fbc” Version 2 specification, these are simply named 034 * <em>And</em> and <em>Or</em>, respectively.) The {@link FbcAnd} and {@link FbcOr} objects 035 * in turn can contain either {@link GeneProductRef} objects or other {@link FbcAnd} and/or 036 * {@link FbcOr} objects. 037 <p> 038 * Here is a concrete example of what the XML representation of a simple 039 * <em>or</em> relationship might look like: 040<pre class='fragment'> 041<reaction id = 'R_ABTA' <span class='regular-text' style='font-weight: normal; font-style: italic; background-color: #ffd; padding-left: 2px; padding-right: 2px'>... rest of {@link Reaction} declaration elided for this example ...</span>> 042 <fbc:geneProductAssociation fbc:id='ga_16'> 043 <fbc:or> 044 <fbc:geneProductRef fbc:geneProduct='g_b2662'/> 045 <fbc:geneProductRef fbc:geneProduct='g_b1302'/> 046 </fbc:or> 047 </fbc:geneProductAssociationgt; 048</reaction> 049</pre> 050 <p> 051 * <p> 052 * @note This class of objects was introduced in Version 2 of the 053 * SBML Level 3 Flux Balance Constraints (“fbc”) 054 * specification. In Version 1 of “fbc”, the information 055 * encoded by this class can be stored instead using the {@link Association} and 056 * {@link GeneAssociation} annotation classes. Please see the Version 1 and 057 * Version 2 “fbc” specifications for more details. 058 */ 059 060public class GeneProductAssociation extends SBase { 061 private long swigCPtr; 062 063 protected GeneProductAssociation(long cPtr, boolean cMemoryOwn) 064 { 065 super(libsbmlJNI.GeneProductAssociation_SWIGUpcast(cPtr), cMemoryOwn); 066 swigCPtr = cPtr; 067 } 068 069 protected static long getCPtr(GeneProductAssociation obj) 070 { 071 return (obj == null) ? 0 : obj.swigCPtr; 072 } 073 074 protected static long getCPtrAndDisown (GeneProductAssociation obj) 075 { 076 long ptr = 0; 077 078 if (obj != null) 079 { 080 ptr = obj.swigCPtr; 081 obj.swigCMemOwn = false; 082 } 083 084 return ptr; 085 } 086 087 protected void finalize() { 088 delete(); 089 } 090 091 public synchronized void delete() { 092 if (swigCPtr != 0) { 093 if (swigCMemOwn) { 094 swigCMemOwn = false; 095 libsbmlJNI.delete_GeneProductAssociation(swigCPtr); 096 } 097 swigCPtr = 0; 098 } 099 super.delete(); 100 } 101 102 103/** 104 * Creates a new {@link GeneProductAssociation} with the given SBML Level, Version, and 105 * “fbc” package version. 106 <p> 107 * @param level a long integer, the SBML Level to assign to this 108 * {@link GeneProductAssociation}. 109 <p> 110 * @param version a long integer, the SBML Version to assign to this 111 * {@link GeneProductAssociation}. 112 <p> 113 * @param pkgVersion a long integer, the SBML “fbc” Version to 114 * assign to this {@link GeneProductAssociation} object. 115 <p> 116 * <p> 117 * @note Attempting to add an object to an {@link SBMLDocument} having a different 118 * combination of SBML Level, Version and XML namespaces than the object 119 * itself will result in an error at the time a caller attempts to make the 120 * addition. A parent object must have compatible Level, Version and XML 121 * namespaces. (Strictly speaking, a parent may also have more XML 122 * namespaces than a child, but the reverse is not permitted.) The 123 * restriction is necessary to ensure that an SBML model has a consistent 124 * overall structure. This requires callers to manage their objects 125 * carefully, but the benefit is increased flexibility in how models can be 126 * created by permitting callers to create objects bottom-up if desired. In 127 * situations where objects are not yet attached to parents (e.g., 128 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 129 * libSBML determine such things as whether it is valid to assign a 130 * particular value to an attribute. For packages, this means that the 131 * parent object to which this package element is being added must have 132 * been created with the package namespace, or that the package namespace 133 * was added to it, even if that parent is not a package object itself. 134 */ public 135 GeneProductAssociation(long level, long version, long pkgVersion) throws org.sbml.libsbml.SBMLConstructorException { 136 this(libsbmlJNI.new_GeneProductAssociation__SWIG_0(level, version, pkgVersion), true); 137 } 138 139 140/** 141 * Creates a new {@link GeneProductAssociation} with the given SBML Level, Version, and 142 * “fbc” package version. 143 <p> 144 * @param level a long integer, the SBML Level to assign to this 145 * {@link GeneProductAssociation}. 146 <p> 147 * @param version a long integer, the SBML Version to assign to this 148 * {@link GeneProductAssociation}. 149 <p> 150 * @param pkgVersion a long integer, the SBML “fbc” Version to 151 * assign to this {@link GeneProductAssociation} object. 152 <p> 153 * <p> 154 * @note Attempting to add an object to an {@link SBMLDocument} having a different 155 * combination of SBML Level, Version and XML namespaces than the object 156 * itself will result in an error at the time a caller attempts to make the 157 * addition. A parent object must have compatible Level, Version and XML 158 * namespaces. (Strictly speaking, a parent may also have more XML 159 * namespaces than a child, but the reverse is not permitted.) The 160 * restriction is necessary to ensure that an SBML model has a consistent 161 * overall structure. This requires callers to manage their objects 162 * carefully, but the benefit is increased flexibility in how models can be 163 * created by permitting callers to create objects bottom-up if desired. In 164 * situations where objects are not yet attached to parents (e.g., 165 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 166 * libSBML determine such things as whether it is valid to assign a 167 * particular value to an attribute. For packages, this means that the 168 * parent object to which this package element is being added must have 169 * been created with the package namespace, or that the package namespace 170 * was added to it, even if that parent is not a package object itself. 171 */ public 172 GeneProductAssociation(long level, long version) throws org.sbml.libsbml.SBMLConstructorException { 173 this(libsbmlJNI.new_GeneProductAssociation__SWIG_1(level, version), true); 174 } 175 176 177/** 178 * Creates a new {@link GeneProductAssociation} with the given SBML Level, Version, and 179 * “fbc” package version. 180 <p> 181 * @param level a long integer, the SBML Level to assign to this 182 * {@link GeneProductAssociation}. 183 <p> 184 * @param version a long integer, the SBML Version to assign to this 185 * {@link GeneProductAssociation}. 186 <p> 187 * @param pkgVersion a long integer, the SBML “fbc” Version to 188 * assign to this {@link GeneProductAssociation} object. 189 <p> 190 * <p> 191 * @note Attempting to add an object to an {@link SBMLDocument} having a different 192 * combination of SBML Level, Version and XML namespaces than the object 193 * itself will result in an error at the time a caller attempts to make the 194 * addition. A parent object must have compatible Level, Version and XML 195 * namespaces. (Strictly speaking, a parent may also have more XML 196 * namespaces than a child, but the reverse is not permitted.) The 197 * restriction is necessary to ensure that an SBML model has a consistent 198 * overall structure. This requires callers to manage their objects 199 * carefully, but the benefit is increased flexibility in how models can be 200 * created by permitting callers to create objects bottom-up if desired. In 201 * situations where objects are not yet attached to parents (e.g., 202 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 203 * libSBML determine such things as whether it is valid to assign a 204 * particular value to an attribute. For packages, this means that the 205 * parent object to which this package element is being added must have 206 * been created with the package namespace, or that the package namespace 207 * was added to it, even if that parent is not a package object itself. 208 */ public 209 GeneProductAssociation(long level) throws org.sbml.libsbml.SBMLConstructorException { 210 this(libsbmlJNI.new_GeneProductAssociation__SWIG_2(level), true); 211 } 212 213 214/** 215 * Creates a new {@link GeneProductAssociation} with the given SBML Level, Version, and 216 * “fbc” package version. 217 <p> 218 * @param level a long integer, the SBML Level to assign to this 219 * {@link GeneProductAssociation}. 220 <p> 221 * @param version a long integer, the SBML Version to assign to this 222 * {@link GeneProductAssociation}. 223 <p> 224 * @param pkgVersion a long integer, the SBML “fbc” Version to 225 * assign to this {@link GeneProductAssociation} object. 226 <p> 227 * <p> 228 * @note Attempting to add an object to an {@link SBMLDocument} having a different 229 * combination of SBML Level, Version and XML namespaces than the object 230 * itself will result in an error at the time a caller attempts to make the 231 * addition. A parent object must have compatible Level, Version and XML 232 * namespaces. (Strictly speaking, a parent may also have more XML 233 * namespaces than a child, but the reverse is not permitted.) The 234 * restriction is necessary to ensure that an SBML model has a consistent 235 * overall structure. This requires callers to manage their objects 236 * carefully, but the benefit is increased flexibility in how models can be 237 * created by permitting callers to create objects bottom-up if desired. In 238 * situations where objects are not yet attached to parents (e.g., 239 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 240 * libSBML determine such things as whether it is valid to assign a 241 * particular value to an attribute. For packages, this means that the 242 * parent object to which this package element is being added must have 243 * been created with the package namespace, or that the package namespace 244 * was added to it, even if that parent is not a package object itself. 245 */ public 246 GeneProductAssociation() throws org.sbml.libsbml.SBMLConstructorException { 247 this(libsbmlJNI.new_GeneProductAssociation__SWIG_3(), true); 248 } 249 250 251/** 252 * Creates a new {@link GeneProductAssociation} with the given {@link FbcPkgNamespaces} 253 * object. 254 <p> 255 * <p> 256 * The package namespaces object used in this constructor is derived from a 257 * {@link SBMLNamespaces} object, which encapsulates SBML Level/Version/namespaces 258 * information. It is used to communicate the SBML Level, Version, and 259 * package version and name information used in addition to SBML Level 3 Core. A 260 * common approach to using libSBML's {@link SBMLNamespaces} facilities is to create an 261 * package namespace object somewhere in a program once, then hand that object 262 * as needed to object constructors of that package that accept it as and 263 * argument, such as this one. 264 <p> 265 * @param fbcns the {@link FbcPkgNamespaces} object. 266 <p> 267 * <p> 268 * @note Attempting to add an object to an {@link SBMLDocument} having a different 269 * combination of SBML Level, Version and XML namespaces than the object 270 * itself will result in an error at the time a caller attempts to make the 271 * addition. A parent object must have compatible Level, Version and XML 272 * namespaces. (Strictly speaking, a parent may also have more XML 273 * namespaces than a child, but the reverse is not permitted.) The 274 * restriction is necessary to ensure that an SBML model has a consistent 275 * overall structure. This requires callers to manage their objects 276 * carefully, but the benefit is increased flexibility in how models can be 277 * created by permitting callers to create objects bottom-up if desired. In 278 * situations where objects are not yet attached to parents (e.g., 279 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 280 * libSBML determine such things as whether it is valid to assign a 281 * particular value to an attribute. For packages, this means that the 282 * parent object to which this package element is being added must have 283 * been created with the package namespace, or that the package namespace 284 * was added to it, even if that parent is not a package object itself. 285 */ public 286 GeneProductAssociation(FbcPkgNamespaces fbcns) throws org.sbml.libsbml.SBMLConstructorException { 287 this(libsbmlJNI.new_GeneProductAssociation__SWIG_4(FbcPkgNamespaces.getCPtr(fbcns), fbcns), true); 288 } 289 290 291/** 292 * Copy constructor for {@link GeneProductAssociation}. 293 <p> 294 * @param orig the {@link GeneProductAssociation} instance to copy. 295 */ public 296 GeneProductAssociation(GeneProductAssociation orig) throws org.sbml.libsbml.SBMLConstructorException { 297 this(libsbmlJNI.new_GeneProductAssociation__SWIG_5(GeneProductAssociation.getCPtr(orig), orig), true); 298 } 299 300 301/** 302 * Creates and returns a deep copy of this {@link GeneProductAssociation} object. 303 <p> 304 * @return a (deep) copy of this {@link GeneProductAssociation} object. 305 */ public 306 GeneProductAssociation cloneObject() { 307 long cPtr = libsbmlJNI.GeneProductAssociation_cloneObject(swigCPtr, this); 308 return (cPtr == 0) ? null : new GeneProductAssociation(cPtr, true); 309 } 310 311 312/** 313 * Returns the value of the 'id' attribute of this {@link GeneProductAssociation}. 314 <p> 315 * @note Because of the inconsistent behavior of this function with 316 * respect to assignments and rules, it is now recommended to 317 * use the getIdAttribute() function instead. 318 <p> 319 * <p> 320 * The identifier given by an object's 'id' attribute value 321 * is used to identify the object within the SBML model definition. 322 * Other objects can refer to the component using this identifier. The 323 * data type of 'id' is always <code>SId</code> or a type derived 324 * from that, such as <code>UnitSId</code>, depending on the object in 325 * question. All data types are defined as follows: 326 * <pre style='margin-left: 2em; border: none; font-weight: bold; color: black'> 327 * letter .= 'a'..'z','A'..'Z' 328 * digit .= '0'..'9' 329 * idChar .= letter | digit | '_' 330 * SId .= ( letter | '_' ) idChar* 331 * </pre> 332 <p> 333 * The characters <code>(</code> and <code>)</code> are used for grouping, the 334 * character <code>*</code> 'zero or more times', and the character 335 * <code>|</code> indicates logical 'or'. The equality of SBML identifiers is 336 * determined by an exact character sequence match; i.e., comparisons must be 337 * performed in a case-sensitive manner. This applies to all uses of <code>SId</code>, 338 * <code>SIdRef</code>, and derived types. 339 <p> 340 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 341 * moved to {@link SBase} directly, instead of being defined individually for many 342 * (but not all) objects. Libsbml has for a long time provided functions 343 * defined on {@link SBase} itself to get, set, check, and unset those attributes, which 344 * would fail or otherwise return empty strings if executed on any object 345 * for which those attributes were not defined. Now that all {@link SBase} objects 346 * define those attributes, those functions now succeed for any object with 347 * the appropriate level and version. 348 <p> 349 * The exception to this rule is that for {@link InitialAssignment}, {@link EventAssignment}, 350 * {@link AssignmentRule}, and {@link RateRule} objects, the getId() function and the isSetId() 351 * functions (though not the setId() or unsetId() functions) would instead 352 * reference the value of the 'variable' attribute (for the rules and event 353 * assignments) or the 'symbol' attribute (for initial assignments). 354 * The {@link AlgebraicRule} fell into this category as well, though because it 355 * contained neither a 'variable' nor a 'symbol' attribute, getId() would 356 * always return an empty string, and isSetId() would always return <code>false.</code> 357 * For this reason, four new functions are now provided 358 * (getIdAttribute(), setIdAttribute(String), 359 * isSetIdAttribute(), and unsetIdAttribute()) that will always 360 * act on the actual 'id' attribute, regardless of the object's type. The 361 * new functions should be used instead of the old ones unless the old behavior 362 * is somehow necessary. 363 <p> 364 * Regardless of the level and version of the SBML, these functions allow 365 * client applications to use more generalized code in some situations 366 * (for instance, when manipulating objects that are all known to have 367 * identifiers). If the object in question does not posess an 'id' attribute 368 * according to the SBML specification for the Level and Version in use, 369 * libSBML will not allow the identifier to be set, nor will it read or 370 * write 'id' attributes for those objects. 371 <p> 372 * @return the id of this {@link GeneProductAssociation}. 373 <p> 374 * @see #getIdAttribute() 375 * @see #setIdAttribute(String sid) 376 * @see #isSetIdAttribute() 377 * @see #unsetIdAttribute() 378 */ public 379 String getId() { 380 return libsbmlJNI.GeneProductAssociation_getId(swigCPtr, this); 381 } 382 383 384/** 385 * Returns the value of the 'name' attribute of this {@link GeneProductAssociation} object. 386 <p> 387 * <p> 388 * <p> 389 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 390 * moved to {@link SBase} directly, instead of being defined individually for many 391 * (but not all) objects. Libsbml has for a long time provided functions 392 * defined on {@link SBase} itself to get, set, and unset those attributes, which 393 * would fail or otherwise return empty strings if executed on any object 394 * for which those attributes were not defined. Now that all {@link SBase} objects 395 * define those attributes, those functions now succeed for any object with 396 * the appropriate level and version. 397 <p> 398 * The 'name' attribute is 399 * optional and is not intended to be used for cross-referencing purposes 400 * within a model. Its purpose instead is to provide a human-readable 401 * label for the component. The data type of 'name' is the type 402 * <code>string</code> defined in XML Schema. SBML imposes no 403 * restrictions as to the content of 'name' attributes beyond those 404 * restrictions defined by the <code>string</code> type in XML Schema. 405 <p> 406 * The recommended practice for handling 'name' is as follows. If a 407 * software tool has the capability for displaying the content of 'name' 408 * attributes, it should display this content to the user as a 409 * component's label instead of the component's 'id'. If the user 410 * interface does not have this capability (e.g., because it cannot 411 * display or use special characters in symbol names), or if the 'name' 412 * attribute is missing on a given component, then the user interface 413 * should display the value of the 'id' attribute instead. (Script 414 * language interpreters are especially likely to display 'id' instead of 415 * 'name'.) 416 <p> 417 * As a consequence of the above, authors of systems that automatically 418 * generate the values of 'id' attributes should be aware some systems 419 * may display the 'id''s to the user. Authors therefore may wish to 420 * take some care to have their software create 'id' values that are: (a) 421 * reasonably easy for humans to type and read; and (b) likely to be 422 * meaningful, for example by making the 'id' attribute be an abbreviated 423 * form of the name attribute value. 424 <p> 425 * An additional point worth mentioning is although there are 426 * restrictions on the uniqueness of 'id' values, there are no 427 * restrictions on the uniqueness of 'name' values in a model. This 428 * allows software applications leeway in assigning component identifiers. 429 <p> 430 * Regardless of the level and version of the SBML, these functions allow 431 * client applications to use more generalized code in some situations 432 * (for instance, when manipulating objects that are all known to have 433 * names). If the object in question does not posess a 'name' attribute 434 * according to the SBML specification for the Level and Version in use, 435 * libSBML will not allow the name to be set, nor will it read or 436 * write 'name' attributes for those objects. 437 <p> 438 * @return the name of this SBML object, or the empty string if not set or unsettable. 439 <p> 440 * @see #getIdAttribute() 441 * @see #isSetName() 442 * @see #setName(String sid) 443 * @see #unsetName() 444 */ public 445 String getName() { 446 return libsbmlJNI.GeneProductAssociation_getName(swigCPtr, this); 447 } 448 449 450/** 451 * Returns the 'association' element of this {@link GeneProductAssociation}. 452 <p> 453 * @return the 'association' element of this {@link GeneProductAssociation}. 454 */ public 455 FbcAssociation getAssociation() { 456 return (FbcAssociation) libsbml.DowncastSBase(libsbmlJNI.GeneProductAssociation_getAssociation__SWIG_0(swigCPtr, this), false); 457} 458 459 460/** 461 * Creates a new 'association' and sets it for this {@link GeneProductAssociation}. 462 <p> 463 * @return the {@link FbcAnd} created. 464 */ public 465 FbcAnd createAnd() { 466 long cPtr = libsbmlJNI.GeneProductAssociation_createAnd(swigCPtr, this); 467 return (cPtr == 0) ? null : new FbcAnd(cPtr, false); 468 } 469 470 471/** 472 * Creates a new 'association' and sets it for this {@link GeneProductAssociation}. 473 */ public 474 FbcOr createOr() { 475 long cPtr = libsbmlJNI.GeneProductAssociation_createOr(swigCPtr, this); 476 return (cPtr == 0) ? null : new FbcOr(cPtr, false); 477 } 478 479 480/** 481 * Creates a new 'association' and sets it for this {@link GeneProductAssociation}. 482 */ public 483 GeneProductRef createGeneProductRef() { 484 long cPtr = libsbmlJNI.GeneProductAssociation_createGeneProductRef(swigCPtr, this); 485 return (cPtr == 0) ? null : new GeneProductRef(cPtr, false); 486 } 487 488 489/** 490 * Predicate returning <code>true</code> if this {@link GeneProductAssociation}'s 'id' 491 * attribute is set. 492 <p> 493 * <p> 494 * @note Because of the inconsistent behavior of this function with 495 * respect to assignments and rules, it is now recommended to 496 * use the isSetIdAttribute() function instead. 497 <p> 498 * <p> 499 * The identifier given by an object's 'id' attribute value 500 * is used to identify the object within the SBML model definition. 501 * Other objects can refer to the component using this identifier. The 502 * data type of 'id' is always <code>SId</code> or a type derived 503 * from that, such as <code>UnitSId</code>, depending on the object in 504 * question. All data types are defined as follows: 505 * <pre style='margin-left: 2em; border: none; font-weight: bold; color: black'> 506 * letter .= 'a'..'z','A'..'Z' 507 * digit .= '0'..'9' 508 * idChar .= letter | digit | '_' 509 * SId .= ( letter | '_' ) idChar* 510 * </pre> 511 <p> 512 * The characters <code>(</code> and <code>)</code> are used for grouping, the 513 * character <code>*</code> 'zero or more times', and the character 514 * <code>|</code> indicates logical 'or'. The equality of SBML identifiers is 515 * determined by an exact character sequence match; i.e., comparisons must be 516 * performed in a case-sensitive manner. This applies to all uses of <code>SId</code>, 517 * <code>SIdRef</code>, and derived types. 518 <p> 519 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 520 * moved to {@link SBase} directly, instead of being defined individually for many 521 * (but not all) objects. Libsbml has for a long time provided functions 522 * defined on {@link SBase} itself to get, set, check, and unset those attributes, which 523 * would fail or otherwise return empty strings if executed on any object 524 * for which those attributes were not defined. Now that all {@link SBase} objects 525 * define those attributes, those functions now succeed for any object with 526 * the appropriate level and version. 527 <p> 528 * The exception to this rule is that for {@link InitialAssignment}, {@link EventAssignment}, 529 * {@link AssignmentRule}, and {@link RateRule} objects, the getId() function and the isSetId() 530 * functions (though not the setId() or unsetId() functions) would instead 531 * reference the value of the 'variable' attribute (for the rules and event 532 * assignments) or the 'symbol' attribute (for initial assignments). 533 * The {@link AlgebraicRule} fell into this category as well, though because it 534 * contained neither a 'variable' nor a 'symbol' attribute, getId() would 535 * always return an empty string, and isSetId() would always return <code>false.</code> 536 * For this reason, four new functions are now provided 537 * (getIdAttribute(), setIdAttribute(String), 538 * isSetIdAttribute(), and unsetIdAttribute()) that will always 539 * act on the actual 'id' attribute, regardless of the object's type. The 540 * new functions should be used instead of the old ones unless the old behavior 541 * is somehow necessary. 542 <p> 543 * Regardless of the level and version of the SBML, these functions allow 544 * client applications to use more generalized code in some situations 545 * (for instance, when manipulating objects that are all known to have 546 * identifiers). If the object in question does not posess an 'id' attribute 547 * according to the SBML specification for the Level and Version in use, 548 * libSBML will not allow the identifier to be set, nor will it read or 549 * write 'id' attributes for those objects. 550 <p> 551 * @return <code>true</code> if the 'id' attribute of this SBML object is 552 * set, <code>false</code> otherwise. 553 <p> 554 * @see #getIdAttribute() 555 * @see #setIdAttribute(String sid) 556 * @see #unsetIdAttribute() 557 * @see #isSetIdAttribute() 558 */ public 559 boolean isSetId() { 560 return libsbmlJNI.GeneProductAssociation_isSetId(swigCPtr, this); 561 } 562 563 564/** 565 * Predicate returning <code>true</code> if this {@link GeneProductAssociation}'s 'name' 566 * attribute is set. 567 <p> 568 * <p> 569 * <p> 570 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 571 * moved to {@link SBase} directly, instead of being defined individually for many 572 * (but not all) objects. Libsbml has for a long time provided functions 573 * defined on {@link SBase} itself to get, set, and unset those attributes, which 574 * would fail or otherwise return empty strings if executed on any object 575 * for which those attributes were not defined. Now that all {@link SBase} objects 576 * define those attributes, those functions now succeed for any object with 577 * the appropriate level and version. 578 <p> 579 * The 'name' attribute is 580 * optional and is not intended to be used for cross-referencing purposes 581 * within a model. Its purpose instead is to provide a human-readable 582 * label for the component. The data type of 'name' is the type 583 * <code>string</code> defined in XML Schema. SBML imposes no 584 * restrictions as to the content of 'name' attributes beyond those 585 * restrictions defined by the <code>string</code> type in XML Schema. 586 <p> 587 * The recommended practice for handling 'name' is as follows. If a 588 * software tool has the capability for displaying the content of 'name' 589 * attributes, it should display this content to the user as a 590 * component's label instead of the component's 'id'. If the user 591 * interface does not have this capability (e.g., because it cannot 592 * display or use special characters in symbol names), or if the 'name' 593 * attribute is missing on a given component, then the user interface 594 * should display the value of the 'id' attribute instead. (Script 595 * language interpreters are especially likely to display 'id' instead of 596 * 'name'.) 597 <p> 598 * As a consequence of the above, authors of systems that automatically 599 * generate the values of 'id' attributes should be aware some systems 600 * may display the 'id''s to the user. Authors therefore may wish to 601 * take some care to have their software create 'id' values that are: (a) 602 * reasonably easy for humans to type and read; and (b) likely to be 603 * meaningful, for example by making the 'id' attribute be an abbreviated 604 * form of the name attribute value. 605 <p> 606 * An additional point worth mentioning is although there are 607 * restrictions on the uniqueness of 'id' values, there are no 608 * restrictions on the uniqueness of 'name' values in a model. This 609 * allows software applications leeway in assigning component identifiers. 610 <p> 611 * Regardless of the level and version of the SBML, these functions allow 612 * client applications to use more generalized code in some situations 613 * (for instance, when manipulating objects that are all known to have 614 * names). If the object in question does not posess a 'name' attribute 615 * according to the SBML specification for the Level and Version in use, 616 * libSBML will not allow the name to be set, nor will it read or 617 * write 'name' attributes for those objects. 618 <p> 619 * @return <code>true</code> if the 'name' attribute of this SBML object is 620 * set, <code>false</code> otherwise. 621 <p> 622 * @see #getName() 623 * @see #setName(String sid) 624 * @see #unsetName() 625 */ public 626 boolean isSetName() { 627 return libsbmlJNI.GeneProductAssociation_isSetName(swigCPtr, this); 628 } 629 630 631/** 632 * Predicate returning <code>true</code> if this {@link GeneProductAssociation}'s 633 * 'association' element is set. 634 <p> 635 * @return <code>true</code> if this {@link GeneProductAssociation}'s 'association' element has been set, 636 * otherwise <code>false</code> is returned. 637 */ public 638 boolean isSetAssociation() { 639 return libsbmlJNI.GeneProductAssociation_isSetAssociation(swigCPtr, this); 640 } 641 642 643/** 644 * Sets the value of the 'id' attribute of this {@link GeneProductAssociation}. 645 <p> 646 * <p> 647 * The string <code>sid</code> is copied. 648 <p> 649 * <p> 650 * The identifier given by an object's 'id' attribute value 651 * is used to identify the object within the SBML model definition. 652 * Other objects can refer to the component using this identifier. The 653 * data type of 'id' is always <code>SId</code> or a type derived 654 * from that, such as <code>UnitSId</code>, depending on the object in 655 * question. All data types are defined as follows: 656 * <pre style='margin-left: 2em; border: none; font-weight: bold; color: black'> 657 * letter .= 'a'..'z','A'..'Z' 658 * digit .= '0'..'9' 659 * idChar .= letter | digit | '_' 660 * SId .= ( letter | '_' ) idChar* 661 * </pre> 662 <p> 663 * The characters <code>(</code> and <code>)</code> are used for grouping, the 664 * character <code>*</code> 'zero or more times', and the character 665 * <code>|</code> indicates logical 'or'. The equality of SBML identifiers is 666 * determined by an exact character sequence match; i.e., comparisons must be 667 * performed in a case-sensitive manner. This applies to all uses of <code>SId</code>, 668 * <code>SIdRef</code>, and derived types. 669 <p> 670 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 671 * moved to {@link SBase} directly, instead of being defined individually for many 672 * (but not all) objects. Libsbml has for a long time provided functions 673 * defined on {@link SBase} itself to get, set, check, and unset those attributes, which 674 * would fail or otherwise return empty strings if executed on any object 675 * for which those attributes were not defined. Now that all {@link SBase} objects 676 * define those attributes, those functions now succeed for any object with 677 * the appropriate level and version. 678 <p> 679 * The exception to this rule is that for {@link InitialAssignment}, {@link EventAssignment}, 680 * {@link AssignmentRule}, and {@link RateRule} objects, the getId() function and the isSetId() 681 * functions (though not the setId() or unsetId() functions) would instead 682 * reference the value of the 'variable' attribute (for the rules and event 683 * assignments) or the 'symbol' attribute (for initial assignments). 684 * The {@link AlgebraicRule} fell into this category as well, though because it 685 * contained neither a 'variable' nor a 'symbol' attribute, getId() would 686 * always return an empty string, and isSetId() would always return <code>false.</code> 687 * For this reason, four new functions are now provided 688 * (getIdAttribute(), setIdAttribute(String), 689 * isSetIdAttribute(), and unsetIdAttribute()) that will always 690 * act on the actual 'id' attribute, regardless of the object's type. The 691 * new functions should be used instead of the old ones unless the old behavior 692 * is somehow necessary. 693 <p> 694 * Regardless of the level and version of the SBML, these functions allow 695 * client applications to use more generalized code in some situations 696 * (for instance, when manipulating objects that are all known to have 697 * identifiers). If the object in question does not posess an 'id' attribute 698 * according to the SBML specification for the Level and Version in use, 699 * libSBML will not allow the identifier to be set, nor will it read or 700 * write 'id' attributes for those objects. 701 <p> 702 * @param sid the string to use as the identifier of this object. 703 <p> 704 * <p> 705 * @return integer value indicating success/failure of the 706 * function. The possible values 707 * returned by this function are: 708 * <ul> 709 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 710 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 711 * <li> {@link libsbmlConstants#LIBSBML_UNEXPECTED_ATTRIBUTE LIBSBML_UNEXPECTED_ATTRIBUTE} 712 * 713 * </ul> <p> 714 * @see #getIdAttribute() 715 * @see #setIdAttribute(String sid) 716 * @see #isSetIdAttribute() 717 * @see #unsetIdAttribute() 718 */ public 719 int setId(String sid) { 720 return libsbmlJNI.GeneProductAssociation_setId(swigCPtr, this, sid); 721 } 722 723 724/** 725 * Sets the value of the 'name' attribute of this {@link GeneProductAssociation}. 726 <p> 727 * <p> 728 * The string in <code>name</code> is copied. 729 <p> 730 * @param name the new name for the SBML object. 731 <p> 732 * <p> 733 * @return integer value indicating success/failure of the 734 * function. The possible values 735 * returned by this function are: 736 * <ul> 737 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 738 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 739 * 740 * </ul> 741 */ public 742 int setName(String name) { 743 return libsbmlJNI.GeneProductAssociation_setName(swigCPtr, this, name); 744 } 745 746 747/** 748 * Sets the 'association' element of this {@link GeneProductAssociation}. 749 <p> 750 * @param association {@link FbcAssociation} to be set. 751 <p> 752 * <p> 753 * @return integer value indicating success/failure of the 754 * function. The possible values 755 * returned by this function are: 756 * <ul> 757 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 758 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 759 * </ul> 760 */ public 761 int setAssociation(FbcAssociation association) { 762 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_0(swigCPtr, this, FbcAssociation.getCPtr(association), association); 763 } 764 765 766/** 767 * Sets the 'association' element of this {@link GeneProductAssociation}. 768 <p> 769 * This is a helper method that allows a user to set the 770 * {@link GeneProductAssociation} via a string such as <code>"a1 AND b1 OR 771 * C2"</code> and have the method work out the correct XML structure. 772 <p> 773 * @param association string representation of the association to be set. 774 * @param usingId 775 * @param addMissingGP 776 <p> 777 * @param usingId If <code>true</code>, this method assumes that the infix 778 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If 779 * <code>false</code> (the default), the method assumes that the string uses the label 780 * attributes of {@link GeneProduct} objects. 781 <p> 782 * @param addMissingGP If <code>true</code> (the default), then while 783 * parsing the infix string in <code>association</code>, any identifiers or labels 784 * (depending on <code>usingId</code>) found in the expression that do not correspond 785 * to an existing {@link GeneProduct} object will result in the addition of that 786 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 787 * that circumstance. 788 <p> 789 * <p> 790 * @return integer value indicating success/failure of the 791 * function. The possible values 792 * returned by this function are: 793 * <ul> 794 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 795 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 796 * </ul> 797 */ public 798 int setAssociation(String association, boolean usingId, boolean addMissingGP) { 799 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_1(swigCPtr, this, association, usingId, addMissingGP); 800 } 801 802 803/** 804 * Sets the 'association' element of this {@link GeneProductAssociation}. 805 <p> 806 * This is a helper method that allows a user to set the 807 * {@link GeneProductAssociation} via a string such as <code>"a1 AND b1 OR 808 * C2"</code> and have the method work out the correct XML structure. 809 <p> 810 * @param association string representation of the association to be set. 811 * @param usingId 812 * @param addMissingGP 813 <p> 814 * @param usingId If <code>true</code>, this method assumes that the infix 815 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If 816 * <code>false</code> (the default), the method assumes that the string uses the label 817 * attributes of {@link GeneProduct} objects. 818 <p> 819 * @param addMissingGP If <code>true</code> (the default), then while 820 * parsing the infix string in <code>association</code>, any identifiers or labels 821 * (depending on <code>usingId</code>) found in the expression that do not correspond 822 * to an existing {@link GeneProduct} object will result in the addition of that 823 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 824 * that circumstance. 825 <p> 826 * <p> 827 * @return integer value indicating success/failure of the 828 * function. The possible values 829 * returned by this function are: 830 * <ul> 831 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 832 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 833 * </ul> 834 */ public 835 int setAssociation(String association, boolean usingId) { 836 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_2(swigCPtr, this, association, usingId); 837 } 838 839 840/** 841 * Sets the 'association' element of this {@link GeneProductAssociation}. 842 <p> 843 * This is a helper method that allows a user to set the 844 * {@link GeneProductAssociation} via a string such as <code>"a1 AND b1 OR 845 * C2"</code> and have the method work out the correct XML structure. 846 <p> 847 * @param association string representation of the association to be set. 848 * @param usingId 849 * @param addMissingGP 850 <p> 851 * @param usingId If <code>true</code>, this method assumes that the infix 852 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If 853 * <code>false</code> (the default), the method assumes that the string uses the label 854 * attributes of {@link GeneProduct} objects. 855 <p> 856 * @param addMissingGP If <code>true</code> (the default), then while 857 * parsing the infix string in <code>association</code>, any identifiers or labels 858 * (depending on <code>usingId</code>) found in the expression that do not correspond 859 * to an existing {@link GeneProduct} object will result in the addition of that 860 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 861 * that circumstance. 862 <p> 863 * <p> 864 * @return integer value indicating success/failure of the 865 * function. The possible values 866 * returned by this function are: 867 * <ul> 868 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 869 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 870 * </ul> 871 */ public 872 int setAssociation(String association) { 873 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_3(swigCPtr, this, association); 874 } 875 876 877/** 878 * Unsets the value of the 'id' attribute of this {@link GeneProductAssociation}. 879 <p> 880 * <p> 881 * <p> 882 * The identifier given by an object's 'id' attribute value 883 * is used to identify the object within the SBML model definition. 884 * Other objects can refer to the component using this identifier. The 885 * data type of 'id' is always <code>SId</code> or a type derived 886 * from that, such as <code>UnitSId</code>, depending on the object in 887 * question. All data types are defined as follows: 888 * <pre style='margin-left: 2em; border: none; font-weight: bold; color: black'> 889 * letter .= 'a'..'z','A'..'Z' 890 * digit .= '0'..'9' 891 * idChar .= letter | digit | '_' 892 * SId .= ( letter | '_' ) idChar* 893 * </pre> 894 <p> 895 * The characters <code>(</code> and <code>)</code> are used for grouping, the 896 * character <code>*</code> 'zero or more times', and the character 897 * <code>|</code> indicates logical 'or'. The equality of SBML identifiers is 898 * determined by an exact character sequence match; i.e., comparisons must be 899 * performed in a case-sensitive manner. This applies to all uses of <code>SId</code>, 900 * <code>SIdRef</code>, and derived types. 901 <p> 902 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 903 * moved to {@link SBase} directly, instead of being defined individually for many 904 * (but not all) objects. Libsbml has for a long time provided functions 905 * defined on {@link SBase} itself to get, set, check, and unset those attributes, which 906 * would fail or otherwise return empty strings if executed on any object 907 * for which those attributes were not defined. Now that all {@link SBase} objects 908 * define those attributes, those functions now succeed for any object with 909 * the appropriate level and version. 910 <p> 911 * The exception to this rule is that for {@link InitialAssignment}, {@link EventAssignment}, 912 * {@link AssignmentRule}, and {@link RateRule} objects, the getId() function and the isSetId() 913 * functions (though not the setId() or unsetId() functions) would instead 914 * reference the value of the 'variable' attribute (for the rules and event 915 * assignments) or the 'symbol' attribute (for initial assignments). 916 * The {@link AlgebraicRule} fell into this category as well, though because it 917 * contained neither a 'variable' nor a 'symbol' attribute, getId() would 918 * always return an empty string, and isSetId() would always return <code>false.</code> 919 * For this reason, four new functions are now provided 920 * (getIdAttribute(), setIdAttribute(String), 921 * isSetIdAttribute(), and unsetIdAttribute()) that will always 922 * act on the actual 'id' attribute, regardless of the object's type. The 923 * new functions should be used instead of the old ones unless the old behavior 924 * is somehow necessary. 925 <p> 926 * Regardless of the level and version of the SBML, these functions allow 927 * client applications to use more generalized code in some situations 928 * (for instance, when manipulating objects that are all known to have 929 * identifiers). If the object in question does not posess an 'id' attribute 930 * according to the SBML specification for the Level and Version in use, 931 * libSBML will not allow the identifier to be set, nor will it read or 932 * write 'id' attributes for those objects. 933 <p> 934 * <p> 935 * @return integer value indicating success/failure of the 936 * function. The possible values 937 * returned by this function are: 938 * <ul> 939 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 940 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 941 * 942 * </ul> <p> 943 * @see #getIdAttribute() 944 * @see #setIdAttribute(String sid) 945 * @see #isSetIdAttribute() 946 * @see #unsetIdAttribute() 947 */ public 948 int unsetId() { 949 return libsbmlJNI.GeneProductAssociation_unsetId(swigCPtr, this); 950 } 951 952 953/** 954 * Unsets the value of the 'name' attribute of this {@link GeneProductAssociation}. 955 <p> 956 * <p> 957 * <p> 958 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 959 * moved to {@link SBase} directly, instead of being defined individually for many 960 * (but not all) objects. Libsbml has for a long time provided functions 961 * defined on {@link SBase} itself to get, set, and unset those attributes, which 962 * would fail or otherwise return empty strings if executed on any object 963 * for which those attributes were not defined. Now that all {@link SBase} objects 964 * define those attributes, those functions now succeed for any object with 965 * the appropriate level and version. 966 <p> 967 * The 'name' attribute is 968 * optional and is not intended to be used for cross-referencing purposes 969 * within a model. Its purpose instead is to provide a human-readable 970 * label for the component. The data type of 'name' is the type 971 * <code>string</code> defined in XML Schema. SBML imposes no 972 * restrictions as to the content of 'name' attributes beyond those 973 * restrictions defined by the <code>string</code> type in XML Schema. 974 <p> 975 * The recommended practice for handling 'name' is as follows. If a 976 * software tool has the capability for displaying the content of 'name' 977 * attributes, it should display this content to the user as a 978 * component's label instead of the component's 'id'. If the user 979 * interface does not have this capability (e.g., because it cannot 980 * display or use special characters in symbol names), or if the 'name' 981 * attribute is missing on a given component, then the user interface 982 * should display the value of the 'id' attribute instead. (Script 983 * language interpreters are especially likely to display 'id' instead of 984 * 'name'.) 985 <p> 986 * As a consequence of the above, authors of systems that automatically 987 * generate the values of 'id' attributes should be aware some systems 988 * may display the 'id''s to the user. Authors therefore may wish to 989 * take some care to have their software create 'id' values that are: (a) 990 * reasonably easy for humans to type and read; and (b) likely to be 991 * meaningful, for example by making the 'id' attribute be an abbreviated 992 * form of the name attribute value. 993 <p> 994 * An additional point worth mentioning is although there are 995 * restrictions on the uniqueness of 'id' values, there are no 996 * restrictions on the uniqueness of 'name' values in a model. This 997 * allows software applications leeway in assigning component identifiers. 998 <p> 999 * Regardless of the level and version of the SBML, these functions allow 1000 * client applications to use more generalized code in some situations 1001 * (for instance, when manipulating objects that are all known to have 1002 * names). If the object in question does not posess a 'name' attribute 1003 * according to the SBML specification for the Level and Version in use, 1004 * libSBML will not allow the name to be set, nor will it read or 1005 * write 'name' attributes for those objects. 1006 <p> 1007 * <p> 1008 * @return integer value indicating success/failure of the 1009 * function. The possible values 1010 * returned by this function are: 1011 * <ul> 1012 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 1013 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 1014 * 1015 * </ul> <p> 1016 * @see #getName() 1017 * @see #setName(String sid) 1018 * @see #isSetName() 1019 */ public 1020 int unsetName() { 1021 return libsbmlJNI.GeneProductAssociation_unsetName(swigCPtr, this); 1022 } 1023 1024 1025/** 1026 * Unsets the 'association' element of this {@link GeneProductAssociation}. 1027 <p> 1028 * <p> 1029 * @return integer value indicating success/failure of the 1030 * function. The possible values 1031 * returned by this function are: 1032 * <ul> 1033 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 1034 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 1035 * </ul> 1036 */ public 1037 int unsetAssociation() { 1038 return libsbmlJNI.GeneProductAssociation_unsetAssociation(swigCPtr, this); 1039 } 1040 1041 1042/** 1043 * Returns the XML element name of this object. 1044 <p> 1045 * For {@link GeneProductAssociation}, the XML element name is always <code>'geneProductAssociation'.</code> 1046 <p> 1047 * @return the name of this element, i.e. <code>'geneProductAssociation'.</code> 1048 */ public 1049 String getElementName() { 1050 return libsbmlJNI.GeneProductAssociation_getElementName(swigCPtr, this); 1051 } 1052 1053 1054/** 1055 * Returns the libSBML type code for this SBML object. 1056 <p> 1057 * <p> 1058 * LibSBML attaches an identifying code to every kind of SBML object. These 1059 * are integer constants known as <em>SBML type codes</em>. The names of all 1060 * the codes begin with the characters <code>SBML_</code>. 1061 * In the Java language interface for libSBML, the 1062 * type codes are defined as static integer constants in the interface class 1063 * {@link libsbmlConstants}. Note that different Level 3 1064 * package plug-ins may use overlapping type codes; to identify the package 1065 * to which a given object belongs, call the 1066 * <code>{@link SBase#getPackageName()} 1067 * </code> 1068 * method on the object. 1069 <p> 1070 * @return the SBML type code for this object: 1071 * {@link libsbmlConstants#SBML_FBC_GENEPRODUCTASSOCIATION SBML_FBC_GENEPRODUCTASSOCIATION} (default). 1072 <p> 1073 * <p> 1074 * @warning <span class='warning'>The specific integer values of the possible 1075 * type codes may be reused by different libSBML plug-ins for SBML Level 3. 1076 * packages, To fully identify the correct code, <strong>it is necessary to 1077 * invoke both getTypeCode() and getPackageName()</strong>.</span> 1078 <p> 1079 * @see #getElementName() 1080 * @see #getPackageName() 1081 */ public 1082 int getTypeCode() { 1083 return libsbmlJNI.GeneProductAssociation_getTypeCode(swigCPtr, this); 1084 } 1085 1086 1087/** 1088 * Predicate returning <code>true</code> if all the required attributes for this 1089 * {@link GeneProductAssociation} object have been set. 1090 <p> 1091 * @note The required attributes for a {@link GeneProductAssociation} object are: 1092 * <ul> 1093 * <li> 'association' 1094 * 1095 * </ul> <p> 1096 * @return a boolean value indicating whether all the required 1097 * attributes for this object have been defined. 1098 */ public 1099 boolean hasRequiredAttributes() { 1100 return libsbmlJNI.GeneProductAssociation_hasRequiredAttributes(swigCPtr, this); 1101 } 1102 1103 1104/** 1105 * Predicate returning <code>true</code> if all the required elements for this 1106 * {@link GeneProductAssociation} object have been set. 1107 <p> 1108 * @note The required elements for a {@link GeneProductAssociation} object are: 1109 * <ul> 1110 * <li> 'association' 1111 * 1112 * </ul> <p> 1113 * @return a boolean value indicating whether all the required 1114 * elements for this object have been defined. 1115 */ public 1116 boolean hasRequiredElements() { 1117 return libsbmlJNI.GeneProductAssociation_hasRequiredElements(swigCPtr, this); 1118 } 1119 1120 1121/** * @internal */ public 1122 void connectToChild() { 1123 libsbmlJNI.GeneProductAssociation_connectToChild(swigCPtr, this); 1124 } 1125 1126 1127/** * @internal */ public 1128 void enablePackageInternal(String pkgURI, String pkgPrefix, boolean flag) { 1129 libsbmlJNI.GeneProductAssociation_enablePackageInternal(swigCPtr, this, pkgURI, pkgPrefix, flag); 1130 } 1131 1132}