001/* ----------------------------------------------------------------------------
002 * This file was automatically generated by SWIG (http://www.swig.org).
003 * Version 3.0.10
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 *  Controls the behavior of the Level 3 formula parser.
013 <p>
014 * <p style='color: #777; font-style: italic'>
015This class of objects is defined by libSBML only and has no direct
016equivalent in terms of SBML components.  This class is not prescribed by
017the SBML specifications, although it is used to implement features
018defined in SBML.
019</p>
020
021 <p>
022 * The function
023 * <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String, L3ParserSettings)</code></a>,
024 * along with its variants <a href='libsbml.html#parseL3Formula(java.lang.String)'><code>libsbml.parseL3Formula(String)</code></a> and
025 * <a href='libsbml.html#parseL3FormulaWithModel(java.lang.String, org.sbml.libsbml.Model)'><code>libsbml.parseL3FormulaWithModel(String, Model)</code></a>,
026 * are the interfaces to a parser for mathematical formulas written as
027 * text strings.  The inverse function is <a href='libsbml.html#formulaToL3String(org.sbml.libsbml.ASTNode)'><code>libsbml.formulaToL3String(ASTNode)</code></a> and its variants such as
028 * <a href='libsbml.html#formulaToL3StringWithSettings(org.sbml.libsbml.ASTNode, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.formulaToL3StringWithSettings(ASTNode, L3ParserSettings)</code></a>.
029 * The parsers and the formula writers convert between a text-string
030 * representation of mathematical formulas and Abstract Syntax Trees (ASTs),
031 * represented in libSBML using {@link ASTNode} objects.
032 * Compared to the parser and writer implemented by the functions
033 * <a href='libsbml.html#parseFormula(java.lang.String)'><code>libsbml.parseFormula(String)</code></a> and
034 * <a href='libsbml.html#formulaToString(org.sbml.libsbml.ASTNode)'><code>libsbml.formulaToString(ASTNode)</code></a>,
035 * which were designed primarily for converting the mathematical formula
036 * strings in SBML Level&nbsp;1, the SBML Level&nbsp;3 or 'L3' variants of
037 * the parser and writer use an extended formula syntax.  They also have a
038 * number of configurable behaviors.  This class (L3ParserSettings) is an
039 * object used to communicate the configuration settings with callers.
040 <p>
041 * The following aspects of the parser are configurable using
042 * {@link L3ParserSettings} objects.  (For the formula writer, only a subset of these
043 * settings is relevant; please see the documentation for
044 * <a href='libsbml.html#formulaToL3StringWithSettings(org.sbml.libsbml.ASTNode, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.formulaToL3StringWithSettings(ASTNode, L3ParserSettings)</code></a> for more information about which ones).
045 <p>
046 * <p>
047 * <ul>
048 * <li> A {@link Model} object may optionally be provided to use identifiers (values
049 * of type <code>SId</code>) from the model in preference to pre-defined MathML symbols
050 * More precisely, the {@link Model} entities whose identifiers will shadow identical
051 * symbols in the mathematical formula are: {@link Species}, {@link Compartment}, {@link Parameter},
052 * {@link Reaction}, and {@link SpeciesReference}.  For instance, if the parser is given a
053 * {@link Model} containing a {@link Species} with the identifier
054 * &quot;<code>pi</code>&quot;, and the formula to be parsed is
055 * &quot;<code>3*pi</code>&quot;, the MathML produced by the parser will
056 * contain the construct <code>&lt;ci&gt; pi &lt;/ci&gt;</code> instead of
057 * the construct <code>&lt;pi/&gt;</code>.  Another example, if the passed-in
058 * {@link Model} contains a {@link FunctionDefinition} with the identifier
059 * &quot;<code>sin</code>&quot;, that function will be used instead of the
060 * predefined MathML function <code>&lt;sin/&gt;</code>.
061 * <li> The function <code>log</code> with a single argument
062 * (&quot;<code>log(x)</code>&quot;) can be parsed as <code>log10(x)</code>,
063 * <code>ln(x)</code>, or treated as an error, as desired.
064 * <li> Unary minus signs can be either collapsed or preserved; that is, the
065 * parser can either (1) remove sequential pairs of unary minuses (e.g.,
066 * &quot;<code>- -3</code>&quot;) from the input and incorporate single unary
067 * minuses into the number node, or (2) preserve all minuses in the AST node
068 * structure, turning them into {@link ASTNode} objects of type
069 * {@link libsbmlConstants#AST_MINUS AST_MINUS}.
070 * <li> The character sequence &quot;<code>number id</code>&quot; can be
071 * interpreted as a numerical value <code>number</code> followed by units of measurement
072 * indicated by <code>id</code>, or it can be treated as a syntax error.  (In
073 * Level&nbsp;3, MathML <code>&lt;cn&gt;</code> elements can have an
074 * attribute named <code>units</code> placed in the SBML namespace, which can be used
075 * to indicate the units to be associated with the number.  The text-string
076 * infix formula parser allows units to be placed after raw numbers; they are
077 * interpreted as unit identifiers for units defined by the SBML
078 * specification or in the containing {@link Model} object.)
079 * <li> The symbol <code>avogadro</code> can be parsed either as a MathML <em>csymbol</em> or
080 * as a identifier.  More specifically, &quot;<code>avogadro</code>&quot; can
081 * be treated as an {@link ASTNode} of type
082 * {@link libsbmlConstants#AST_NAME_AVOGADRO AST_NAME_AVOGADRO} or of type
083 * {@link libsbmlConstants#AST_NAME AST_NAME}.
084 * <li> Strings that match built-in functions and constants can either be parsed
085 * as a match regardless of capitalization, or may be required to be
086 * all-lower-case to be considered a match.
087 * <li> LibSBML plug-ins implementing support for SBML Level&nbsp;3 packages
088 * may introduce extensions to the syntax understood by the parser.  The
089 * precise nature of the extensions will be documented by the individual
090 * package plug-ins.  An example of a possible extension is a notation for
091 * vectors and arrays, introduced by the SBML Level&nbsp;3 <em>Arrays</em>
092 * package.
093 *
094 * </ul>
095 <p>
096 * To obtain the default configuration values, callers can use the function
097 * <a href='libsbml.html#getDefaultL3ParserSettings()'><code>libsbml.getDefaultL3ParserSettings()</code></a>.  To change the configuration,
098 * callers can create an {@link L3ParserSettings} object, set the desired
099 * characteristics using the methods provided, and pass that object to
100 * <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String formula, L3ParserSettings settings)</code></a>.
101 <p>
102 * @see <a href='libsbml.html#parseL3Formula(java.lang.String)'><code>libsbml.parseL3Formula(String)</code></a>
103 * @see <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String, L3ParserSettings)</code></a>
104 * @see <a href='libsbml.html#parseL3FormulaWithModel(java.lang.String, org.sbml.libsbml.Model)'><code>libsbml.parseL3FormulaWithModel(String, Model)</code></a>
105 * @see <a href='libsbml.html#parseFormula(java.lang.String)'><code>libsbml.parseFormula(String)</code></a>
106 * @see <a href='libsbml.html#formulaToL3StringWithSettings(org.sbml.libsbml.ASTNode, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.formulaToL3StringWithSettings(ASTNode, L3ParserSettings)</code></a>
107 * @see <a href='libsbml.html#formulaToL3String(org.sbml.libsbml.ASTNode)'><code>libsbml.formulaToL3String(ASTNode)</code></a>
108 * @see <a href='libsbml.html#formulaToString(org.sbml.libsbml.ASTNode)'><code>libsbml.formulaToString(ASTNode)</code></a>
109 * @see <a href='libsbml.html#getDefaultL3ParserSettings()'><code>libsbml.getDefaultL3ParserSettings()</code></a>
110 */
111
112public class L3ParserSettings {
113   private long swigCPtr;
114   protected boolean swigCMemOwn;
115
116   protected L3ParserSettings(long cPtr, boolean cMemoryOwn)
117   {
118     swigCMemOwn = cMemoryOwn;
119     swigCPtr    = cPtr;
120   }
121
122   protected static long getCPtr(L3ParserSettings obj)
123   {
124     return (obj == null) ? 0 : obj.swigCPtr;
125   }
126
127   protected static long getCPtrAndDisown (L3ParserSettings obj)
128   {
129     long ptr = 0;
130
131     if (obj != null)
132     {
133       ptr             = obj.swigCPtr;
134       obj.swigCMemOwn = false;
135     }
136
137     return ptr;
138   }
139
140  protected void finalize() {
141    delete();
142  }
143
144  public synchronized void delete() {
145    if (swigCPtr != 0) {
146      if (swigCMemOwn) {
147        swigCMemOwn = false;
148        libsbmlJNI.delete_L3ParserSettings(swigCPtr);
149      }
150      swigCPtr = 0;
151    }
152  }
153
154  
155/**
156   * Creates a new {@link L3ParserSettings} object with default values.
157   <p>
158   * This is the default constructor for the {@link L3ParserSettings} object.  It
159   * sets the stored {@link Model} object to <code>null</code> and sets the following
160   * field values in the {@link L3ParserSettings} object:
161   <p>
162   * <ul>
163   * <li> <em>parseunits</em> ('parse units') is set to
164   * {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}.
165   <p>
166   * <li> <em>collapseminus</em> ('collapse minus') is set to
167   * {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS}.
168   <p>
169   * <li> <em>parselog</em> ('parse log') is set to
170   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10}.
171   <p>
172   * <li> <em>avocsymbol</em> ('Avogadro csymbol') is set to
173   * {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL}.
174   <p>
175   * <li> <em>caseSensitive</em> ('case sensitive') is set to
176   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}.
177   <p>
178   * <li> <em>sbmlns</em> ('SBML namespaces') is set to <code>null</code> (which
179   * indicates that no syntax extensions due to SBML Level&nbsp;3 packages
180   * will be assumed&mdash;the formula parser will only understand the
181   * core syntax described in the documentation for
182   * <a href='libsbml.html#parseL3Formula(java.lang.String)'><code>libsbml.parseL3Formula(String)</code></a>).
183   * </ul>
184   */ public
185 L3ParserSettings() {
186    this(libsbmlJNI.new_L3ParserSettings__SWIG_0(), true);
187  }
188
189  
190/**
191   * Creates a new {@link L3ParserSettings} object with specific values for all
192   * possible settings.
193   <p>
194   * @param model a {@link Model} object to be used for disambiguating identifiers
195   * encountered by <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String, L3ParserSettings)</code></a> in mathematical formulas.
196   <p>
197   * @param parselog ('parse log') a flag that controls how the parser will
198   * handle the symbol <code>log</code> in mathematical formulas. The function <code>log</code>
199   * with a single argument (&quot;<code>log(x)</code>&quot;) can be parsed
200   * as <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
201   * desired, by using the parameter values
202   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10},
203   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}, or
204   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}, respectively.
205   <p>
206   * @param collapseminus ('collapse minus') a flag that controls how the
207   * parser will handle minus signs in formulas.  Unary minus signs can be
208   * collapsed or preserved; that is, sequential pairs of unary minuses
209   * (e.g., &quot;<code>- -3</code>&quot;) can be removed from the input
210   * entirely and single unary minuses can be incorporated into the number
211   * node, or all minuses can be preserved in the AST node structure.
212   * The possible values of this field are
213   * {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} (to collapse unary minuses) and
214   * {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS} (to expand unary minuses).
215   <p>
216   * @param parseunits ('parse units') a flag that controls how the parser
217   * will handle apparent references to units of measurement associated with
218   * raw numbers in a formula.  If set to the value
219   * {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}, units are parsed; if set to the value
220   * {@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS}, units are not parsed.
221   <p>
222   * @param avocsymbol ('Avogadro csymbol') a flag that controls how the
223   * parser will handle the appearance of the symbol <code>avogadro</code> in a
224   * formula.  If set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL},
225   * the symbol is interpreted as the SBML/MathML <em>csymbol</em> <code>avogadro</code>; if
226   * set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME}, the symbol is
227   * interpreted as a plain symbol name.
228   <p>
229   * @param caseSensitive ('case sensitive') a flag that controls how the
230   * cases of alphabetical characters are treated when symbols are compared.
231   * If the flag is set to the value
232   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}, symbols are
233   * compared in a case-insensitive manner, which means that mathematical
234   * functions such as <code>'sin'</code> will be matched no matter what their case is:
235   * <code>'Sin'</code>, <code>'SIN'</code>, etc.  If the flag is set to the value
236   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE}, symbols are
237   * interpreted in a case-sensitive manner.
238   <p>
239   * @param sbmlns ('SBML namespaces') an SBML namespaces object.  The
240   * namespaces identify the SBML Level&nbsp;3 packages that can extend the
241   * syntax understood by the formula parser.  When non-<code>null</code>, the parser
242   * will interpret additional syntax defined by the packages; for example,
243   * it may understand vector/array extensions introduced by the SBML
244   * Level&nbsp;3 <em>Arrays</em> package.
245   <p>
246   * 
247</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd>
248The native C++ implementation of this method defines a default argument
249value. In the documentation generated for different libSBML language
250bindings, you may or may not see corresponding arguments in the method
251declarations. For example, in Java and C#, a default argument is handled by
252declaring two separate methods, with one of them having the argument and
253the other one lacking the argument. However, the libSBML documentation will
254be <em>identical</em> for both methods. Consequently, if you are reading
255this and do not see an argument even though one is described, please look
256for descriptions of other variants of this method near where this one
257appears in the documentation.
258</dd></dl>
259 
260   <p>
261   * @see #getModel()
262   * @see #setModel(Model)
263   * @see #unsetModel()
264   * @see #getParseLog()
265   * @see #setParseLog(int)
266   * @see #getParseUnits()
267   * @see #setParseUnits(boolean)
268   * @see #getParseCollapseMinus()
269   * @see #setParseCollapseMinus(boolean)
270   * @see #getParseAvogadroCsymbol()
271   * @see #setParseAvogadroCsymbol(boolean)
272   */ public
273 L3ParserSettings(Model model, int parselog, boolean collapseminus, boolean parseunits, boolean avocsymbol, boolean caseSensitive, SBMLNamespaces sbmlns) {
274    this(libsbmlJNI.new_L3ParserSettings__SWIG_1(Model.getCPtr(model), model, parselog, collapseminus, parseunits, avocsymbol, caseSensitive, SBMLNamespaces.getCPtr(sbmlns), sbmlns), true);
275  }
276
277  
278/**
279   * Creates a new {@link L3ParserSettings} object with specific values for all
280   * possible settings.
281   <p>
282   * @param model a {@link Model} object to be used for disambiguating identifiers
283   * encountered by <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String, L3ParserSettings)</code></a> in mathematical formulas.
284   <p>
285   * @param parselog ('parse log') a flag that controls how the parser will
286   * handle the symbol <code>log</code> in mathematical formulas. The function <code>log</code>
287   * with a single argument (&quot;<code>log(x)</code>&quot;) can be parsed
288   * as <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
289   * desired, by using the parameter values
290   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10},
291   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}, or
292   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}, respectively.
293   <p>
294   * @param collapseminus ('collapse minus') a flag that controls how the
295   * parser will handle minus signs in formulas.  Unary minus signs can be
296   * collapsed or preserved; that is, sequential pairs of unary minuses
297   * (e.g., &quot;<code>- -3</code>&quot;) can be removed from the input
298   * entirely and single unary minuses can be incorporated into the number
299   * node, or all minuses can be preserved in the AST node structure.
300   * The possible values of this field are
301   * {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} (to collapse unary minuses) and
302   * {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS} (to expand unary minuses).
303   <p>
304   * @param parseunits ('parse units') a flag that controls how the parser
305   * will handle apparent references to units of measurement associated with
306   * raw numbers in a formula.  If set to the value
307   * {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}, units are parsed; if set to the value
308   * {@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS}, units are not parsed.
309   <p>
310   * @param avocsymbol ('Avogadro csymbol') a flag that controls how the
311   * parser will handle the appearance of the symbol <code>avogadro</code> in a
312   * formula.  If set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL},
313   * the symbol is interpreted as the SBML/MathML <em>csymbol</em> <code>avogadro</code>; if
314   * set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME}, the symbol is
315   * interpreted as a plain symbol name.
316   <p>
317   * @param caseSensitive ('case sensitive') a flag that controls how the
318   * cases of alphabetical characters are treated when symbols are compared.
319   * If the flag is set to the value
320   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}, symbols are
321   * compared in a case-insensitive manner, which means that mathematical
322   * functions such as <code>'sin'</code> will be matched no matter what their case is:
323   * <code>'Sin'</code>, <code>'SIN'</code>, etc.  If the flag is set to the value
324   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE}, symbols are
325   * interpreted in a case-sensitive manner.
326   <p>
327   * @param sbmlns ('SBML namespaces') an SBML namespaces object.  The
328   * namespaces identify the SBML Level&nbsp;3 packages that can extend the
329   * syntax understood by the formula parser.  When non-<code>null</code>, the parser
330   * will interpret additional syntax defined by the packages; for example,
331   * it may understand vector/array extensions introduced by the SBML
332   * Level&nbsp;3 <em>Arrays</em> package.
333   <p>
334   * 
335</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd>
336The native C++ implementation of this method defines a default argument
337value. In the documentation generated for different libSBML language
338bindings, you may or may not see corresponding arguments in the method
339declarations. For example, in Java and C#, a default argument is handled by
340declaring two separate methods, with one of them having the argument and
341the other one lacking the argument. However, the libSBML documentation will
342be <em>identical</em> for both methods. Consequently, if you are reading
343this and do not see an argument even though one is described, please look
344for descriptions of other variants of this method near where this one
345appears in the documentation.
346</dd></dl>
347 
348   <p>
349   * @see #getModel()
350   * @see #setModel(Model)
351   * @see #unsetModel()
352   * @see #getParseLog()
353   * @see #setParseLog(int)
354   * @see #getParseUnits()
355   * @see #setParseUnits(boolean)
356   * @see #getParseCollapseMinus()
357   * @see #setParseCollapseMinus(boolean)
358   * @see #getParseAvogadroCsymbol()
359   * @see #setParseAvogadroCsymbol(boolean)
360   */ public
361 L3ParserSettings(Model model, int parselog, boolean collapseminus, boolean parseunits, boolean avocsymbol, boolean caseSensitive) {
362    this(libsbmlJNI.new_L3ParserSettings__SWIG_2(Model.getCPtr(model), model, parselog, collapseminus, parseunits, avocsymbol, caseSensitive), true);
363  }
364
365  
366/**
367   * Creates a new {@link L3ParserSettings} object with specific values for all
368   * possible settings.
369   <p>
370   * @param model a {@link Model} object to be used for disambiguating identifiers
371   * encountered by <a href='libsbml.html#parseL3FormulaWithSettings(java.lang.String, org.sbml.libsbml.L3ParserSettings)'><code>libsbml.parseL3FormulaWithSettings(String, L3ParserSettings)</code></a> in mathematical formulas.
372   <p>
373   * @param parselog ('parse log') a flag that controls how the parser will
374   * handle the symbol <code>log</code> in mathematical formulas. The function <code>log</code>
375   * with a single argument (&quot;<code>log(x)</code>&quot;) can be parsed
376   * as <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
377   * desired, by using the parameter values
378   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10},
379   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}, or
380   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}, respectively.
381   <p>
382   * @param collapseminus ('collapse minus') a flag that controls how the
383   * parser will handle minus signs in formulas.  Unary minus signs can be
384   * collapsed or preserved; that is, sequential pairs of unary minuses
385   * (e.g., &quot;<code>- -3</code>&quot;) can be removed from the input
386   * entirely and single unary minuses can be incorporated into the number
387   * node, or all minuses can be preserved in the AST node structure.
388   * The possible values of this field are
389   * {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} (to collapse unary minuses) and
390   * {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS} (to expand unary minuses).
391   <p>
392   * @param parseunits ('parse units') a flag that controls how the parser
393   * will handle apparent references to units of measurement associated with
394   * raw numbers in a formula.  If set to the value
395   * {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS}, units are parsed; if set to the value
396   * {@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS}, units are not parsed.
397   <p>
398   * @param avocsymbol ('Avogadro csymbol') a flag that controls how the
399   * parser will handle the appearance of the symbol <code>avogadro</code> in a
400   * formula.  If set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL},
401   * the symbol is interpreted as the SBML/MathML <em>csymbol</em> <code>avogadro</code>; if
402   * set to the value {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME}, the symbol is
403   * interpreted as a plain symbol name.
404   <p>
405   * @param caseSensitive ('case sensitive') a flag that controls how the
406   * cases of alphabetical characters are treated when symbols are compared.
407   * If the flag is set to the value
408   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}, symbols are
409   * compared in a case-insensitive manner, which means that mathematical
410   * functions such as <code>'sin'</code> will be matched no matter what their case is:
411   * <code>'Sin'</code>, <code>'SIN'</code>, etc.  If the flag is set to the value
412   * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE}, symbols are
413   * interpreted in a case-sensitive manner.
414   <p>
415   * @param sbmlns ('SBML namespaces') an SBML namespaces object.  The
416   * namespaces identify the SBML Level&nbsp;3 packages that can extend the
417   * syntax understood by the formula parser.  When non-<code>null</code>, the parser
418   * will interpret additional syntax defined by the packages; for example,
419   * it may understand vector/array extensions introduced by the SBML
420   * Level&nbsp;3 <em>Arrays</em> package.
421   <p>
422   * 
423</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd>
424The native C++ implementation of this method defines a default argument
425value. In the documentation generated for different libSBML language
426bindings, you may or may not see corresponding arguments in the method
427declarations. For example, in Java and C#, a default argument is handled by
428declaring two separate methods, with one of them having the argument and
429the other one lacking the argument. However, the libSBML documentation will
430be <em>identical</em> for both methods. Consequently, if you are reading
431this and do not see an argument even though one is described, please look
432for descriptions of other variants of this method near where this one
433appears in the documentation.
434</dd></dl>
435 
436   <p>
437   * @see #getModel()
438   * @see #setModel(Model)
439   * @see #unsetModel()
440   * @see #getParseLog()
441   * @see #setParseLog(int)
442   * @see #getParseUnits()
443   * @see #setParseUnits(boolean)
444   * @see #getParseCollapseMinus()
445   * @see #setParseCollapseMinus(boolean)
446   * @see #getParseAvogadroCsymbol()
447   * @see #setParseAvogadroCsymbol(boolean)
448   */ public
449 L3ParserSettings(Model model, int parselog, boolean collapseminus, boolean parseunits, boolean avocsymbol) {
450    this(libsbmlJNI.new_L3ParserSettings__SWIG_3(Model.getCPtr(model), model, parselog, collapseminus, parseunits, avocsymbol), true);
451  }
452
453  
454/**
455   * Copy constructor.
456   */ public
457 L3ParserSettings(L3ParserSettings source) {
458    this(libsbmlJNI.new_L3ParserSettings__SWIG_4(L3ParserSettings.getCPtr(source), source), true);
459  }
460
461  
462/**
463   * Sets the model reference in this {@link L3ParserSettings} object.
464   <p>
465   * <p>
466 * When a {@link Model} object is provided, identifiers (values of type <code>SId</code>)
467 * from that model are used in preference to pre-defined MathML symbol
468 * definitions.  More precisely, the {@link Model} entities whose identifiers will
469 * shadow identical symbols in the mathematical formula are: {@link Species},
470 * {@link Compartment}, {@link Parameter}, {@link Reaction}, and {@link SpeciesReference}.  For instance, if
471 * the parser is given a {@link Model} containing a {@link Species} with the identifier
472 * &quot;<code>pi</code>&quot;, and the formula to be parsed is
473 * &quot;<code>3*pi</code>&quot;, the MathML produced will contain the
474 * construct <code>&lt;ci&gt; pi &lt;/ci&gt;</code> instead of the construct
475 * <code>&lt;pi/&gt;</code>.  Similarly, when a {@link Model} object is provided, 
476 * <code>SId</code> values of user-defined functions present in the {@link Model} will be used
477 * preferentially over pre-defined MathML functions.  For example, if the
478 * passed-in {@link Model} contains a {@link FunctionDefinition} with the identifier
479 * &quot;<code>sin</code>&quot;, that function will be used instead of the
480 * predefined MathML function <code>&lt;sin/&gt;</code>.
481   <p>
482   * @param model a {@link Model} object to be used for disambiguating identifiers.
483   <p>
484   * @warning <span class='warning'>This does <em>not</em> copy the {@link Model} object.
485   * This means that modifications made to the {@link Model} after invoking this
486   * method may affect parsing behavior, because the parser will query the
487   * <em>current</em> contents of the model.</span>
488   <p>
489   * @see #getModel()
490   * @see #unsetModel()
491   */ public
492 void setModel(Model model) {
493    libsbmlJNI.L3ParserSettings_setModel(swigCPtr, this, Model.getCPtr(model), model);
494  }
495
496  
497/**
498   * Returns the {@link Model} object referenced by this {@link L3ParserSettings} object.
499   <p>
500   * <p>
501 * When a {@link Model} object is provided, identifiers (values of type <code>SId</code>)
502 * from that model are used in preference to pre-defined MathML symbol
503 * definitions.  More precisely, the {@link Model} entities whose identifiers will
504 * shadow identical symbols in the mathematical formula are: {@link Species},
505 * {@link Compartment}, {@link Parameter}, {@link Reaction}, and {@link SpeciesReference}.  For instance, if
506 * the parser is given a {@link Model} containing a {@link Species} with the identifier
507 * &quot;<code>pi</code>&quot;, and the formula to be parsed is
508 * &quot;<code>3*pi</code>&quot;, the MathML produced will contain the
509 * construct <code>&lt;ci&gt; pi &lt;/ci&gt;</code> instead of the construct
510 * <code>&lt;pi/&gt;</code>.  Similarly, when a {@link Model} object is provided, 
511 * <code>SId</code> values of user-defined functions present in the {@link Model} will be used
512 * preferentially over pre-defined MathML functions.  For example, if the
513 * passed-in {@link Model} contains a {@link FunctionDefinition} with the identifier
514 * &quot;<code>sin</code>&quot;, that function will be used instead of the
515 * predefined MathML function <code>&lt;sin/&gt;</code>.
516   <p>
517   * @see #setModel(Model)
518   * @see #unsetModel()
519   */ public
520 Model getModel() {
521    long cPtr = libsbmlJNI.L3ParserSettings_getModel(swigCPtr, this);
522    return (cPtr == 0) ? null : new Model(cPtr, false);
523  }
524
525  
526/**
527   * Unsets the {@link Model} reference in this {@link L3ParserSettings} object.
528   <p>
529   * The effect of calling this method is to set the stored model value
530   * to <code>null.</code>
531   <p>
532   * @see #setModel(Model)
533   * @see #getModel()
534   */ public
535 void unsetModel() {
536    libsbmlJNI.L3ParserSettings_unsetModel(swigCPtr, this);
537  }
538
539  
540/**
541   * Sets the behavior for handling <code>log</code> in mathematical formulas.
542   <p>
543   * The function <code>log</code> with a single argument
544   * (&quot;<code>log(x)</code>&quot;) can be parsed as
545   * <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error.
546   * These three behaviors are set, respectively, by using the value
547   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10},
548   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}, or
549   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}
550   * for the <code>type</code> parameter.
551   <p>
552   * @param type a constant, one of following three possibilities:
553   * <ul>
554   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10}
555   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}
556   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}
557   *
558   * </ul> <p>
559   * @see #getParseLog()
560   */ public
561 void setParseLog(int type) {
562    libsbmlJNI.L3ParserSettings_setParseLog(swigCPtr, this, type);
563  }
564
565  
566/**
567   * Indicates the current behavior set for handling the function <code>log</code> with
568   * one argument.
569   <p>
570   * The function <code>log</code> with a single argument
571   * (&quot;<code>log(x)</code>&quot;) can be parsed as
572   * <code>log10(x)</code>, <code>ln(x)</code>, or treated as an error, as
573   * desired.  These three possible behaviors are indicated, respectively, by
574   * the values
575   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10},
576   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}, and
577   * {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}.
578   <p>
579   * @return One of following three constants:
580   * <ul>
581   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LOG10}
582   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_LN}
583   * <li> {@link libsbmlConstants#L3P_PARSE_LOG_AS_ERROR L3P_PARSE_LOG_AS_ERROR}
584   *
585   * </ul> <p>
586   * @see #setParseLog(int)
587   */ public
588 int getParseLog() {
589    return libsbmlJNI.L3ParserSettings_getParseLog(swigCPtr, this);
590  }
591
592  
593/**
594   * Sets the behavior for handling unary minuses appearing in mathematical
595   * formulas.
596   <p>
597   * <p>
598 * This setting affects two behaviors.  First, pairs of multiple unary
599 * minuses in a row (e.g., &quot;<code>- -3</code>&quot;) can be collapsed
600 * and ignored in the input, or the multiple minuses can be preserved in the
601 * AST node tree that is generated by the parser.  Second, minus signs in
602 * front of numbers can be collapsed into the number node itself; for
603 * example, a &quot;<code>- 4.1</code>&quot; can be turned into a single
604 * {@link ASTNode} of type {@link libsbmlConstants#AST_REAL AST_REAL} with a value of
605 * <code>-4.1</code>, or it can be turned into a node of type
606 * {@link libsbmlConstants#AST_MINUS AST_MINUS} having a child node of type
607 * {@link libsbmlConstants#AST_REAL AST_REAL}.
608   <p>
609   * This method lets you tell the parser which behavior to use&mdash;either
610   * collapse minuses or always preserve them.  The two possibilities are
611   * represented using the following constants:
612   <p>
613   * <p>
614 * <ul>
615 * <li> {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} (value = <code>true</code>): collapse
616 * unary minuses where possible.
617 * <li> {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS} (value = <code>false</code>): do not
618 * collapse unary minuses, and instead translate each one into an AST node of
619 * type {@link libsbmlConstants#AST_MINUS AST_MINUS}.
620 * </ul>
621   <p>
622   * @param collapseminus a boolean value (one of the constants
623   * {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} or
624   * {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS})
625   * indicating how unary minus signs in the input should be handled.
626   <p>
627   * @see #getParseCollapseMinus()
628   */ public
629 void setParseCollapseMinus(boolean collapseminus) {
630    libsbmlJNI.L3ParserSettings_setParseCollapseMinus(swigCPtr, this, collapseminus);
631  }
632
633  
634/**
635   * Indicates the current behavior set for handling multiple unary minuses
636   * in formulas.
637   <p>
638   * <p>
639 * This setting affects two behaviors.  First, pairs of multiple unary
640 * minuses in a row (e.g., &quot;<code>- -3</code>&quot;) can be collapsed
641 * and ignored in the input, or the multiple minuses can be preserved in the
642 * AST node tree that is generated by the parser.  Second, minus signs in
643 * front of numbers can be collapsed into the number node itself; for
644 * example, a &quot;<code>- 4.1</code>&quot; can be turned into a single
645 * {@link ASTNode} of type {@link libsbmlConstants#AST_REAL AST_REAL} with a value of
646 * <code>-4.1</code>, or it can be turned into a node of type
647 * {@link libsbmlConstants#AST_MINUS AST_MINUS} having a child node of type
648 * {@link libsbmlConstants#AST_REAL AST_REAL}.
649   <p>
650   * @return A boolean indicating the behavior currently set.  The possible
651   * values are as follows:
652   * <p>
653 * <ul>
654 * <li> {@link libsbmlConstants#L3P_COLLAPSE_UNARY_MINUS L3P_COLLAPSE_UNARY_MINUS} (value = <code>true</code>): collapse
655 * unary minuses where possible.
656 * <li> {@link libsbmlConstants#L3P_EXPAND_UNARY_MINUS L3P_EXPAND_UNARY_MINUS} (value = <code>false</code>): do not
657 * collapse unary minuses, and instead translate each one into an AST node of
658 * type {@link libsbmlConstants#AST_MINUS AST_MINUS}.
659 * </ul>
660   <p>
661   * @see #setParseCollapseMinus(boolean)
662   */ public
663 boolean getParseCollapseMinus() {
664    return libsbmlJNI.L3ParserSettings_getParseCollapseMinus(swigCPtr, this);
665  }
666
667  
668/**
669   * Sets the parser's behavior in handling units associated with numbers
670   * in a mathematical formula.
671   <p>
672   * <p>
673 * In SBML Level&nbsp;2, there is no means of associating a unit of
674 * measurement with a pure number in a formula, while SBML Level&nbsp;3 does
675 * define a syntax for this.  In Level&nbsp;3, MathML <code>&lt;cn&gt;</code>
676 * elements can have an attribute named <code>units</code> placed in the SBML
677 * namespace, which can be used to indicate the units to be associated with
678 * the number.  The text-string infix formula parser allows units to be
679 * placed after raw numbers; they are interpreted as unit identifiers for
680 * units defined by the SBML specification or in the containing {@link Model} object.
681 * Some examples include: &quot;<code>4 mL</code>&quot;, &quot;<code>2.01
682 * Hz</code>&quot;, &quot;<code>3.1e-6 M</code>&quot;, and &quot;<code>(5/8)
683 * inches</code>&quot;.  To produce a valid SBML model, there must either
684 * exist a {@link UnitDefinition} corresponding to the identifier of the unit, or the
685 * unit must be defined in Table&nbsp;2 of the SBML Level&nbsp;3 specification.
686   <p>
687   * This method sets the formula parser's behavior with respect to units.
688   <p>
689   * @param units A boolean indicating whether to parse units.  The
690   * possible values are as follows:
691   * <p>
692 * <ul>
693 * <li> {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS} (value = <code>true</code>): parse units in the
694 * text-string formula.
695 * <li> {@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS} (value = <code>false</code>): treat units in the
696 * text-string formula as errors.
697 * </ul>
698   <p>
699   * @see #getParseUnits()
700   */ public
701 void setParseUnits(boolean units) {
702    libsbmlJNI.L3ParserSettings_setParseUnits(swigCPtr, this, units);
703  }
704
705  
706/**
707   * Indicates the current behavior set for handling units in text-string
708   * mathematical formulas.
709   <p>
710   * <p>
711 * In SBML Level&nbsp;2, there is no means of associating a unit of
712 * measurement with a pure number in a formula, while SBML Level&nbsp;3 does
713 * define a syntax for this.  In Level&nbsp;3, MathML <code>&lt;cn&gt;</code>
714 * elements can have an attribute named <code>units</code> placed in the SBML
715 * namespace, which can be used to indicate the units to be associated with
716 * the number.  The text-string infix formula parser allows units to be
717 * placed after raw numbers; they are interpreted as unit identifiers for
718 * units defined by the SBML specification or in the containing {@link Model} object.
719 * Some examples include: &quot;<code>4 mL</code>&quot;, &quot;<code>2.01
720 * Hz</code>&quot;, &quot;<code>3.1e-6 M</code>&quot;, and &quot;<code>(5/8)
721 * inches</code>&quot;.  To produce a valid SBML model, there must either
722 * exist a {@link UnitDefinition} corresponding to the identifier of the unit, or the
723 * unit must be defined in Table&nbsp;2 of the SBML Level&nbsp;3 specification.
724   <p>
725   * Since SBML Level&nbsp;2 does not have the ability to associate units
726   * with pure numbers, the value should be expected to be <code>false</code>
727   * ({@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS}) when parsing text-string
728   * formulas intended for use in SBML Level&nbsp;2 documents.
729   <p>
730   * @return A boolean indicating whether to parse units.  The
731   * possible values are as follows:
732   * <p>
733 * <ul>
734 * <li> {@link libsbmlConstants#L3P_PARSE_UNITS L3P_PARSE_UNITS} (value = <code>true</code>): parse units in the
735 * text-string formula.
736 * <li> {@link libsbmlConstants#L3P_NO_UNITS L3P_NO_UNITS} (value = <code>false</code>): treat units in the
737 * text-string formula as errors.
738 * </ul>
739   <p>
740   * @see #setParseUnits(boolean)
741   */ public
742 boolean getParseUnits() {
743    return libsbmlJNI.L3ParserSettings_getParseUnits(swigCPtr, this);
744  }
745
746  
747/**
748   * Sets the parser's behavior in handling the symbol <code>avogadro</code> in
749   * mathematical formulas.
750   <p>
751   * <p>
752 * SBML Level&nbsp;3 defines a symbol for representing the value of
753 * Avogadro's constant, but it is not defined in SBML Level&nbsp;2.  As a
754 * result, the text-string formula parser must behave differently
755 * depending on which SBML Level is being targeted.  For Level&nbsp;3
756 * documents, it can interpret instances of <code>avogadro</code> in the input
757 * as a reference to the MathML <em>csymbol</em> for Avogadro's constant
758 * defined in the SBML Level&nbsp;3 specification.  For Level&nbsp;2,
759 * it must treat <code>avogadro</code> as just another plain symbol.
760   <p>
761   * This method allows callers to set the <code>avogadro</code>-handling
762   * behavior in this {@link L3ParserSettings} object.  The possible values of 
763   * <code>l2only</code> are as follows:
764   <p>
765   * <p>
766 * <ul>
767 * <li> {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL} (value = <code>true</code>): tells the
768 * parser to translate the string <code>avogadro</code> (in any capitalization) into an
769 * AST node of type {@link libsbmlConstants#AST_NAME_AVOGADRO AST_NAME_AVOGADRO}.
770 * <li> {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME} (value = <code>false</code>): tells the
771 * parser to translate the string <code>avogadro</code> into an AST of type
772 * {@link libsbmlConstants#AST_NAME AST_NAME}.
773 * </ul>
774   <p>
775   * Since SBML Level&nbsp;2 does not define a symbol for Avogadro's
776   * constant, the value should be set to
777   * {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME} when parsing text-string formulas
778   * intended for use in SBML Level&nbsp;2 documents.
779   <p>
780   * @param l2only a boolean value indicating how the string <code>avogadro</code>
781   * should be treated when encountered in a formula.  This will be one of
782   * the values {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL} or
783   * {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME}.
784   <p>
785   * @see #getParseAvogadroCsymbol()
786   */ public
787 void setParseAvogadroCsymbol(boolean l2only) {
788    libsbmlJNI.L3ParserSettings_setParseAvogadroCsymbol(swigCPtr, this, l2only);
789  }
790
791  
792/**
793   * Indicates the current behavior set for handling <code>avogadro</code> for SBML
794   * Level&nbsp;3.
795   <p>
796   * <p>
797 * SBML Level&nbsp;3 defines a symbol for representing the value of
798 * Avogadro's constant, but it is not defined in SBML Level&nbsp;2.  As a
799 * result, the text-string formula parser must behave differently
800 * depending on which SBML Level is being targeted.  For Level&nbsp;3
801 * documents, it can interpret instances of <code>avogadro</code> in the input
802 * as a reference to the MathML <em>csymbol</em> for Avogadro's constant
803 * defined in the SBML Level&nbsp;3 specification.  For Level&nbsp;2,
804 * it must treat <code>avogadro</code> as just another plain symbol.
805   <p>
806   * This method returns the current setting of the
807   * <code>avogadro</code>-handling behavior in this {@link L3ParserSettings} object.
808   * The possible values are as follows:
809   <p>
810   * <p>
811 * <ul>
812 * <li> {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL} (value = <code>true</code>): tells the
813 * parser to translate the string <code>avogadro</code> (in any capitalization) into an
814 * AST node of type {@link libsbmlConstants#AST_NAME_AVOGADRO AST_NAME_AVOGADRO}.
815 * <li> {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME} (value = <code>false</code>): tells the
816 * parser to translate the string <code>avogadro</code> into an AST of type
817 * {@link libsbmlConstants#AST_NAME AST_NAME}.
818 * </ul>
819   <p>
820   * @return A boolean indicating which mode is currently set; one of
821   * {@link libsbmlConstants#L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_CSYMBOL}
822   * or
823   * {@link libsbmlConstants#L3P_AVOGADRO_IS_NAME L3P_AVOGADRO_IS_NAME}.
824   <p>
825   * @see #setParseAvogadroCsymbol(boolean)
826   */ public
827 boolean getParseAvogadroCsymbol() {
828    return libsbmlJNI.L3ParserSettings_getParseAvogadroCsymbol(swigCPtr, this);
829  }
830
831  
832/**
833   * Sets the parser's behavior with respect to case sensitivity for
834   * recognizing predefined symbols.
835   <p>
836   * <p>
837 * By default (which is the value
838 * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}), the parser
839 * compares symbols in a case <em>insensitive</em> manner for built-in functions
840 * such as <code>'sin'</code> and <code>'piecewise'</code>, and for constants such as <code>'true'</code>
841 * and <code>'avogadro'.</code>  Setting this option to
842 * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE} causes the parser to
843 * become case sensitive.  In that mode, for example, the symbols <code>'sin'</code>
844 * and <code>'true'</code> will match the built-in values, but the symbols <code>'SIN'</code>,
845 * <code>'Sin'</code>, <code>'True'</code>, <code>'TRUE'</code>, and so on, will not.
846   <p>
847   * @param strcmp a boolean indicating whether to be case sensitive (if 
848   * <code>true</code>) or be case insensitive (if <code>false</code>).
849   <p>
850   * @see #getComparisonCaseSensitivity()
851   */ public
852 void setComparisonCaseSensitivity(boolean strcmp) {
853    libsbmlJNI.L3ParserSettings_setComparisonCaseSensitivity(swigCPtr, this, strcmp);
854  }
855
856  
857/**
858   * Returns <code>true</code> if the parser is configured to match built-in symbols
859   * in a case-insensitive way.
860   <p>
861   * <p>
862 * By default (which is the value
863 * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_INSENSITIVE}), the parser
864 * compares symbols in a case <em>insensitive</em> manner for built-in functions
865 * such as <code>'sin'</code> and <code>'piecewise'</code>, and for constants such as <code>'true'</code>
866 * and <code>'avogadro'.</code>  Setting this option to
867 * {@link libsbmlConstants#L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE} causes the parser to
868 * become case sensitive.  In that mode, for example, the symbols <code>'sin'</code>
869 * and <code>'true'</code> will match the built-in values, but the symbols <code>'SIN'</code>,
870 * <code>'Sin'</code>, <code>'True'</code>, <code>'TRUE'</code>, and so on, will not.
871   <p>
872   * @return <code>true</code> if matches are done in a case-sensitive manner, and 
873   * <code>false</code> if the parser will recognize built-in functions and
874   * constants regardless of case,.
875   <p>
876   * @see #setComparisonCaseSensitivity(boolean)
877   */ public
878 boolean getComparisonCaseSensitivity() {
879    return libsbmlJNI.L3ParserSettings_getComparisonCaseSensitivity(swigCPtr, this);
880  }
881
882  
883/**
884   * Set up the plugins for this {@link L3ParserSettings}, based on the
885   * {@link SBMLNamespaces} object.
886   <p>
887   * When a {@link SBMLNamespaces} object is provided, the parser will only interpret
888   * infix syntax understood by the core libSBML <em>plus</em> the packages
889   * indicated by the {@link SBMLNamespaces} objects provided.  {@link ASTNode} objects
890   * returned by the L3Parser will contain those {@link SBMLNamespaces} objects, and
891   * will be used to parse certain constructs that may only be understood by
892   * packages (e.g., vectors for the SBML Level&nbsp;3 'arrays' package).
893   * Note that by default, all packages that were compiled with this version
894   * of libSBML are included, so this function is most useful as a way to
895   * turn <em>off</em> certain namespaces, such as might be desired if your tool
896   * does not support vectors, for example.
897   <p>
898   * @param sbmlns a {@link SBMLNamespaces} object to be used.  If <code>null</code> is given
899   * as the value, all plugins will be loaded.
900   */ public
901 void setPlugins(SBMLNamespaces sbmlns) {
902    libsbmlJNI.L3ParserSettings_setPlugins(swigCPtr, this, SBMLNamespaces.getCPtr(sbmlns), sbmlns);
903  }
904
905  
906/** * @internal */ public
907 void visitPackageInfixSyntax(ASTNode parent, ASTNode node, SWIGTYPE_p_StringBuffer_t sb) {
908    libsbmlJNI.L3ParserSettings_visitPackageInfixSyntax(swigCPtr, this, ASTNode.getCPtr(parent), parent, ASTNode.getCPtr(node), node, SWIGTYPE_p_StringBuffer_t.getCPtr(sb));
909  }
910
911}