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 * Log of errors and other events encountered during SBML 013 * processing. 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 error log is a list. Each {@link SBMLDocument} maintains its own 024 * {@link SBMLErrorLog}. When a libSBML operation on SBML content results in an 025 * error, or when there is something worth noting about the SBML content, 026 * the issue is reported as an {@link SBMLError} object stored in the {@link SBMLErrorLog} 027 * list. 028 <p> 029 * {@link SBMLErrorLog} is derived from {@link XMLErrorLog}, an object class that serves 030 * exactly the same purpose but for the XML parsing layer. {@link XMLErrorLog} 031 * provides crucial methods such as 032 * {@link XMLErrorLog#getNumErrors()} 033 * for determining how many {@link SBMLError} or {@link XMLError} objects are in the log. 034 * {@link SBMLErrorLog} inherits these methods. 035 <p> 036 * The general approach to working with {@link SBMLErrorLog} in user programs 037 * involves first obtaining a pointer to a log from a libSBML object such 038 * as {@link SBMLDocument}. Callers should then use 039 * {@link XMLErrorLog#getNumErrors()} to inquire how 040 * many objects there are in the list. (The answer may be 0.) If there is 041 * at least one {@link SBMLError} object in the {@link SBMLErrorLog} instance, callers can 042 * then iterate over the list using 043 * {@link SBMLErrorLog#getError(long n)}, 044 * using methods provided by the {@link SBMLError} class to find out the error code 045 * and associated information such as the error severity, the message, and 046 * the line number in the input. 047 <p> 048 * If you wish to simply print the error strings for a human to read, an 049 * easier and more direct way might be to use {@link SBMLDocument#printErrors()}. 050 <p> 051 * @see SBMLError 052 * @see XMLErrorLog 053 * @see XMLError 054 */ 055 056public class SBMLErrorLog extends XMLErrorLog { 057 private long swigCPtr; 058 059 protected SBMLErrorLog(long cPtr, boolean cMemoryOwn) 060 { 061 super(libsbmlJNI.SBMLErrorLog_SWIGUpcast(cPtr), cMemoryOwn); 062 swigCPtr = cPtr; 063 } 064 065 protected static long getCPtr(SBMLErrorLog obj) 066 { 067 return (obj == null) ? 0 : obj.swigCPtr; 068 } 069 070 protected static long getCPtrAndDisown (SBMLErrorLog obj) 071 { 072 long ptr = 0; 073 074 if (obj != null) 075 { 076 ptr = obj.swigCPtr; 077 obj.swigCMemOwn = false; 078 } 079 080 return ptr; 081 } 082 083 protected void finalize() { 084 delete(); 085 } 086 087 public synchronized void delete() { 088 if (swigCPtr != 0) { 089 if (swigCMemOwn) { 090 swigCMemOwn = false; 091 libsbmlJNI.delete_SBMLErrorLog(swigCPtr); 092 } 093 swigCPtr = 0; 094 } 095 super.delete(); 096 } 097 098 099/** 100 * Returns the <i>n</i>th {@link SBMLError} object in this log. 101 <p> 102 * Index <code>n</code> is counted from 0. Callers should first inquire about the 103 * number of items in the log by using the 104 * {@link XMLErrorLog#getNumErrors()} method. 105 * Attempts to use an error index number that exceeds the actual number 106 * of errors in the log will result in a <code>null</code> being returned. 107 <p> 108 * @param n the index number of the error to retrieve (with 0 being the 109 * first error). 110 <p> 111 * @return the <i>n</i>th {@link SBMLError} in this log, or <code>null</code> if <code>n</code> is 112 * greater than or equal to 113 * {@link XMLErrorLog#getNumErrors()}. 114 <p> 115 * @see #getNumErrors() 116 */ public 117 SBMLError getError(long n) { 118 long cPtr = libsbmlJNI.SBMLErrorLog_getError(swigCPtr, this, n); 119 return (cPtr == 0) ? null : new SBMLError(cPtr, false); 120 } 121 122 123/** 124 * Returns the number of errors that have been logged with the given 125 * severity code. 126 <p> 127 * <p> 128 * LibSBML associates severity levels with every {@link SBMLError} object to 129 * provide an indication of how serious the problem is. Severities range 130 * from informational diagnostics to fatal (irrecoverable) errors. Given 131 * an {@link SBMLError} object instance, a caller can interrogate it for its 132 * severity level using methods such as {@link SBMLError#getSeverity()}, 133 * {@link SBMLError#isFatal()}, and so on. The present method encapsulates 134 * iteration and interrogation of all objects in an {@link SBMLErrorLog}, making 135 * it easy to check for the presence of error objects with specific 136 * severity levels. 137 <p> 138 * @param severity a 139 * value from the set of <code>LIBSBML_SEV_</code> constants defined by 140 * the interface class <code><a 141 * href='libsbmlConstants.html'>libsbmlConstants</a></code> 142 <p> 143 * @return a count of the number of errors with the given severity code. 144 <p> 145 * @see #getNumErrors() 146 */ public 147 long getNumFailsWithSeverity(long severity) { 148 return libsbmlJNI.SBMLErrorLog_getNumFailsWithSeverity__SWIG_0(swigCPtr, this, severity); 149 } 150 151 152/** 153 * Creates a new, empty {@link SBMLErrorLog}. 154 * @internal 155 */ public 156 SBMLErrorLog() { 157 this(libsbmlJNI.new_SBMLErrorLog__SWIG_0(), true); 158 } 159 160 161/** 162 * Copy Constructor 163 * @internal 164 */ public 165 SBMLErrorLog(SBMLErrorLog other) { 166 this(libsbmlJNI.new_SBMLErrorLog__SWIG_1(SBMLErrorLog.getCPtr(other), other), true); 167 } 168 169 170/** 171 * Convenience function that combines creating an {@link SBMLError} object and 172 * adding it to the log. 173 <p> 174 * @param errorId a long integer, the identification number of the error. 175 <p> 176 * @param level a long integer, the SBML Level 177 <p> 178 * @param version a long integer, the SBML Level's Version 179 <p> 180 * @param details a string containing additional details about the error. 181 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 182 * the given message is <em>appended</em> to a predefined message associated 183 * with the given code. If the error code is not recognized, the message 184 * is stored as-is as the text of the error. 185 <p> 186 * @param line a long integer, the line number at which the error occured. 187 <p> 188 * @param column a long integer, the column number at which the error occured. 189 <p> 190 * @param severity an integer indicating severity of the error. 191 <p> 192 * @param category an integer indicating the category to which the error 193 * belongs. 194 <p> 195 * 196</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 197The native C++ implementation of this method defines a default argument 198value. In the documentation generated for different libSBML language 199bindings, you may or may not see corresponding arguments in the method 200declarations. For example, in Java and C#, a default argument is handled by 201declaring two separate methods, with one of them having the argument and 202the other one lacking the argument. However, the libSBML documentation will 203be <em>identical</em> for both methods. Consequently, if you are reading 204this and do not see an argument even though one is described, please look 205for descriptions of other variants of this method near where this one 206appears in the documentation. 207</dd></dl> 208 209 * @internal 210 */ public 211 void logError(long errorId, long level, long version, String details, long line, long column, long severity, long category) { 212 libsbmlJNI.SBMLErrorLog_logError__SWIG_0(swigCPtr, this, errorId, level, version, details, line, column, severity, category); 213 } 214 215 216/** 217 * Convenience function that combines creating an {@link SBMLError} object and 218 * adding it to the log. 219 <p> 220 * @param errorId a long integer, the identification number of the error. 221 <p> 222 * @param level a long integer, the SBML Level 223 <p> 224 * @param version a long integer, the SBML Level's Version 225 <p> 226 * @param details a string containing additional details about the error. 227 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 228 * the given message is <em>appended</em> to a predefined message associated 229 * with the given code. If the error code is not recognized, the message 230 * is stored as-is as the text of the error. 231 <p> 232 * @param line a long integer, the line number at which the error occured. 233 <p> 234 * @param column a long integer, the column number at which the error occured. 235 <p> 236 * @param severity an integer indicating severity of the error. 237 <p> 238 * @param category an integer indicating the category to which the error 239 * belongs. 240 <p> 241 * 242</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 243The native C++ implementation of this method defines a default argument 244value. In the documentation generated for different libSBML language 245bindings, you may or may not see corresponding arguments in the method 246declarations. For example, in Java and C#, a default argument is handled by 247declaring two separate methods, with one of them having the argument and 248the other one lacking the argument. However, the libSBML documentation will 249be <em>identical</em> for both methods. Consequently, if you are reading 250this and do not see an argument even though one is described, please look 251for descriptions of other variants of this method near where this one 252appears in the documentation. 253</dd></dl> 254 255 * @internal 256 */ public 257 void logError(long errorId, long level, long version, String details, long line, long column, long severity) { 258 libsbmlJNI.SBMLErrorLog_logError__SWIG_1(swigCPtr, this, errorId, level, version, details, line, column, severity); 259 } 260 261 262/** 263 * Convenience function that combines creating an {@link SBMLError} object and 264 * adding it to the log. 265 <p> 266 * @param errorId a long integer, the identification number of the error. 267 <p> 268 * @param level a long integer, the SBML Level 269 <p> 270 * @param version a long integer, the SBML Level's Version 271 <p> 272 * @param details a string containing additional details about the error. 273 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 274 * the given message is <em>appended</em> to a predefined message associated 275 * with the given code. If the error code is not recognized, the message 276 * is stored as-is as the text of the error. 277 <p> 278 * @param line a long integer, the line number at which the error occured. 279 <p> 280 * @param column a long integer, the column number at which the error occured. 281 <p> 282 * @param severity an integer indicating severity of the error. 283 <p> 284 * @param category an integer indicating the category to which the error 285 * belongs. 286 <p> 287 * 288</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 289The native C++ implementation of this method defines a default argument 290value. In the documentation generated for different libSBML language 291bindings, you may or may not see corresponding arguments in the method 292declarations. For example, in Java and C#, a default argument is handled by 293declaring two separate methods, with one of them having the argument and 294the other one lacking the argument. However, the libSBML documentation will 295be <em>identical</em> for both methods. Consequently, if you are reading 296this and do not see an argument even though one is described, please look 297for descriptions of other variants of this method near where this one 298appears in the documentation. 299</dd></dl> 300 301 * @internal 302 */ public 303 void logError(long errorId, long level, long version, String details, long line, long column) { 304 libsbmlJNI.SBMLErrorLog_logError__SWIG_2(swigCPtr, this, errorId, level, version, details, line, column); 305 } 306 307 308/** 309 * Convenience function that combines creating an {@link SBMLError} object and 310 * adding it to the log. 311 <p> 312 * @param errorId a long integer, the identification number of the error. 313 <p> 314 * @param level a long integer, the SBML Level 315 <p> 316 * @param version a long integer, the SBML Level's Version 317 <p> 318 * @param details a string containing additional details about the error. 319 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 320 * the given message is <em>appended</em> to a predefined message associated 321 * with the given code. If the error code is not recognized, the message 322 * is stored as-is as the text of the error. 323 <p> 324 * @param line a long integer, the line number at which the error occured. 325 <p> 326 * @param column a long integer, the column number at which the error occured. 327 <p> 328 * @param severity an integer indicating severity of the error. 329 <p> 330 * @param category an integer indicating the category to which the error 331 * belongs. 332 <p> 333 * 334</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 335The native C++ implementation of this method defines a default argument 336value. In the documentation generated for different libSBML language 337bindings, you may or may not see corresponding arguments in the method 338declarations. For example, in Java and C#, a default argument is handled by 339declaring two separate methods, with one of them having the argument and 340the other one lacking the argument. However, the libSBML documentation will 341be <em>identical</em> for both methods. Consequently, if you are reading 342this and do not see an argument even though one is described, please look 343for descriptions of other variants of this method near where this one 344appears in the documentation. 345</dd></dl> 346 347 * @internal 348 */ public 349 void logError(long errorId, long level, long version, String details, long line) { 350 libsbmlJNI.SBMLErrorLog_logError__SWIG_3(swigCPtr, this, errorId, level, version, details, line); 351 } 352 353 354/** 355 * Convenience function that combines creating an {@link SBMLError} object and 356 * adding it to the log. 357 <p> 358 * @param errorId a long integer, the identification number of the error. 359 <p> 360 * @param level a long integer, the SBML Level 361 <p> 362 * @param version a long integer, the SBML Level's Version 363 <p> 364 * @param details a string containing additional details about the error. 365 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 366 * the given message is <em>appended</em> to a predefined message associated 367 * with the given code. If the error code is not recognized, the message 368 * is stored as-is as the text of the error. 369 <p> 370 * @param line a long integer, the line number at which the error occured. 371 <p> 372 * @param column a long integer, the column number at which the error occured. 373 <p> 374 * @param severity an integer indicating severity of the error. 375 <p> 376 * @param category an integer indicating the category to which the error 377 * belongs. 378 <p> 379 * 380</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 381The native C++ implementation of this method defines a default argument 382value. In the documentation generated for different libSBML language 383bindings, you may or may not see corresponding arguments in the method 384declarations. For example, in Java and C#, a default argument is handled by 385declaring two separate methods, with one of them having the argument and 386the other one lacking the argument. However, the libSBML documentation will 387be <em>identical</em> for both methods. Consequently, if you are reading 388this and do not see an argument even though one is described, please look 389for descriptions of other variants of this method near where this one 390appears in the documentation. 391</dd></dl> 392 393 * @internal 394 */ public 395 void logError(long errorId, long level, long version, String details) { 396 libsbmlJNI.SBMLErrorLog_logError__SWIG_4(swigCPtr, this, errorId, level, version, details); 397 } 398 399 400/** 401 * Convenience function that combines creating an {@link SBMLError} object and 402 * adding it to the log. 403 <p> 404 * @param errorId a long integer, the identification number of the error. 405 <p> 406 * @param level a long integer, the SBML Level 407 <p> 408 * @param version a long integer, the SBML Level's Version 409 <p> 410 * @param details a string containing additional details about the error. 411 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 412 * the given message is <em>appended</em> to a predefined message associated 413 * with the given code. If the error code is not recognized, the message 414 * is stored as-is as the text of the error. 415 <p> 416 * @param line a long integer, the line number at which the error occured. 417 <p> 418 * @param column a long integer, the column number at which the error occured. 419 <p> 420 * @param severity an integer indicating severity of the error. 421 <p> 422 * @param category an integer indicating the category to which the error 423 * belongs. 424 <p> 425 * 426</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 427The native C++ implementation of this method defines a default argument 428value. In the documentation generated for different libSBML language 429bindings, you may or may not see corresponding arguments in the method 430declarations. For example, in Java and C#, a default argument is handled by 431declaring two separate methods, with one of them having the argument and 432the other one lacking the argument. However, the libSBML documentation will 433be <em>identical</em> for both methods. Consequently, if you are reading 434this and do not see an argument even though one is described, please look 435for descriptions of other variants of this method near where this one 436appears in the documentation. 437</dd></dl> 438 439 * @internal 440 */ public 441 void logError(long errorId, long level, long version) { 442 libsbmlJNI.SBMLErrorLog_logError__SWIG_5(swigCPtr, this, errorId, level, version); 443 } 444 445 446/** 447 * Convenience function that combines creating an {@link SBMLError} object and 448 * adding it to the log. 449 <p> 450 * @param errorId a long integer, the identification number of the error. 451 <p> 452 * @param level a long integer, the SBML Level 453 <p> 454 * @param version a long integer, the SBML Level's Version 455 <p> 456 * @param details a string containing additional details about the error. 457 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 458 * the given message is <em>appended</em> to a predefined message associated 459 * with the given code. If the error code is not recognized, the message 460 * is stored as-is as the text of the error. 461 <p> 462 * @param line a long integer, the line number at which the error occured. 463 <p> 464 * @param column a long integer, the column number at which the error occured. 465 <p> 466 * @param severity an integer indicating severity of the error. 467 <p> 468 * @param category an integer indicating the category to which the error 469 * belongs. 470 <p> 471 * 472</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 473The native C++ implementation of this method defines a default argument 474value. In the documentation generated for different libSBML language 475bindings, you may or may not see corresponding arguments in the method 476declarations. For example, in Java and C#, a default argument is handled by 477declaring two separate methods, with one of them having the argument and 478the other one lacking the argument. However, the libSBML documentation will 479be <em>identical</em> for both methods. Consequently, if you are reading 480this and do not see an argument even though one is described, please look 481for descriptions of other variants of this method near where this one 482appears in the documentation. 483</dd></dl> 484 485 * @internal 486 */ public 487 void logError(long errorId, long level) { 488 libsbmlJNI.SBMLErrorLog_logError__SWIG_6(swigCPtr, this, errorId, level); 489 } 490 491 492/** 493 * Convenience function that combines creating an {@link SBMLError} object and 494 * adding it to the log. 495 <p> 496 * @param errorId a long integer, the identification number of the error. 497 <p> 498 * @param level a long integer, the SBML Level 499 <p> 500 * @param version a long integer, the SBML Level's Version 501 <p> 502 * @param details a string containing additional details about the error. 503 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 504 * the given message is <em>appended</em> to a predefined message associated 505 * with the given code. If the error code is not recognized, the message 506 * is stored as-is as the text of the error. 507 <p> 508 * @param line a long integer, the line number at which the error occured. 509 <p> 510 * @param column a long integer, the column number at which the error occured. 511 <p> 512 * @param severity an integer indicating severity of the error. 513 <p> 514 * @param category an integer indicating the category to which the error 515 * belongs. 516 <p> 517 * 518</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 519The native C++ implementation of this method defines a default argument 520value. In the documentation generated for different libSBML language 521bindings, you may or may not see corresponding arguments in the method 522declarations. For example, in Java and C#, a default argument is handled by 523declaring two separate methods, with one of them having the argument and 524the other one lacking the argument. However, the libSBML documentation will 525be <em>identical</em> for both methods. Consequently, if you are reading 526this and do not see an argument even though one is described, please look 527for descriptions of other variants of this method near where this one 528appears in the documentation. 529</dd></dl> 530 531 * @internal 532 */ public 533 void logError(long errorId) { 534 libsbmlJNI.SBMLErrorLog_logError__SWIG_7(swigCPtr, this, errorId); 535 } 536 537 538/** 539 * Convenience function that combines creating an {@link SBMLError} object and 540 * adding it to the log. 541 <p> 542 * @param errorId a long integer, the identification number of the error. 543 <p> 544 * @param level a long integer, the SBML Level 545 <p> 546 * @param version a long integer, the SBML Level's Version 547 <p> 548 * @param details a string containing additional details about the error. 549 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 550 * the given message is <em>appended</em> to a predefined message associated 551 * with the given code. If the error code is not recognized, the message 552 * is stored as-is as the text of the error. 553 <p> 554 * @param line a long integer, the line number at which the error occured. 555 <p> 556 * @param column a long integer, the column number at which the error occured. 557 <p> 558 * @param severity an integer indicating severity of the error. 559 <p> 560 * @param category an integer indicating the category to which the error 561 * belongs. 562 <p> 563 * 564</dl><dl class="docnote"><dt><b>Documentation note:</b></dt><dd> 565The native C++ implementation of this method defines a default argument 566value. In the documentation generated for different libSBML language 567bindings, you may or may not see corresponding arguments in the method 568declarations. For example, in Java and C#, a default argument is handled by 569declaring two separate methods, with one of them having the argument and 570the other one lacking the argument. However, the libSBML documentation will 571be <em>identical</em> for both methods. Consequently, if you are reading 572this and do not see an argument even though one is described, please look 573for descriptions of other variants of this method near where this one 574appears in the documentation. 575</dd></dl> 576 577 * @internal 578 */ public 579 void logError() { 580 libsbmlJNI.SBMLErrorLog_logError__SWIG_8(swigCPtr, this); 581 } 582 583 584/** * @internal */ public 585 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column, long severity, long category) { 586 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_0(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column, severity, category); 587 } 588 589 590/** * @internal */ public 591 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column, long severity) { 592 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_1(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column, severity); 593 } 594 595 596/** * @internal */ public 597 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column) { 598 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_2(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column); 599 } 600 601 602/** * @internal */ public 603 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line) { 604 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_3(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line); 605 } 606 607 608/** * @internal */ public 609 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details) { 610 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_4(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details); 611 } 612 613 614/** * @internal */ public 615 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version) { 616 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_5(swigCPtr, this, arg0, errorId, pkgVersion, level, version); 617 } 618 619 620/** * @internal */ public 621 void logPackageError(String arg0, long errorId, long pkgVersion, long level) { 622 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_6(swigCPtr, this, arg0, errorId, pkgVersion, level); 623 } 624 625 626/** * @internal */ public 627 void logPackageError(String arg0, long errorId, long pkgVersion) { 628 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_7(swigCPtr, this, arg0, errorId, pkgVersion); 629 } 630 631 632/** * @internal */ public 633 void logPackageError(String arg0, long errorId) { 634 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_8(swigCPtr, this, arg0, errorId); 635 } 636 637 638/** * @internal */ public 639 void logPackageError(String arg0) { 640 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_9(swigCPtr, this, arg0); 641 } 642 643 644/** * @internal */ public 645 void logPackageError() { 646 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_10(swigCPtr, this); 647 } 648 649 650/** 651 * Adds the given {@link SBMLError} to the log. 652 <p> 653 * @param error {@link SBMLError}, the error to be logged. 654 * @internal 655 */ public 656 void add(SBMLError error) { 657 libsbmlJNI.SBMLErrorLog_add(swigCPtr, this, SBMLError.getCPtr(error), error); 658 } 659 660 661/** 662 * Removes an error having errorId from the {@link SBMLError} list. 663 <p> 664 * Only the first item will be removed if there are multiple errors 665 * with the given errorId. 666 <p> 667 * @param errorId the error identifier of the error to be removed. 668 */ public 669 void remove(long errorId) { 670 libsbmlJNI.SBMLErrorLog_remove(swigCPtr, this, errorId); 671 } 672 673 674/** 675 * Returns true if {@link SBMLErrorLog} contains an errorId 676 <p> 677 * @param errorId the error identifier of the error to be found. 678 */ public 679 boolean contains(long errorId) { 680 return libsbmlJNI.SBMLErrorLog_contains(swigCPtr, this, errorId); 681 } 682 683}