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