001/* ----------------------------------------------------------------------------
002 * This file was automatically generated by SWIG (http://www.swig.org).
003 * Version 2.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 *  A helper class for controlling the behavior of the
013 * text-string formula parser.
014 <p>
015 * <p style='color: #777; font-style: italic'>
016This class of objects is defined by libSBML only and has no direct
017equivalent in terms of SBML components.  This class is not prescribed by
018the SBML specifications, although it is used to implement features
019defined in SBML.
020</p>
021
022 <p>
023 * The function
024 * <code><a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'>libsbml.parseL3FormulaWithSettings(String formula, {@link L3ParserSettings} settings)</a></code>,
025 * along with its variants 
026 * <code><a href='libsbml.html#parseFormula(java.lang.String)'>libsbml.parseFormula(java.lang.String formula)</a></code>
027 * and
028 * <code><a href='libsbml.html#parseL3FormulaWithModel(java.lang.String, org.sbml.libsbml.Model)'>libsbml.parseL3FormulaWithModel(String formula, {@link Model} model)</a></code>,
029 * are the interfaces to a parser for mathematical formulas expressed as
030 * text strings.  The parser converts the text-string formulas into
031 * Abstract Syntax Trees (ASTs), represented in libSBML using {@link ASTNode}
032 * objects. Compared to the parser implemented by the function
033 * <code><a href='libsbml.html#parseFormula(java.lang.String)'>libsbml.parseFormula(java.lang.String formula)</a></code>,
034 * which was designed primarily for converting the mathematical formula
035 * strings in SBML Level&nbsp;1, the 'L3' variant of the parser accepts an
036 * extended formula syntax.  It also has a number of configurable behaviors.
037 * This class (L3ParserSettings) is an object used to communicate the
038 * configuration settings with callers.
039 <p>
040 * The following aspects of the parser are configurable:
041 * <ul>
042 * <li> The function <code>log</code> with a single argument (&quot;<code>log(x)</code>&quot;) 
043 * can be parsed as <code>log10(x)</code>, <code>ln(x)</code>, or treated
044 * as an error, as desired.
045 * <li> Unary minus signs can be collapsed or preserved; that is,
046 * sequential pairs of unary minuses (e.g., &quot;<code>- -3</code>&quot;)
047 * can be removed from the input entirely and single unary minuses can be
048 * incorporated into the number node, or all minuses can be preserved in
049 * the AST node structure.
050 * <li> Parsing of units embedded in the input string can be turned on and
051 * off.
052 * <li> The string <code>avogadro</code> can be parsed as a MathML <em>csymbol</em> or
053 * as an identifier.
054 * <li> A {@link Model} object may optionally be provided to the parser using
055 * the variant function call <code><a href='libsbml.html#parseL3FormulaWithModel(java.lang.String, org.sbml.libsbml.Model)'>libsbml.parseL3FormulaWithModel(String formula, {@link Model} model)</a></code>.
056 * or stored in a {@link L3ParserSettings} object passed to the variant function
057 * <code><a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'>libsbml.parseL3FormulaWithSettings(String formula, org.sbml.libsbml.L3ParserSettings settings)</a></code>.
058 * When a {@link Model} object is provided, identifiers (values of type <code>SId</code>)
059 * from that model are used in preference to pre-defined MathML
060 * definitions.  More precisely, the {@link Model} entities whose identifiers will
061 * shadow identical symbols in the mathematical formula are: {@link Species},
062 * {@link Compartment}, {@link Parameter}, {@link Reaction}, and {@link SpeciesReference}.  For instance,
063 * if the parser is given a {@link Model} containing a {@link Species} with the identifier
064 * &quot;<code>pi</code>&quot;, and the formula to be parsed is
065 * &quot;<code>3*pi</code>&quot;, the MathML produced will contain the
066 * construct <code>&lt;ci&gt; pi &lt;/ci&gt;</code> instead of the
067 * construct <code>&lt;pi/&gt;</code>.
068 * <li> Similarly, when a {@link Model} object is provided, <code>SId</code> values of
069 * user-defined functions present in the {@link Model} will be used preferentially
070 * over pre-defined MathML functions.  For example, if the passed-in {@link Model}
071 * contains a {@link FunctionDefinition} with the identifier
072 * &quot;<code>sin</code>&quot;, that function will be used instead of the
073 * predefined MathML function <code>&lt;sin/&gt;</code>.
074 * </ul>
075 <p>
076 * To obtain the default configuration values, callers can use the function
077 * <code><a href='libsbml.html#getDefaultL3ParserSettings()'>libsbml.getDefaultL3ParserSettings()</a></code>.
078 * To change the configuration, callers can create an {@link L3ParserSettings}
079 * object, set the desired characteristics using the methods
080 * provided, and pass that object to
081 * <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String formula, {@link L3ParserSettings} settings)</code></a>.
082 <p>
083 <p>
084 <p>
085 <p>
086 * @see <code><a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'>libsbml.parseL3FormulaWithSettings(String formula, L3ParserSettings settings)</a></code>
087 * @see <code><a href='libsbml.html#parseL3Formula(java.lang.String)'>libsbml.parseL3Formula(String formula)</a></code>
088 * @see <code><a href='libsbml.html#parseL3FormulaWithModel(java.lang.String, org.sbml.libsbml.Model)'>parseL3FormulaWithModel(String formula, Model model)</a></code>
089 */
090
091public class L3ParserSettings {
092   private long swigCPtr;
093   protected boolean swigCMemOwn;
094
095   protected L3ParserSettings(long cPtr, boolean cMemoryOwn)
096   {
097     swigCMemOwn = cMemoryOwn;
098     swigCPtr    = cPtr;
099   }
100
101   protected static long getCPtr(L3ParserSettings obj)
102   {
103     return (obj == null) ? 0 : obj.swigCPtr;
104   }
105
106   protected static long getCPtrAndDisown (L3ParserSettings obj)
107   {
108     long ptr = 0;
109
110     if (obj != null)
111     {
112       ptr             = obj.swigCPtr;
113       obj.swigCMemOwn = false;
114     }
115
116     return ptr;
117   }
118
119  protected void finalize() {
120    delete();
121  }
122
123  public synchronized void delete() {
124    if (swigCPtr != 0) {
125      if (swigCMemOwn) {
126        swigCMemOwn = false;
127        libsbmlJNI.delete_L3ParserSettings(swigCPtr);
128      }
129      swigCPtr = 0;
130    }
131  }
132
133  
134/**
135   * Creates a new {@link L3ParserSettings} object with default values.
136   <p>
137   * This is the default constructor for the {@link L3ParserSettings} object.  It
138   * sets the {@link Model} to <code>null</code> and other settings to 
139   * <code>L3P_PARSE_LOG_AS_LOG10</code>, <code>L3P_EXPAND_UNARY_MINUS</code>, <code>L3P_PARSE_UNITS</code>,
140   * and <code>L3P_AVOGADRO_IS_CSYMBOL.</code>
141   */ public
142 L3ParserSettings() {
143    this(libsbmlJNI.new_L3ParserSettings__SWIG_0(), true);
144  }
145
146  
147/**
148   * Creates a new {@link L3ParserSettings} object with specific values for all
149   * possible settings.
150   <p>
151   * @param model a {@link Model} object to be used for disambiguating identifiers
152   <p>
153   * @param parselog a flag that controls how the parser will handle
154   * the symbol <code>log</code> in formulas
155   <p>
156   * @param collapseminus a flag that controls how the parser will handle
157   * minus signs
158   <p>
159   * @param parseunits a flag that controls how the parser will handle
160   * apparent references to units of measurement associated with raw
161   * numbers in a formula
162   <p>
163   * @param avocsymbol a flag that controls how the parser will handle
164   * the appearance of the symbol <code>avogadro</code> in a formula
165   <p>
166   * @see #getModel()
167   * @see #setModel(Model model)
168   * @see #unsetModel()
169   * @see #getParseLog()
170   * @see #setParseLog(int type)
171   * @see #getParseUnits()
172   * @see #setParseUnits(boolean units)
173   * @see #getParseCollapseMinus()
174   * @see #setParseCollapseMinus(boolean collapseminus)
175   * @see #getParseAvogadroCsymbol()
176   * @see #setParseAvogadroCsymbol(boolean l2only)
177   */ public
178 L3ParserSettings(Model model, int parselog, boolean collapseminus, boolean parseunits, boolean avocsymbol) {
179    this(libsbmlJNI.new_L3ParserSettings__SWIG_1(Model.getCPtr(model), model, parselog, collapseminus, parseunits, avocsymbol), true);
180  }
181
182  
183/**
184   * Sets the model reference in this {@link L3ParserSettings} object.
185   <p>
186   * When a {@link Model} object is provided, identifiers (values of type <code>SId</code>)
187   * from that model are used in preference to pre-defined MathML
188   * definitions.  More precisely, the {@link Model} entities whose identifiers will
189   * shadow identical symbols in the mathematical formula are: {@link Species},
190   * {@link Compartment}, {@link Parameter}, {@link Reaction}, and {@link SpeciesReference}.  For instance,
191   * if the parser is given a {@link Model} containing a {@link Species} with the identifier
192   * &quot;<code>pi</code>&quot;, and the formula to be parsed is
193   * &quot;<code>3*pi</code>&quot;, the MathML produced will contain the
194   * construct <code>&lt;ci&gt; pi &lt;/ci&gt;</code> instead of the
195   * construct <code>&lt;pi/&gt;</code>.
196   * Similarly, when a {@link Model} object is provided, <code>SId</code> values of
197   * user-defined functions present in the {@link Model} will be used preferentially
198   * over pre-defined MathML functions.  For example, if the passed-in {@link Model}
199   * contains a {@link FunctionDefinition} with the identifier
200   * &quot;<code>sin</code>&quot;, that function will be used instead of the
201   * predefined MathML function <code>&lt;sin/&gt;</code>.
202   <p>
203   * @param model a {@link Model} object to be used for disambiguating identifiers
204   <p>
205   * @warning <span class='warning'>This does <em>not</em> copy the {@link Model} object.
206   * This means that modifications made to the object after invoking this
207   * method may affect parsing behavior.</span>
208   <p>
209   * @see #getModel()
210   * @see #unsetModel()
211   */ public
212 void setModel(Model model) {
213    libsbmlJNI.L3ParserSettings_setModel(swigCPtr, this, Model.getCPtr(model), model);
214  }
215
216  
217/**
218   * Returns the {@link Model} object referenced by this {@link L3ParserSettings} object.
219   <p>
220   * @see #setModel(Model model)
221   * @see #unsetModel()
222   */ public
223 Model getModel() {
224    long cPtr = libsbmlJNI.L3ParserSettings_getModel(swigCPtr, this);
225    return (cPtr == 0) ? null : new Model(cPtr, false);
226  }
227
228  
229/**
230   * Sets the {@link Model} reference in this {@link L3ParserSettings} object to <code>null.</code>
231   <p>
232   * @see #setModel(Model model)
233   * @see #getModel()
234   */ public
235 void unsetModel() {
236    libsbmlJNI.L3ParserSettings_unsetModel(swigCPtr, this);
237  }
238
239  
240/**
241   * Sets the behavior for handling <code>log</code> in mathematical formulas.
242   <p>
243   * The function <code>log</code> with a single argument
244   * (&quot;<code>log(x)</code>&quot;) can be parsed as
245   * <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
246   * desired.
247   <p>
248   * @param type a constant, one of following three possibilities:
249   * <ul>
250   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10}
251   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}
252   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}
253   *
254   * </ul> <p>
255   * @see #getParseLog()
256   */ public
257 void setParseLog(int type) {
258    libsbmlJNI.L3ParserSettings_setParseLog(swigCPtr, this, type);
259  }
260
261  
262/**
263   * Returns the current setting indicating what to do with formulas
264   * containing the function <code>log</code> with one argument.
265   <p>
266   * The function <code>log</code> with a single argument
267   * (&quot;<code>log(x)</code>&quot;) can be parsed as
268   * <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
269   * desired.
270   <p>
271   * @return One of following three constants:
272   * <ul>
273   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10}
274   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}
275   * <li> {@link  libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}
276   *
277   * </ul> <p>
278   * @see #setParseLog(int type)
279   */ public
280 int getParseLog() {
281    return libsbmlJNI.L3ParserSettings_getParseLog(swigCPtr, this);
282  }
283
284  
285/**
286   * Sets the behavior for handling unary minuses appearing in mathematical
287   * formulas.
288   <p>
289   * This setting affects two behaviors.  First, pairs of multiple unary
290   * minuses in a row (e.g., &quot;<code>- -3</code>&quot;) can be
291   * collapsed and ignored in the input, or the multiple minuses can be
292   * preserved in the AST node tree that is generated by the parser.
293   * Second, minus signs in front of numbers can be collapsed into the
294   * number node itself; for example, a &quot;<code>- 4.1</code>&quot; can
295   * be turned into a single {@link ASTNode} of type {@link  libsbmlConstants#AST_REAL
296   * AST_REAL} with a value of <code>-4.1</code>, or it can be
297   * turned into a node of type {@link  libsbmlConstants#AST_MINUS
298   * AST_MINUS} having a child node of type {@link 
299   * libsbmlConstants#AST_REAL AST_REAL}.  This method lets you tell
300   * the parser which behavior to use&mdash;either collapse minuses or
301   * always preserve them.  The two possibilities are represented using the
302   * following constants:
303   <p>
304   * <ul>
305   * <li> {@link  libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS
306   * L3P_COLLAPSE_UNARY_MINUS} (value = <code>true</code>): collapse unary
307   * minuses where possible.
308   * <li> {@link  libsbmlConstants#L3P_EXPAND_UNARY_MINUS
309   * L3P_EXPAND_UNARY_MINUS} (value = <code>false</code>): do not collapse
310   * unary minuses, and instead translate each one into an AST node of type
311   * {@link  libsbmlConstants#AST_MINUS AST_MINUS}.
312   *
313   * </ul> <p>
314   * @param collapseminus a boolean value (one of the constants
315   * {@link  libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS
316   * L3P_COLLAPSE_UNARY_MINUS} or
317   * {@link  libsbmlConstants#L3P_EXPAND_UNARY_MINUS
318   * L3P_EXPAND_UNARY_MINUS}) indicating how unary minus signs in
319   * the input should be handled.
320   <p>
321   * @see #getParseCollapseMinus()
322   */ public
323 void setParseCollapseMinus(boolean collapseminus) {
324    libsbmlJNI.L3ParserSettings_setParseCollapseMinus(swigCPtr, this, collapseminus);
325  }
326
327  
328/**
329   * Returns a flag indicating the current behavior set for handling
330   * multiple unary minuses in formulas.
331   <p>
332   * This setting affects two behaviors.  First, pairs of multiple unary
333   * minuses in a row (e.g., &quot;<code>- -3</code>&quot;) can be
334   * collapsed and ignored in the input, or the multiple minuses can be
335   * preserved in the AST node tree that is generated by the parser.
336   * Second, minus signs in front of numbers can be collapsed into the
337   * number node itself; for example, a &quot;<code>- 4.1</code>&quot; can
338   * be turned into a single {@link ASTNode} of type {@link  libsbmlConstants#AST_REAL
339   * AST_REAL} with a value of <code>-4.1</code>, or it can be
340   * turned into a node of type {@link  libsbmlConstants#AST_MINUS
341   * AST_MINUS} having a child node of type {@link 
342   * libsbmlConstants#AST_REAL AST_REAL}.  This method lets you tell
343   * the parser which behavior to use&mdash;either collapse minuses or
344   * always preserve them.  The two possibilities are represented using the
345   * following constants:
346   <p>
347   * <ul>
348   * <li> {@link  libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS
349   * L3P_COLLAPSE_UNARY_MINUS} (value = <code>true</code>): collapse unary
350   * minuses where possible.
351   * <li> {@link  libsbmlConstants#L3P_EXPAND_UNARY_MINUS
352   * L3P_EXPAND_UNARY_MINUS} (value = <code>false</code>): do not collapse
353   * unary minuses, and instead translate each one into an AST node of type
354   * {@link  libsbmlConstants#AST_MINUS AST_MINUS}.
355   *
356   * </ul> <p>
357   * @return A boolean, one of {@link 
358   * libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS
359   * L3P_COLLAPSE_UNARY_MINUS} or {@link 
360   * libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS}.
361   <p>
362   * @see #setParseCollapseMinus(boolean collapseminus)
363   */ public
364 boolean getParseCollapseMinus() {
365    return libsbmlJNI.L3ParserSettings_getParseCollapseMinus(swigCPtr, this);
366  }
367
368  
369/**
370   * Sets the parser's behavior in handling units associated with numbers
371   * in a mathematical formula.
372   <p>
373   * In SBML Level&nbsp;2, there is no means of associating a unit of
374   * measurement with a pure number in a formula, while SBML Level&nbsp;3
375   * does define a syntax for this.  In Level&nbsp;3, MathML
376   * <code>&lt;cn&gt;</code> elements can have an attribute named <code>units</code>
377   * placed in the SBML namespace, which can be used to indicate the units
378   * to be associated with the number.  The text-string infix formula
379   * parser allows units to be placed after raw numbers; they are
380   * interpreted as unit identifiers for units defined by the SBML
381   * specification or in the containing {@link Model} object.  Some examples
382   * include: &quot;<code>4 mL</code>&quot;, &quot;<code>2.01
383   * Hz</code>&quot;, &quot;<code>3.1e-6 M</code>&quot;, and
384   * &quot;<code>(5/8) inches</code>&quot;.  To produce a valid SBML model,
385   * there must either exist a {@link UnitDefinition} corresponding to the
386   * identifier of the unit, or the unit must be defined in Table&nbsp;2 of
387   * the SBML specification.
388   <p>
389   * @param units A boolean indicating whether to parse units:
390   * <ul>
391   * <li> {@link  libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}
392   * (value = <code>true</code>): parse units in the text-string formula.
393   * <li> {@link  libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS} (value = 
394   * <code>false</code>): treat units in the text-string formula as errors.
395   *
396   * </ul> <p>
397   * @see #getParseUnits()
398   */ public
399 void setParseUnits(boolean units) {
400    libsbmlJNI.L3ParserSettings_setParseUnits(swigCPtr, this, units);
401  }
402
403  
404/**
405   * Returns <code>if</code> the current settings allow units in text-string
406   * mathematical formulas.
407   <p>
408   * In SBML Level&nbsp;2, there is no means of associating a unit of
409   * measurement with a pure number in a formula, while SBML Level&nbsp;3
410   * does define a syntax for this.  In Level&nbsp;3, MathML
411   * <code>&lt;cn&gt;</code> elements can have an attribute named <code>units</code>
412   * placed in the SBML namespace, which can be used to indicate the units
413   * to be associated with the number.  The text-string infix formula
414   * parser allows units to be placed after raw numbers; they are
415   * interpreted as unit identifiers for units defined by the SBML
416   * specification or in the containing {@link Model} object.  Some examples
417   * include: &quot;<code>4 mL</code>&quot;, &quot;<code>2.01
418   * Hz</code>&quot;, &quot;<code>3.1e-6 M</code>&quot;, and
419   * &quot;<code>(5/8) inches</code>&quot;.  To produce a valid SBML model,
420   * there must either exist a {@link UnitDefinition} corresponding to the
421   * identifier of the unit, or the unit must be defined in Table&nbsp;2 of
422   * the SBML specification.
423   <p>
424   * Since SBML Level&nbsp;2 does not have the ability to associate units with
425   * pure numbers, the value should be set to <code>false</code> when parsing text-string
426   * formulas intended for use in SBML Level&nbsp;2 documents.
427   <p>
428   * @return A boolean indicating whether to parse units:
429   * <ul>
430   * <li> {@link  libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}
431   * (value = <code>true</code>): parse units in the text-string formula.
432   * <li> {@link  libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS} (value = 
433   * <code>false</code>): treat units in the text-string formula as errors.
434   *
435   * </ul> <p>
436   * @see #setParseUnits(boolean units)
437   */ public
438 boolean getParseUnits() {
439    return libsbmlJNI.L3ParserSettings_getParseUnits(swigCPtr, this);
440  }
441
442  
443/**
444   * Sets the parser's behavior in handling the string <code>avogadro</code> in
445   * mathematical formulas.
446   <p>
447   * SBML Level&nbsp;3 defines a symbol for representing the value of
448   * Avogadro's constant, but it is not defined in SBML Level&nbsp;2.  As a
449   * result, the text-string formula parser must behave differently
450   * depending on which SBML Level is being targeted.  The argument to this
451   * method can be one of two values:
452   <p>
453   * <ul>
454   * <li> {@link  libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL
455   * L3P_AVOGADRO_IS_CSYMBOL} (value = <code>true</code>): tells the parser to
456   * translate the string <code>avogadro</code> (in any capitalization) into an AST
457   * node of type {@link  libsbmlConstants#AST_NAME_AVOGADRO
458   * AST_NAME_AVOGADRO}.
459   * <li> {@link  libsbmlConstants#L3P_AVOGADRO_IS_NAME
460   * L3P_AVOGADRO_IS_NAME} (value = <code>false</code>): tells the parser to
461   * translate the string <code>avogadro</code> into an AST of type {@link 
462   * libsbmlConstants#AST_NAME AST_NAME}.
463   *
464   * </ul> <p>
465   * Since SBML Level&nbsp;2 does not define a symbol for Avogadro's
466   * constant, the value should be set to <code>false</code> when parsing text-string
467   * formulas intended for use in SBML Level&nbsp;2 documents.
468   <p>
469   * @param l2only a boolean value (one of the constants
470   * {@link  libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL
471   * L3P_AVOGADRO_IS_CSYMBOL} or
472   * {@link  libsbmlConstants#L3P_AVOGADRO_IS_NAME
473   * L3P_AVOGADRO_IS_NAME}) indicating how the string <code>avogadro</code>
474   * should be treated when encountered in a formula.
475   <p>
476   * @see #getParseAvogadroCsymbol()
477   */ public
478 void setParseAvogadroCsymbol(boolean l2only) {
479    libsbmlJNI.L3ParserSettings_setParseAvogadroCsymbol(swigCPtr, this, l2only);
480  }
481
482  
483/**
484   * Returns <code>true</code> if the current settings are oriented towards handling
485   * <code>avogadro</code> for SBML Level&nbsp;3.
486   <p>
487   * SBML Level&nbsp;3 defines a symbol for representing the value of
488   * Avogadro's constant, but it is not defined in SBML Level&nbsp;2.  As a
489   * result, the text-string formula parser must behave differently
490   * depending on which SBML Level is being targeted.
491   <p>
492   * @return A boolean indicating which mode is currently set; the value is
493   * one of the following possibilities:
494   * <ul>
495   * <li> {@link  libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL
496   * L3P_AVOGADRO_IS_CSYMBOL} (value = <code>true</code>): tells the parser to
497   * translate the string <code>avogadro</code> (in any capitalization) into an AST
498   * node of type {@link  libsbmlConstants#AST_NAME_AVOGADRO
499   * AST_NAME_AVOGADRO}.
500   * <li> {@link  libsbmlConstants#L3P_AVOGADRO_IS_NAME
501   * L3P_AVOGADRO_IS_NAME} (value = <code>false</code>): tells the parser to
502   * translate the string <code>avogadro</code> into an AST of type {@link 
503   * libsbmlConstants#AST_NAME AST_NAME}.
504   *
505   * </ul> <p>
506   * @see #setParseAvogadroCsymbol(boolean l2only)
507   */ public
508 boolean getParseAvogadroCsymbol() {
509    return libsbmlJNI.L3ParserSettings_getParseAvogadroCsymbol(swigCPtr, this);
510  }
511
512}