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