001/* ---------------------------------------------------------------------------- 002 * This file was automatically generated by SWIG (http://www.swig.org). 003 * Version 3.0.8 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 1, the SBML Level 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 * "<code>pi</code>", and the formula to be parsed is 055 * "<code>3*pi</code>", the MathML produced by the parser will 056 * contain the construct <code><ci> pi </ci></code> instead of 057 * the construct <code><pi/></code>. Another example, if the passed-in 058 * {@link Model} contains a {@link FunctionDefinition} with the identifier 059 * "<code>sin</code>", that function will be used instead of the 060 * predefined MathML function <code><sin/></code>. 061 * <li> The function <code>log</code> with a single argument 062 * ("<code>log(x)</code>") 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 * "<code>- -3</code>") 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 "<code>number id</code>" 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 3, MathML <code><cn></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, "<code>avogadro</code>" 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 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 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 3 packages 180 * will be assumed—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 ("<code>log(x)</code>") 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., "<code>- -3</code>") 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 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 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 ("<code>log(x)</code>") 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., "<code>- -3</code>") 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 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 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 ("<code>log(x)</code>") 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., "<code>- -3</code>") 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 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 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 * "<code>pi</code>", and the formula to be parsed is 473 * "<code>3*pi</code>", the MathML produced will contain the 474 * construct <code><ci> pi </ci></code> instead of the construct 475 * <code><pi/></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 * "<code>sin</code>", that function will be used instead of the 480 * predefined MathML function <code><sin/></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 * "<code>pi</code>", and the formula to be parsed is 508 * "<code>3*pi</code>", the MathML produced will contain the 509 * construct <code><ci> pi </ci></code> instead of the construct 510 * <code><pi/></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 * "<code>sin</code>", that function will be used instead of the 515 * predefined MathML function <code><sin/></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 * ("<code>log(x)</code>") 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 * ("<code>log(x)</code>") 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., "<code>- -3</code>") 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 "<code>- 4.1</code>" 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—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., "<code>- -3</code>") 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 "<code>- 4.1</code>" 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 2, there is no means of associating a unit of 674 * measurement with a pure number in a formula, while SBML Level 3 does 675 * define a syntax for this. In Level 3, MathML <code><cn></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: "<code>4 mL</code>", "<code>2.01 682 * Hz</code>", "<code>3.1e-6 M</code>", and "<code>(5/8) 683 * inches</code>". 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 2 of the SBML Level 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 2, there is no means of associating a unit of 712 * measurement with a pure number in a formula, while SBML Level 3 does 713 * define a syntax for this. In Level 3, MathML <code><cn></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: "<code>4 mL</code>", "<code>2.01 720 * Hz</code>", "<code>3.1e-6 M</code>", and "<code>(5/8) 721 * inches</code>". 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 2 of the SBML Level 3 specification. 724 <p> 725 * Since SBML Level 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 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 3 defines a symbol for representing the value of 753 * Avogadro's constant, but it is not defined in SBML Level 2. As a 754 * result, the text-string formula parser must behave differently 755 * depending on which SBML Level is being targeted. For Level 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 3 specification. For Level 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 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 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 3. 795 <p> 796 * <p> 797 * SBML Level 3 defines a symbol for representing the value of 798 * Avogadro's constant, but it is not defined in SBML Level 2. As a 799 * result, the text-string formula parser must behave differently 800 * depending on which SBML Level is being targeted. For Level 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 3 specification. For Level 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 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}