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