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