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