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-groups"><a href="group__groups.html">groups</a></span> 013 A list of {@link Group} objects. 014 <p> 015 * The SBML Level 3 Groups package provides a means of defining a 016 * <em>group of entities</em>: a simple mechanism for indicating that 017 * particular components of an SBML model are related in some way. A group 018 * is defined using a {@link Group} class object, and all the {@link Group} objects in a 019 * model are stored in the parent {@link Model} object within a {@link ListOfGroups} object. 020 <p> 021 * A {@link ListOfGroups} is optional, but, if present, must contain at least one 022 * {@link Group} object. In common with other ListOf___ classes in SBML, 023 * {@link ListOfGroups} is derived from {@link SBase}. It inherits {@link SBase}'s attributes 024 * 'metaid' and 'sboTerm', as well as the subcomponents for Annotation and 025 * Notes, but does not add any new attributes of its own. 026 <p> 027 * <p> 028 * The various ListOf___ classes in SBML 029 * are merely containers used for organizing the main components of an SBML 030 * model. In libSBML's implementation, ListOf___ 031 * classes are derived from the 032 * intermediate utility class {@link ListOf}, which 033 * is not defined by the SBML specifications but serves as a useful 034 * programmatic construct. {@link ListOf} is itself is in turn derived from {@link SBase}, 035 * which provides all of the various ListOf___ 036 * classes with common features 037 * defined by the SBML specification, such as 'metaid' attributes and 038 * annotations. 039 <p> 040 * The relationship between the lists and the rest of an SBML model is 041 * illustrated by the following (for SBML Level 2 Version 4): 042 <p> 043 * <figure> 044 <object type="image/svg+xml" data="listof-illustration.svg" class="centered"></object> 045</figure> 046 047 <p> 048 * SBML Level 3 Version 1 has essentially the same structure as 049 * Level 2 Version 4, depicted above, but SBML Level 3 050 * Version 2 allows 051 * containers to contain zero or more of the relevant object, instead of 052 * requiring at least one. As such, libsbml will write out an 053 * otherwise-empty ListOf___ element that has any optional attribute set 054 * (such as 'id' or 'metaid'), that has an optional child (such 055 * as a 'notes' or 'annotation'), or that has attributes or children set 056 * from any SBML Level 3 package, whether or not the ListOf___ has 057 * any other children. 058 <p> 059 * Readers may wonder about the motivations for using the ListOf___ 060 * containers in SBML. A simpler approach in XML might be to place the 061 * components all directly at the top level of the model definition. The 062 * choice made in SBML is to group them within XML elements named after 063 * ListOf<em>Classname</em>, in part because it helps organize the 064 * components. More importantly, the fact that the container classes are 065 * derived from {@link SBase} means that software tools can add information <em>about</em> 066 * the lists themselves into each list container's 'annotation'. 067 <p> 068 * @see ListOfFunctionDefinitions 069 * @see ListOfUnitDefinitions 070 * @see ListOfCompartmentTypes 071 * @see ListOfSpeciesTypes 072 * @see ListOfCompartments 073 * @see ListOfSpecies 074 * @see ListOfParameters 075 * @see ListOfInitialAssignments 076 * @see ListOfRules 077 * @see ListOfConstraints 078 * @see ListOfReactions 079 * @see ListOfEvents 080 */ 081 082public class ListOfGroups extends ListOf { 083 private long swigCPtr; 084 085 protected ListOfGroups(long cPtr, boolean cMemoryOwn) 086 { 087 super(libsbmlJNI.ListOfGroups_SWIGUpcast(cPtr), cMemoryOwn); 088 swigCPtr = cPtr; 089 } 090 091 protected static long getCPtr(ListOfGroups obj) 092 { 093 return (obj == null) ? 0 : obj.swigCPtr; 094 } 095 096 protected static long getCPtrAndDisown (ListOfGroups obj) 097 { 098 long ptr = 0; 099 100 if (obj != null) 101 { 102 ptr = obj.swigCPtr; 103 obj.swigCMemOwn = false; 104 } 105 106 return ptr; 107 } 108 109 protected void finalize() { 110 delete(); 111 } 112 113 public synchronized void delete() { 114 if (swigCPtr != 0) { 115 if (swigCMemOwn) { 116 swigCMemOwn = false; 117 libsbmlJNI.delete_ListOfGroups(swigCPtr); 118 } 119 swigCPtr = 0; 120 } 121 super.delete(); 122 } 123 124 125/** 126 * Creates a new {@link ListOfGroups} using the given SBML Level, Version and 127 * “groups” package version. 128 <p> 129 * @param level a long integer, the SBML Level to assign to this 130 * {@link ListOfGroups}. 131 <p> 132 * @param version a long integer, the SBML Version to assign to this 133 * {@link ListOfGroups}. 134 <p> 135 * @param pkgVersion a long integer, the SBML Groups Version to assign to 136 * this {@link ListOfGroups}. 137 <p> 138 * <p> 139 * @note Attempting to add an object to an {@link SBMLDocument} having a different 140 * combination of SBML Level, Version and XML namespaces than the object 141 * itself will result in an error at the time a caller attempts to make the 142 * addition. A parent object must have compatible Level, Version and XML 143 * namespaces. (Strictly speaking, a parent may also have more XML 144 * namespaces than a child, but the reverse is not permitted.) The 145 * restriction is necessary to ensure that an SBML model has a consistent 146 * overall structure. This requires callers to manage their objects 147 * carefully, but the benefit is increased flexibility in how models can be 148 * created by permitting callers to create objects bottom-up if desired. In 149 * situations where objects are not yet attached to parents (e.g., 150 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 151 * libSBML determine such things as whether it is valid to assign a 152 * particular value to an attribute. For packages, this means that the 153 * parent object to which this package element is being added must have 154 * been created with the package namespace, or that the package namespace 155 * was added to it, even if that parent is not a package object itself. 156 */ public 157 ListOfGroups(long level, long version, long pkgVersion) throws org.sbml.libsbml.SBMLConstructorException { 158 this(libsbmlJNI.new_ListOfGroups__SWIG_0(level, version, pkgVersion), true); 159 } 160 161 162/** 163 * Creates a new {@link ListOfGroups} using the given SBML Level, Version and 164 * “groups” package version. 165 <p> 166 * @param level a long integer, the SBML Level to assign to this 167 * {@link ListOfGroups}. 168 <p> 169 * @param version a long integer, the SBML Version to assign to this 170 * {@link ListOfGroups}. 171 <p> 172 * @param pkgVersion a long integer, the SBML Groups Version to assign to 173 * this {@link ListOfGroups}. 174 <p> 175 * <p> 176 * @note Attempting to add an object to an {@link SBMLDocument} having a different 177 * combination of SBML Level, Version and XML namespaces than the object 178 * itself will result in an error at the time a caller attempts to make the 179 * addition. A parent object must have compatible Level, Version and XML 180 * namespaces. (Strictly speaking, a parent may also have more XML 181 * namespaces than a child, but the reverse is not permitted.) The 182 * restriction is necessary to ensure that an SBML model has a consistent 183 * overall structure. This requires callers to manage their objects 184 * carefully, but the benefit is increased flexibility in how models can be 185 * created by permitting callers to create objects bottom-up if desired. In 186 * situations where objects are not yet attached to parents (e.g., 187 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 188 * libSBML determine such things as whether it is valid to assign a 189 * particular value to an attribute. For packages, this means that the 190 * parent object to which this package element is being added must have 191 * been created with the package namespace, or that the package namespace 192 * was added to it, even if that parent is not a package object itself. 193 */ public 194 ListOfGroups(long level, long version) throws org.sbml.libsbml.SBMLConstructorException { 195 this(libsbmlJNI.new_ListOfGroups__SWIG_1(level, version), true); 196 } 197 198 199/** 200 * Creates a new {@link ListOfGroups} using the given SBML Level, Version and 201 * “groups” package version. 202 <p> 203 * @param level a long integer, the SBML Level to assign to this 204 * {@link ListOfGroups}. 205 <p> 206 * @param version a long integer, the SBML Version to assign to this 207 * {@link ListOfGroups}. 208 <p> 209 * @param pkgVersion a long integer, the SBML Groups Version to assign to 210 * this {@link ListOfGroups}. 211 <p> 212 * <p> 213 * @note Attempting to add an object to an {@link SBMLDocument} having a different 214 * combination of SBML Level, Version and XML namespaces than the object 215 * itself will result in an error at the time a caller attempts to make the 216 * addition. A parent object must have compatible Level, Version and XML 217 * namespaces. (Strictly speaking, a parent may also have more XML 218 * namespaces than a child, but the reverse is not permitted.) The 219 * restriction is necessary to ensure that an SBML model has a consistent 220 * overall structure. This requires callers to manage their objects 221 * carefully, but the benefit is increased flexibility in how models can be 222 * created by permitting callers to create objects bottom-up if desired. In 223 * situations where objects are not yet attached to parents (e.g., 224 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 225 * libSBML determine such things as whether it is valid to assign a 226 * particular value to an attribute. For packages, this means that the 227 * parent object to which this package element is being added must have 228 * been created with the package namespace, or that the package namespace 229 * was added to it, even if that parent is not a package object itself. 230 */ public 231 ListOfGroups(long level) throws org.sbml.libsbml.SBMLConstructorException { 232 this(libsbmlJNI.new_ListOfGroups__SWIG_2(level), true); 233 } 234 235 236/** 237 * Creates a new {@link ListOfGroups} using the given SBML Level, Version and 238 * “groups” package version. 239 <p> 240 * @param level a long integer, the SBML Level to assign to this 241 * {@link ListOfGroups}. 242 <p> 243 * @param version a long integer, the SBML Version to assign to this 244 * {@link ListOfGroups}. 245 <p> 246 * @param pkgVersion a long integer, the SBML Groups Version to assign to 247 * this {@link ListOfGroups}. 248 <p> 249 * <p> 250 * @note Attempting to add an object to an {@link SBMLDocument} having a different 251 * combination of SBML Level, Version and XML namespaces than the object 252 * itself will result in an error at the time a caller attempts to make the 253 * addition. A parent object must have compatible Level, Version and XML 254 * namespaces. (Strictly speaking, a parent may also have more XML 255 * namespaces than a child, but the reverse is not permitted.) The 256 * restriction is necessary to ensure that an SBML model has a consistent 257 * overall structure. This requires callers to manage their objects 258 * carefully, but the benefit is increased flexibility in how models can be 259 * created by permitting callers to create objects bottom-up if desired. In 260 * situations where objects are not yet attached to parents (e.g., 261 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 262 * libSBML determine such things as whether it is valid to assign a 263 * particular value to an attribute. For packages, this means that the 264 * parent object to which this package element is being added must have 265 * been created with the package namespace, or that the package namespace 266 * was added to it, even if that parent is not a package object itself. 267 */ public 268 ListOfGroups() throws org.sbml.libsbml.SBMLConstructorException { 269 this(libsbmlJNI.new_ListOfGroups__SWIG_3(), true); 270 } 271 272 273/** 274 * Creates a new {@link ListOfGroups} using the given {@link GroupsPkgNamespaces} object. 275 <p> 276 * <p> 277 * The package namespaces object used in this constructor is derived from a 278 * {@link SBMLNamespaces} object, which encapsulates SBML Level/Version/namespaces 279 * information. It is used to communicate the SBML Level, Version, and 280 * package version and name information used in addition to SBML Level 3 Core. A 281 * common approach to using libSBML's {@link SBMLNamespaces} facilities is to create an 282 * package namespace object somewhere in a program once, then hand that object 283 * as needed to object constructors of that package that accept it as and 284 * argument, such as this one. 285 <p> 286 * @param groupsns the {@link GroupsPkgNamespaces} object. 287 <p> 288 * <p> 289 * @note Attempting to add an object to an {@link SBMLDocument} having a different 290 * combination of SBML Level, Version and XML namespaces than the object 291 * itself will result in an error at the time a caller attempts to make the 292 * addition. A parent object must have compatible Level, Version and XML 293 * namespaces. (Strictly speaking, a parent may also have more XML 294 * namespaces than a child, but the reverse is not permitted.) The 295 * restriction is necessary to ensure that an SBML model has a consistent 296 * overall structure. This requires callers to manage their objects 297 * carefully, but the benefit is increased flexibility in how models can be 298 * created by permitting callers to create objects bottom-up if desired. In 299 * situations where objects are not yet attached to parents (e.g., 300 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 301 * libSBML determine such things as whether it is valid to assign a 302 * particular value to an attribute. For packages, this means that the 303 * parent object to which this package element is being added must have 304 * been created with the package namespace, or that the package namespace 305 * was added to it, even if that parent is not a package object itself. 306 */ public 307 ListOfGroups(GroupsPkgNamespaces groupsns) throws org.sbml.libsbml.SBMLConstructorException { 308 this(libsbmlJNI.new_ListOfGroups__SWIG_4(GroupsPkgNamespaces.getCPtr(groupsns), groupsns), true); 309 } 310 311 312/** 313 * Copy constructor for {@link ListOfGroups}. 314 <p> 315 * @param orig the {@link ListOfGroups} instance to copy. 316 */ public 317 ListOfGroups(ListOfGroups orig) throws org.sbml.libsbml.SBMLConstructorException { 318 this(libsbmlJNI.new_ListOfGroups__SWIG_5(ListOfGroups.getCPtr(orig), orig), true); 319 } 320 321 322/** 323 * Creates and returns a deep copy of this {@link ListOfGroups} object. 324 <p> 325 * @return a (deep) copy of this {@link ListOfGroups} object. 326 */ public 327 ListOfGroups cloneObject() { 328 long cPtr = libsbmlJNI.ListOfGroups_cloneObject(swigCPtr, this); 329 return (cPtr == 0) ? null : new ListOfGroups(cPtr, true); 330 } 331 332 333/** 334 * Get a {@link Group} from the {@link ListOfGroups}. 335 <p> 336 * @param n a long integer representing the index of the {@link Group} to retrieve. 337 <p> 338 * @return the nth {@link Group} in this {@link ListOfGroups}. 339 <p> 340 * <p> 341 * The pointer that is returned by this function is not owned by the caller, 342 * but may be queried and modified. Any changes made will be reflected in any 343 * resulting SBML document containing the pointer's parent. 344 <p> 345 * @see #addGroup(Group object) 346 * @see #createGroup() 347 * @see #get(String sid) 348 * @see #getNumGroups() 349 * @see #remove(String sid) 350 * @see #remove(long n) 351 */ public 352 Group get(long n) { 353 long cPtr = libsbmlJNI.ListOfGroups_get__SWIG_0(swigCPtr, this, n); 354 return (cPtr == 0) ? null : new Group(cPtr, false); 355 } 356 357 358/** 359 * Get a {@link Group} from the {@link ListOfGroups} based on its identifier. 360 <p> 361 * @param sid a string representing the identifier of the {@link Group} to retrieve. 362 <p> 363 * @return the {@link Group} in this {@link ListOfGroups} with the given <code>sid</code> or <code>null</code> if 364 * no such {@link Group} exists. 365 <p> 366 * <p> 367 * The pointer that is returned by this function is not owned by the caller, 368 * but may be queried and modified. Any changes made will be reflected in any 369 * resulting SBML document containing the pointer's parent. 370 <p> 371 * @see #addGroup(Group object) 372 * @see #createGroup() 373 * @see #get(long n) 374 * @see #getNumGroups() 375 * @see #remove(String sid) 376 * @see #remove(long n) 377 */ public 378 Group get(String sid) { 379 long cPtr = libsbmlJNI.ListOfGroups_get__SWIG_2(swigCPtr, this, sid); 380 return (cPtr == 0) ? null : new Group(cPtr, false); 381 } 382 383 384/** 385 * Removes the nth {@link Group} from this {@link ListOfGroups} and returns a pointer to it. 386 <p> 387 * @param n a long integer representing the index of the {@link Group} to remove. 388 <p> 389 * @return a pointer to the nth {@link Group} in this {@link ListOfGroups}. 390 <p> 391 * <p> 392 * The pointer that is returned by this function is owned by the caller, 393 * who is responsible for deleting it. Any changes made to the element 394 * will not be reflected in any resulting SBML document unless the element 395 * is added to an SBML Document. Even in this case, the element's deletion is 396 * still the responsibility of the caller with two exceptions: if it is used 397 * as the 'disownedItem' in the * {@link ListOf#appendAndOwn()} or {@link ListOf#insertAndOwn()} 398 * functions. All other functions in libsbml add a copy of the element, 399 * and do not transfer ownership of the pointer. 400 <p> 401 * @see #addGroup(Group object) 402 * @see #createGroup() 403 * @see #get(String sid) 404 * @see #get(long n) 405 * @see #getNumGroups() 406 * @see #remove(String sid) 407 */ public 408 Group remove(long n) { 409 long cPtr = libsbmlJNI.ListOfGroups_remove__SWIG_0(swigCPtr, this, n); 410 return (cPtr == 0) ? null : new Group(cPtr, true); 411 } 412 413 414/** 415 * Removes the {@link Group} from this {@link ListOfGroups} based on its identifier and 416 * returns a pointer to it. 417 <p> 418 * @param sid a string representing the identifier of the {@link Group} to remove. 419 <p> 420 * @return the {@link Group} in this {@link ListOfGroups} based on the identifier or null if 421 * no such {@link Group} exists. 422 <p> 423 * <p> 424 * The pointer that is returned by this function is owned by the caller, 425 * who is responsible for deleting it. Any changes made to the element 426 * will not be reflected in any resulting SBML document unless the element 427 * is added to an SBML Document. Even in this case, the element's deletion is 428 * still the responsibility of the caller with two exceptions: if it is used 429 * as the 'disownedItem' in the * {@link ListOf#appendAndOwn()} or {@link ListOf#insertAndOwn()} 430 * functions. All other functions in libsbml add a copy of the element, 431 * and do not transfer ownership of the pointer. 432 <p> 433 * @see #addGroup(Group object) 434 * @see #createGroup() 435 * @see #get(String sid) 436 * @see #get(long n) 437 * @see #getNumGroups() 438 * @see #remove(long n) 439 */ public 440 Group remove(String sid) { 441 long cPtr = libsbmlJNI.ListOfGroups_remove__SWIG_1(swigCPtr, this, sid); 442 return (cPtr == 0) ? null : new Group(cPtr, true); 443 } 444 445 446/** 447 * Adds a copy of the given {@link Group} to this {@link ListOfGroups}. 448 <p> 449 * @param g the {@link Group} object to add. 450 <p> 451 * <p> 452 * @return integer value indicating success/failure of the 453 * function. The possible values 454 * returned by this function are: 455 * <ul> 456 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS} 457 * <li> {@link libsbmlConstants#LIBSBML_OPERATION_FAILED LIBSBML_OPERATION_FAILED} 458 * <li> {@link libsbmlConstants#LIBSBML_INVALID_OBJECT LIBSBML_INVALID_OBJECT} 459 * <li> {@link libsbmlConstants#LIBSBML_LEVEL_MISMATCH LIBSBML_LEVEL_MISMATCH} 460 * <li> {@link libsbmlConstants#LIBSBML_VERSION_MISMATCH LIBSBML_VERSION_MISMATCH} 461 * <li> {@link libsbmlConstants#LIBSBML_PKG_VERSION_MISMATCH LIBSBML_PKG_VERSION_MISMATCH} 462 * <li> {@link libsbmlConstants#LIBSBML_DUPLICATE_OBJECT_ID LIBSBML_DUPLICATE_OBJECT_ID} 463 * 464 * </ul> <p> 465 * <p> 466 * @note This method should be used with some caution. The fact that this 467 * method <em>copies</em> the object passed to it means that the caller will be 468 * left holding a physically different object instance than the one contained 469 * inside this object. Changes made to the original object instance (such as 470 * resetting attribute values) will <em>not affect the instance in this 471 * object</em>. In addition, the caller should make sure to free the 472 * original object if it is no longer being used, or else a memory leak will 473 * result. Please see other methods on this class (particularly a 474 * corresponding method whose name begins with the word <code>create</code>) 475 * for alternatives that do not lead to these issues. 476 <p> 477 * @see #createGroup() 478 * @see #get(String sid) 479 * @see #get(long n) 480 * @see #getNumGroups() 481 * @see #remove(String sid) 482 * @see #remove(long n) 483 */ public 484 int addGroup(Group g) { 485 return libsbmlJNI.ListOfGroups_addGroup(swigCPtr, this, Group.getCPtr(g), g); 486 } 487 488 489/** 490 * Get the number of {@link Group} objects in this {@link ListOfGroups}. 491 <p> 492 * @return the number of {@link Group} objects in this {@link ListOfGroups}. 493 <p> 494 * @see #addGroup(Group object) 495 * @see #createGroup() 496 * @see #get(String sid) 497 * @see #get(long n) 498 * @see #remove(String sid) 499 * @see #remove(long n) 500 */ public 501 long getNumGroups() { 502 return libsbmlJNI.ListOfGroups_getNumGroups(swigCPtr, this); 503 } 504 505 506/** 507 * Creates a new {@link Group} object, adds it to this {@link ListOfGroups} object and 508 * returns the {@link Group} object created. 509 <p> 510 * @return a new {@link Group} object instance. 511 <p> 512 * <p> 513 * The pointer that is returned by this function is not owned by the caller, 514 * but may be queried and modified. Any changes made will be reflected in any 515 * resulting SBML document containing the pointer's parent. 516 <p> 517 * @see #addGroup(Group object) 518 * @see #get(String sid) 519 * @see #get(long n) 520 * @see #getNumGroups() 521 * @see #remove(String sid) 522 * @see #remove(long n) 523 */ public 524 Group createGroup() { 525 long cPtr = libsbmlJNI.ListOfGroups_createGroup(swigCPtr, this); 526 return (cPtr == 0) ? null : new Group(cPtr, false); 527 } 528 529 530/** 531 * Returns the XML element name of this {@link ListOfGroups} object. 532 <p> 533 * For {@link ListOfGroups}, the XML element name is always <code>'listOfGroups'.</code> 534 <p> 535 * @return the name of this element, i.e. <code>'listOfGroups'.</code> 536 */ public 537 String getElementName() { 538 return libsbmlJNI.ListOfGroups_getElementName(swigCPtr, this); 539 } 540 541 542/** 543 * Returns the libSBML type code for this {@link ListOfGroups} object. 544 <p> 545 * <p> 546 * LibSBML attaches an identifying code to every kind of SBML object. These 547 * are integer constants known as <em>SBML type codes</em>. The names of all 548 * the codes begin with the characters <code>SBML_</code>. 549 * In the Java language interface for libSBML, the 550 * type codes are defined as static integer constants in the interface class 551 * {@link libsbmlConstants}. Note that different Level 3 552 * package plug-ins may use overlapping type codes; to identify the package 553 * to which a given object belongs, call the 554 * <code>{@link SBase#getPackageName()} 555 * </code> 556 * method on the object. 557 <p> 558 * @return the SBML type code for this object: 559 * {@link libsbmlConstants#SBML_LIST_OF SBML_LIST_OF}. 560 <p> 561 * <p> 562 * @warning <span class='warning'>The specific integer values of the possible 563 * type codes may be reused by different libSBML plug-ins for SBML Level 3. 564 * packages, To fully identify the correct code, <strong>it is necessary to 565 * invoke both getTypeCode() and getPackageName()</strong>.</span> 566 */ public 567 int getTypeCode() { 568 return libsbmlJNI.ListOfGroups_getTypeCode(swigCPtr, this); 569 } 570 571 572/** 573 * Returns the libSBML type code for the SBML objects contained in this 574 * {@link ListOfGroups} object. 575 <p> 576 * <p> 577 * LibSBML attaches an identifying code to every kind of SBML object. These 578 * are integer constants known as <em>SBML type codes</em>. The names of all 579 * the codes begin with the characters <code>SBML_</code>. 580 * In the Java language interface for libSBML, the 581 * type codes are defined as static integer constants in the interface class 582 * {@link libsbmlConstants}. Note that different Level 3 583 * package plug-ins may use overlapping type codes; to identify the package 584 * to which a given object belongs, call the 585 * <code>{@link SBase#getPackageName()} 586 * </code> 587 * method on the object. 588 <p> 589 * @return the SBML typecode for the objects contained in this ListOfGroups: 590 * {@link libsbmlConstants#SBML_GROUPS_GROUP SBML_GROUPS_GROUP}. 591 <p> 592 * <p> 593 * @warning <span class='warning'>The specific integer values of the possible 594 * type codes may be reused by different libSBML plug-ins for SBML Level 3. 595 * packages, To fully identify the correct code, <strong>it is necessary to 596 * invoke both getTypeCode() and getPackageName()</strong>.</span> 597 <p> 598 * @see #getElementName() 599 * @see #getPackageName() 600 */ public 601 int getItemTypeCode() { 602 return libsbmlJNI.ListOfGroups_getItemTypeCode(swigCPtr, this); 603 } 604 605}