001/* ---------------------------------------------------------------------------- 002 * This file was automatically generated by SWIG (http://www.swig.org). 003 * Version 3.0.10 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 <p> 775 * @param usingId If <code>true</code>, this method assumes that the infix 776 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If @c 777 * false (the default), the method assumes that the string uses the label 778 * attributes of {@link GeneProduct} objects. 779 <p> 780 * @param addMissingGP If <code>true</code> (the default), then while 781 * parsing the infix string in <code>association</code>, any identifiers or labels 782 * (depending on <code>usingId</code>) found in the expression that do not correspond 783 * to an existing {@link GeneProduct} object will result in the addition of that 784 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 785 * that circumstance. 786 <p> 787 * <p> 788 * @return integer value indicating success/failure of the 789 * function. The possible values 790 * returned by this function are: 791 * <ul> 792 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 793 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 794 * </ul> 795 */ public 796 int setAssociation(String association, boolean usingId, boolean addMissingGP) { 797 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_1(swigCPtr, this, association, usingId, addMissingGP); 798 } 799 800 801/** 802 * Sets the 'association' element of this {@link GeneProductAssociation}. 803 <p> 804 * This is a helper method that allows a user to set the 805 * {@link GeneProductAssociation} via a string such as <code>"a1 AND b1 OR 806 * C2"</code> and have the method work out the correct XML structure. 807 <p> 808 * @param association string representation of the association to be set. 809 <p> 810 * @param usingId If <code>true</code>, this method assumes that the infix 811 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If @c 812 * false (the default), the method assumes that the string uses the label 813 * attributes of {@link GeneProduct} objects. 814 <p> 815 * @param addMissingGP If <code>true</code> (the default), then while 816 * parsing the infix string in <code>association</code>, any identifiers or labels 817 * (depending on <code>usingId</code>) found in the expression that do not correspond 818 * to an existing {@link GeneProduct} object will result in the addition of that 819 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 820 * that circumstance. 821 <p> 822 * <p> 823 * @return integer value indicating success/failure of the 824 * function. The possible values 825 * returned by this function are: 826 * <ul> 827 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 828 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 829 * </ul> 830 */ public 831 int setAssociation(String association, boolean usingId) { 832 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_2(swigCPtr, this, association, usingId); 833 } 834 835 836/** 837 * Sets the 'association' element of this {@link GeneProductAssociation}. 838 <p> 839 * This is a helper method that allows a user to set the 840 * {@link GeneProductAssociation} via a string such as <code>"a1 AND b1 OR 841 * C2"</code> and have the method work out the correct XML structure. 842 <p> 843 * @param association string representation of the association to be set. 844 <p> 845 * @param usingId If <code>true</code>, this method assumes that the infix 846 * string <code>association</code> uses the identifiers of {@link GeneProduct} objects. If @c 847 * false (the default), the method assumes that the string uses the label 848 * attributes of {@link GeneProduct} objects. 849 <p> 850 * @param addMissingGP If <code>true</code> (the default), then while 851 * parsing the infix string in <code>association</code>, any identifiers or labels 852 * (depending on <code>usingId</code>) found in the expression that do not correspond 853 * to an existing {@link GeneProduct} object will result in the addition of that 854 * {@link GeneProduct}. If <code>false</code>, this method will not add a {@link GeneProduct} in 855 * that circumstance. 856 <p> 857 * <p> 858 * @return integer value indicating success/failure of the 859 * function. The possible values 860 * returned by this function are: 861 * <ul> 862 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 863 * <li> {@link libsbmlConstants#LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_ATTRIBUTE_VALUE} 864 * </ul> 865 */ public 866 int setAssociation(String association) { 867 return libsbmlJNI.GeneProductAssociation_setAssociation__SWIG_3(swigCPtr, this, association); 868 } 869 870 871/** 872 * Unsets the value of the 'id' attribute of this {@link GeneProductAssociation}. 873 <p> 874 * <p> 875 * <p> 876 * The identifier given by an object's 'id' attribute value 877 * is used to identify the object within the SBML model definition. 878 * Other objects can refer to the component using this identifier. The 879 * data type of 'id' is always <code>SId</code> or a type derived 880 * from that, such as <code>UnitSId</code>, depending on the object in 881 * question. All data types are defined as follows: 882 * <pre style='margin-left: 2em; border: none; font-weight: bold; color: black'> 883 * letter .= 'a'..'z','A'..'Z' 884 * digit .= '0'..'9' 885 * idChar .= letter | digit | '_' 886 * SId .= ( letter | '_' ) idChar* 887 * </pre> 888 <p> 889 * The characters <code>(</code> and <code>)</code> are used for grouping, the 890 * character <code>*</code> 'zero or more times', and the character 891 * <code>|</code> indicates logical 'or'. The equality of SBML identifiers is 892 * determined by an exact character sequence match; i.e., comparisons must be 893 * performed in a case-sensitive manner. This applies to all uses of <code>SId</code>, 894 * <code>SIdRef</code>, and derived types. 895 <p> 896 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 897 * moved to {@link SBase} directly, instead of being defined individually for many 898 * (but not all) objects. Libsbml has for a long time provided functions 899 * defined on {@link SBase} itself to get, set, check, and unset those attributes, which 900 * would fail or otherwise return empty strings if executed on any object 901 * for which those attributes were not defined. Now that all {@link SBase} objects 902 * define those attributes, those functions now succeed for any object with 903 * the appropriate level and version. 904 <p> 905 * The exception to this rule is that for {@link InitialAssignment}, {@link EventAssignment}, 906 * {@link AssignmentRule}, and {@link RateRule} objects, the getId() function and the isSetId() 907 * functions (though not the setId() or unsetId() functions) would instead 908 * reference the value of the 'variable' attribute (for the rules and event 909 * assignments) or the 'symbol' attribute (for initial assignments). 910 * The {@link AlgebraicRule} fell into this category as well, though because it 911 * contained neither a 'variable' nor a 'symbol' attribute, getId() would 912 * always return an empty string, and isSetId() would always return <code>false.</code> 913 * For this reason, four new functions are now provided 914 * (getIdAttribute(), setIdAttribute(String), 915 * isSetIdAttribute(), and unsetIdAttribute()) that will always 916 * act on the actual 'id' attribute, regardless of the object's type. The 917 * new functions should be used instead of the old ones unless the old behavior 918 * is somehow necessary. 919 <p> 920 * Regardless of the level and version of the SBML, these functions allow 921 * client applications to use more generalized code in some situations 922 * (for instance, when manipulating objects that are all known to have 923 * identifiers). If the object in question does not posess an 'id' attribute 924 * according to the SBML specification for the Level and Version in use, 925 * libSBML will not allow the identifier to be set, nor will it read or 926 * write 'id' attributes for those objects. 927 <p> 928 * <p> 929 * @return integer value indicating success/failure of the 930 * function. The possible values 931 * returned by this function are: 932 * <ul> 933 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 934 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 935 * 936 * </ul> <p> 937 * @see #getIdAttribute() 938 * @see #setIdAttribute(String sid) 939 * @see #isSetIdAttribute() 940 * @see #unsetIdAttribute() 941 */ public 942 int unsetId() { 943 return libsbmlJNI.GeneProductAssociation_unsetId(swigCPtr, this); 944 } 945 946 947/** 948 * Unsets the value of the 'name' attribute of this {@link GeneProductAssociation}. 949 <p> 950 * <p> 951 * <p> 952 * In SBML Level 3 Version 2, the 'id' and 'name' attributes were 953 * moved to {@link SBase} directly, instead of being defined individually for many 954 * (but not all) objects. Libsbml has for a long time provided functions 955 * defined on {@link SBase} itself to get, set, and unset those attributes, which 956 * would fail or otherwise return empty strings if executed on any object 957 * for which those attributes were not defined. Now that all {@link SBase} objects 958 * define those attributes, those functions now succeed for any object with 959 * the appropriate level and version. 960 <p> 961 * The 'name' attribute is 962 * optional and is not intended to be used for cross-referencing purposes 963 * within a model. Its purpose instead is to provide a human-readable 964 * label for the component. The data type of 'name' is the type 965 * <code>string</code> defined in XML Schema. SBML imposes no 966 * restrictions as to the content of 'name' attributes beyond those 967 * restrictions defined by the <code>string</code> type in XML Schema. 968 <p> 969 * The recommended practice for handling 'name' is as follows. If a 970 * software tool has the capability for displaying the content of 'name' 971 * attributes, it should display this content to the user as a 972 * component's label instead of the component's 'id'. If the user 973 * interface does not have this capability (e.g., because it cannot 974 * display or use special characters in symbol names), or if the 'name' 975 * attribute is missing on a given component, then the user interface 976 * should display the value of the 'id' attribute instead. (Script 977 * language interpreters are especially likely to display 'id' instead of 978 * 'name'.) 979 <p> 980 * As a consequence of the above, authors of systems that automatically 981 * generate the values of 'id' attributes should be aware some systems 982 * may display the 'id''s to the user. Authors therefore may wish to 983 * take some care to have their software create 'id' values that are: (a) 984 * reasonably easy for humans to type and read; and (b) likely to be 985 * meaningful, for example by making the 'id' attribute be an abbreviated 986 * form of the name attribute value. 987 <p> 988 * An additional point worth mentioning is although there are 989 * restrictions on the uniqueness of 'id' values, there are no 990 * restrictions on the uniqueness of 'name' values in a model. This 991 * allows software applications leeway in assigning component identifiers. 992 <p> 993 * Regardless of the level and version of the SBML, these functions allow 994 * client applications to use more generalized code in some situations 995 * (for instance, when manipulating objects that are all known to have 996 * names). If the object in question does not posess a 'name' attribute 997 * according to the SBML specification for the Level and Version in use, 998 * libSBML will not allow the name to be set, nor will it read or 999 * write 'name' attributes for those objects. 1000 <p> 1001 * <p> 1002 * @return integer value indicating success/failure of the 1003 * function. The possible values 1004 * returned by this function are: 1005 * <ul> 1006 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 1007 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 1008 * 1009 * </ul> <p> 1010 * @see #getName() 1011 * @see #setName(String sid) 1012 * @see #isSetName() 1013 */ public 1014 int unsetName() { 1015 return libsbmlJNI.GeneProductAssociation_unsetName(swigCPtr, this); 1016 } 1017 1018 1019/** 1020 * Unsets the 'association' element of this {@link GeneProductAssociation}. 1021 <p> 1022 * <p> 1023 * @return integer value indicating success/failure of the 1024 * function. The possible values 1025 * returned by this function are: 1026 * <ul> 1027 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 1028 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 1029 * </ul> 1030 */ public 1031 int unsetAssociation() { 1032 return libsbmlJNI.GeneProductAssociation_unsetAssociation(swigCPtr, this); 1033 } 1034 1035 1036/** 1037 * Returns the XML element name of this object. 1038 <p> 1039 * For {@link GeneProductAssociation}, the XML element name is always <code>'geneProductAssociation'.</code> 1040 <p> 1041 * @return the name of this element, i.e. <code>'geneProductAssociation'.</code> 1042 */ public 1043 String getElementName() { 1044 return libsbmlJNI.GeneProductAssociation_getElementName(swigCPtr, this); 1045 } 1046 1047 1048/** 1049 * Returns the libSBML type code for this SBML object. 1050 <p> 1051 * <p> 1052 * LibSBML attaches an identifying code to every kind of SBML object. These 1053 * are integer constants known as <em>SBML type codes</em>. The names of all 1054 * the codes begin with the characters <code>SBML_</code>. 1055 * In the Java language interface for libSBML, the 1056 * type codes are defined as static integer constants in the interface class 1057 * {@link libsbmlConstants}. Note that different Level 3 1058 * package plug-ins may use overlapping type codes; to identify the package 1059 * to which a given object belongs, call the <code>getPackageName()</code> 1060 * method on the object. 1061 <p> 1062 * @return the SBML type code for this object: 1063 * {@link libsbmlConstants#SBML_FBC_GENEPRODUCTASSOCIATION SBML_FBC_GENEPRODUCTASSOCIATION} (default). 1064 <p> 1065 * <p> 1066 * @warning <span class='warning'>The specific integer values of the possible 1067 * type codes may be reused by different libSBML plug-ins for SBML Level 3. 1068 * packages, To fully identify the correct code, <strong>it is necessary to 1069 * invoke both getTypeCode() and getPackageName()</strong>.</span> 1070 <p> 1071 * @see #getElementName() 1072 * @see #getPackageName() 1073 */ public 1074 int getTypeCode() { 1075 return libsbmlJNI.GeneProductAssociation_getTypeCode(swigCPtr, this); 1076 } 1077 1078 1079/** 1080 * Predicate returning <code>true</code> if all the required attributes for this 1081 * {@link GeneProductAssociation} object have been set. 1082 <p> 1083 * @note The required attributes for a {@link GeneProductAssociation} object are: 1084 * <ul> 1085 * <li> 'association' 1086 * 1087 * </ul> <p> 1088 * @return a boolean value indicating whether all the required 1089 * attributes for this object have been defined. 1090 */ public 1091 boolean hasRequiredAttributes() { 1092 return libsbmlJNI.GeneProductAssociation_hasRequiredAttributes(swigCPtr, this); 1093 } 1094 1095 1096/** 1097 * Predicate returning <code>true</code> if all the required elements for this 1098 * {@link GeneProductAssociation} object have been set. 1099 <p> 1100 * @note The required elements for a {@link GeneProductAssociation} object are: 1101 * <ul> 1102 * <li> 'association' 1103 * 1104 * </ul> <p> 1105 * @return a boolean value indicating whether all the required 1106 * elements for this object have been defined. 1107 */ public 1108 boolean hasRequiredElements() { 1109 return libsbmlJNI.GeneProductAssociation_hasRequiredElements(swigCPtr, this); 1110 } 1111 1112 1113/** * @internal */ public 1114 void connectToChild() { 1115 libsbmlJNI.GeneProductAssociation_connectToChild(swigCPtr, this); 1116 } 1117 1118 1119/** * @internal */ public 1120 void enablePackageInternal(String pkgURI, String pkgPrefix, boolean flag) { 1121 libsbmlJNI.GeneProductAssociation_enablePackageInternal(swigCPtr, this, pkgURI, pkgPrefix, flag); 1122 } 1123 1124}