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 * Log of errors and other events encountered during SBML 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 * LibSBML associates severity levels with every {@link SBMLError} object to 128 * provide an indication of how serious the problem is. Severities range 129 * from informational diagnostics to fatal (irrecoverable) errors. Given 130 * an {@link SBMLError} object instance, a caller can interrogate it for its 131 * severity level using methods such as {@link SBMLError#getSeverity()}, 132 * {@link SBMLError#isFatal()}, and so on. The present method encapsulates 133 * iteration and interrogation of all objects in an {@link SBMLErrorLog}, making 134 * it easy to check for the presence of error objects with specific 135 * severity levels. 136 * <p> 137 * @param severity a 138 * value from the set of <code>LIBSBML_SEV_</code> constants defined by 139 * the interface class <code><a 140 * href='libsbmlConstants.html'>libsbmlConstants</a></code> 141 * <p> 142 * @return a count of the number of errors with the given severity code. 143 * <p> 144 * @see #getNumErrors() 145 */ public 146 long getNumFailsWithSeverity(long severity) { 147 return libsbmlJNI.SBMLErrorLog_getNumFailsWithSeverity__SWIG_0(swigCPtr, this, severity); 148 } 149 150 151/** 152 * Creates a new, empty {@link SBMLErrorLog}. 153 * @internal 154 */ public 155 SBMLErrorLog() { 156 this(libsbmlJNI.new_SBMLErrorLog(), true); 157 } 158 159 160/** 161 * Convenience function that combines creating an {@link SBMLError} object and 162 * adding it to the log. 163 * <p> 164 * @param errorId a long integer, the identification number of the error. 165 * <p> 166 * @param level a long integer, the SBML Level 167 * <p> 168 * @param version a long integer, the SBML Level's Version 169 * <p> 170 * @param details a string containing additional details about the error. 171 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 172 * the given message is <em>appended</em> to a predefined message associated 173 * with the given code. If the error code is not recognized, the message 174 * is stored as-is as the text of the error. 175 * <p> 176 * @param line a long integer, the line number at which the error occured. 177 * <p> 178 * @param column a long integer, the column number at which the error occured. 179 * <p> 180 * @param severity an integer indicating severity of the error. 181 * <p> 182 * @param category an integer indicating the category to which the error 183 * belongs. 184 * <p> 185 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 186</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 187The native C++ implementation of this method defines a default argument 188value. In the documentation generated for different libSBML language 189bindings, you may or may not see corresponding arguments in the method 190declarations. For example, in Java and C#, a default argument is handled by 191declaring two separate methods, with one of them having the argument and 192the other one lacking the argument. However, the libSBML documentation will 193be <em>identical</em> for both methods. Consequently, if you are reading 194this and do not see an argument even though one is described, please look 195for descriptions of other variants of this method near where this one 196appears in the documentation. 197</dd></dl> 198 199 * @internal 200 */ public 201 void logError(long errorId, long level, long version, String details, long line, long column, long severity, long category) { 202 libsbmlJNI.SBMLErrorLog_logError__SWIG_0(swigCPtr, this, errorId, level, version, details, line, column, severity, category); 203 } 204 205 206/** 207 * Convenience function that combines creating an {@link SBMLError} object and 208 * adding it to the log. 209 * <p> 210 * @param errorId a long integer, the identification number of the error. 211 * <p> 212 * @param level a long integer, the SBML Level 213 * <p> 214 * @param version a long integer, the SBML Level's Version 215 * <p> 216 * @param details a string containing additional details about the error. 217 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 218 * the given message is <em>appended</em> to a predefined message associated 219 * with the given code. If the error code is not recognized, the message 220 * is stored as-is as the text of the error. 221 * <p> 222 * @param line a long integer, the line number at which the error occured. 223 * <p> 224 * @param column a long integer, the column number at which the error occured. 225 * <p> 226 * @param severity an integer indicating severity of the error. 227 * <p> 228 * @param category an integer indicating the category to which the error 229 * belongs. 230 * <p> 231 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 232</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 233The native C++ implementation of this method defines a default argument 234value. In the documentation generated for different libSBML language 235bindings, you may or may not see corresponding arguments in the method 236declarations. For example, in Java and C#, a default argument is handled by 237declaring two separate methods, with one of them having the argument and 238the other one lacking the argument. However, the libSBML documentation will 239be <em>identical</em> for both methods. Consequently, if you are reading 240this and do not see an argument even though one is described, please look 241for descriptions of other variants of this method near where this one 242appears in the documentation. 243</dd></dl> 244 245 * @internal 246 */ public 247 void logError(long errorId, long level, long version, String details, long line, long column, long severity) { 248 libsbmlJNI.SBMLErrorLog_logError__SWIG_1(swigCPtr, this, errorId, level, version, details, line, column, severity); 249 } 250 251 252/** 253 * Convenience function that combines creating an {@link SBMLError} object and 254 * adding it to the log. 255 * <p> 256 * @param errorId a long integer, the identification number of the error. 257 * <p> 258 * @param level a long integer, the SBML Level 259 * <p> 260 * @param version a long integer, the SBML Level's Version 261 * <p> 262 * @param details a string containing additional details about the error. 263 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 264 * the given message is <em>appended</em> to a predefined message associated 265 * with the given code. If the error code is not recognized, the message 266 * is stored as-is as the text of the error. 267 * <p> 268 * @param line a long integer, the line number at which the error occured. 269 * <p> 270 * @param column a long integer, the column number at which the error occured. 271 * <p> 272 * @param severity an integer indicating severity of the error. 273 * <p> 274 * @param category an integer indicating the category to which the error 275 * belongs. 276 * <p> 277 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 278</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 279The native C++ implementation of this method defines a default argument 280value. In the documentation generated for different libSBML language 281bindings, you may or may not see corresponding arguments in the method 282declarations. For example, in Java and C#, a default argument is handled by 283declaring two separate methods, with one of them having the argument and 284the other one lacking the argument. However, the libSBML documentation will 285be <em>identical</em> for both methods. Consequently, if you are reading 286this and do not see an argument even though one is described, please look 287for descriptions of other variants of this method near where this one 288appears in the documentation. 289</dd></dl> 290 291 * @internal 292 */ public 293 void logError(long errorId, long level, long version, String details, long line, long column) { 294 libsbmlJNI.SBMLErrorLog_logError__SWIG_2(swigCPtr, this, errorId, level, version, details, line, column); 295 } 296 297 298/** 299 * Convenience function that combines creating an {@link SBMLError} object and 300 * adding it to the log. 301 * <p> 302 * @param errorId a long integer, the identification number of the error. 303 * <p> 304 * @param level a long integer, the SBML Level 305 * <p> 306 * @param version a long integer, the SBML Level's Version 307 * <p> 308 * @param details a string containing additional details about the error. 309 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 310 * the given message is <em>appended</em> to a predefined message associated 311 * with the given code. If the error code is not recognized, the message 312 * is stored as-is as the text of the error. 313 * <p> 314 * @param line a long integer, the line number at which the error occured. 315 * <p> 316 * @param column a long integer, the column number at which the error occured. 317 * <p> 318 * @param severity an integer indicating severity of the error. 319 * <p> 320 * @param category an integer indicating the category to which the error 321 * belongs. 322 * <p> 323 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 324</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 325The native C++ implementation of this method defines a default argument 326value. In the documentation generated for different libSBML language 327bindings, you may or may not see corresponding arguments in the method 328declarations. For example, in Java and C#, a default argument is handled by 329declaring two separate methods, with one of them having the argument and 330the other one lacking the argument. However, the libSBML documentation will 331be <em>identical</em> for both methods. Consequently, if you are reading 332this and do not see an argument even though one is described, please look 333for descriptions of other variants of this method near where this one 334appears in the documentation. 335</dd></dl> 336 337 * @internal 338 */ public 339 void logError(long errorId, long level, long version, String details, long line) { 340 libsbmlJNI.SBMLErrorLog_logError__SWIG_3(swigCPtr, this, errorId, level, version, details, line); 341 } 342 343 344/** 345 * Convenience function that combines creating an {@link SBMLError} object and 346 * adding it to the log. 347 * <p> 348 * @param errorId a long integer, the identification number of the error. 349 * <p> 350 * @param level a long integer, the SBML Level 351 * <p> 352 * @param version a long integer, the SBML Level's Version 353 * <p> 354 * @param details a string containing additional details about the error. 355 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 356 * the given message is <em>appended</em> to a predefined message associated 357 * with the given code. If the error code is not recognized, the message 358 * is stored as-is as the text of the error. 359 * <p> 360 * @param line a long integer, the line number at which the error occured. 361 * <p> 362 * @param column a long integer, the column number at which the error occured. 363 * <p> 364 * @param severity an integer indicating severity of the error. 365 * <p> 366 * @param category an integer indicating the category to which the error 367 * belongs. 368 * <p> 369 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 370</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 371The native C++ implementation of this method defines a default argument 372value. In the documentation generated for different libSBML language 373bindings, you may or may not see corresponding arguments in the method 374declarations. For example, in Java and C#, a default argument is handled by 375declaring two separate methods, with one of them having the argument and 376the other one lacking the argument. However, the libSBML documentation will 377be <em>identical</em> for both methods. Consequently, if you are reading 378this and do not see an argument even though one is described, please look 379for descriptions of other variants of this method near where this one 380appears in the documentation. 381</dd></dl> 382 383 * @internal 384 */ public 385 void logError(long errorId, long level, long version, String details) { 386 libsbmlJNI.SBMLErrorLog_logError__SWIG_4(swigCPtr, this, errorId, level, version, details); 387 } 388 389 390/** 391 * Convenience function that combines creating an {@link SBMLError} object and 392 * adding it to the log. 393 * <p> 394 * @param errorId a long integer, the identification number of the error. 395 * <p> 396 * @param level a long integer, the SBML Level 397 * <p> 398 * @param version a long integer, the SBML Level's Version 399 * <p> 400 * @param details a string containing additional details about the error. 401 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 402 * the given message is <em>appended</em> to a predefined message associated 403 * with the given code. If the error code is not recognized, the message 404 * is stored as-is as the text of the error. 405 * <p> 406 * @param line a long integer, the line number at which the error occured. 407 * <p> 408 * @param column a long integer, the column number at which the error occured. 409 * <p> 410 * @param severity an integer indicating severity of the error. 411 * <p> 412 * @param category an integer indicating the category to which the error 413 * belongs. 414 * <p> 415 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 416</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 417The native C++ implementation of this method defines a default argument 418value. In the documentation generated for different libSBML language 419bindings, you may or may not see corresponding arguments in the method 420declarations. For example, in Java and C#, a default argument is handled by 421declaring two separate methods, with one of them having the argument and 422the other one lacking the argument. However, the libSBML documentation will 423be <em>identical</em> for both methods. Consequently, if you are reading 424this and do not see an argument even though one is described, please look 425for descriptions of other variants of this method near where this one 426appears in the documentation. 427</dd></dl> 428 429 * @internal 430 */ public 431 void logError(long errorId, long level, long version) { 432 libsbmlJNI.SBMLErrorLog_logError__SWIG_5(swigCPtr, this, errorId, level, version); 433 } 434 435 436/** 437 * Convenience function that combines creating an {@link SBMLError} object and 438 * adding it to the log. 439 * <p> 440 * @param errorId a long integer, the identification number of the error. 441 * <p> 442 * @param level a long integer, the SBML Level 443 * <p> 444 * @param version a long integer, the SBML Level's Version 445 * <p> 446 * @param details a string containing additional details about the error. 447 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 448 * the given message is <em>appended</em> to a predefined message associated 449 * with the given code. If the error code is not recognized, the message 450 * is stored as-is as the text of the error. 451 * <p> 452 * @param line a long integer, the line number at which the error occured. 453 * <p> 454 * @param column a long integer, the column number at which the error occured. 455 * <p> 456 * @param severity an integer indicating severity of the error. 457 * <p> 458 * @param category an integer indicating the category to which the error 459 * belongs. 460 * <p> 461 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 462</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 463The native C++ implementation of this method defines a default argument 464value. In the documentation generated for different libSBML language 465bindings, you may or may not see corresponding arguments in the method 466declarations. For example, in Java and C#, a default argument is handled by 467declaring two separate methods, with one of them having the argument and 468the other one lacking the argument. However, the libSBML documentation will 469be <em>identical</em> for both methods. Consequently, if you are reading 470this and do not see an argument even though one is described, please look 471for descriptions of other variants of this method near where this one 472appears in the documentation. 473</dd></dl> 474 475 * @internal 476 */ public 477 void logError(long errorId, long level) { 478 libsbmlJNI.SBMLErrorLog_logError__SWIG_6(swigCPtr, this, errorId, level); 479 } 480 481 482/** 483 * Convenience function that combines creating an {@link SBMLError} object and 484 * adding it to the log. 485 * <p> 486 * @param errorId a long integer, the identification number of the error. 487 * <p> 488 * @param level a long integer, the SBML Level 489 * <p> 490 * @param version a long integer, the SBML Level's Version 491 * <p> 492 * @param details a string containing additional details about the error. 493 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 494 * the given message is <em>appended</em> to a predefined message associated 495 * with the given code. If the error code is not recognized, the message 496 * is stored as-is as the text of the error. 497 * <p> 498 * @param line a long integer, the line number at which the error occured. 499 * <p> 500 * @param column a long integer, the column number at which the error occured. 501 * <p> 502 * @param severity an integer indicating severity of the error. 503 * <p> 504 * @param category an integer indicating the category to which the error 505 * belongs. 506 * <p> 507 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 508</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 509The native C++ implementation of this method defines a default argument 510value. In the documentation generated for different libSBML language 511bindings, you may or may not see corresponding arguments in the method 512declarations. For example, in Java and C#, a default argument is handled by 513declaring two separate methods, with one of them having the argument and 514the other one lacking the argument. However, the libSBML documentation will 515be <em>identical</em> for both methods. Consequently, if you are reading 516this and do not see an argument even though one is described, please look 517for descriptions of other variants of this method near where this one 518appears in the documentation. 519</dd></dl> 520 521 * @internal 522 */ public 523 void logError(long errorId) { 524 libsbmlJNI.SBMLErrorLog_logError__SWIG_7(swigCPtr, this, errorId); 525 } 526 527 528/** 529 * Convenience function that combines creating an {@link SBMLError} object and 530 * adding it to the log. 531 * <p> 532 * @param errorId a long integer, the identification number of the error. 533 * <p> 534 * @param level a long integer, the SBML Level 535 * <p> 536 * @param version a long integer, the SBML Level's Version 537 * <p> 538 * @param details a string containing additional details about the error. 539 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 540 * the given message is <em>appended</em> to a predefined message associated 541 * with the given code. If the error code is not recognized, the message 542 * is stored as-is as the text of the error. 543 * <p> 544 * @param line a long integer, the line number at which the error occured. 545 * <p> 546 * @param column a long integer, the column number at which the error occured. 547 * <p> 548 * @param severity an integer indicating severity of the error. 549 * <p> 550 * @param category an integer indicating the category to which the error 551 * belongs. 552 * <p> 553 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 554</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 555The native C++ implementation of this method defines a default argument 556value. In the documentation generated for different libSBML language 557bindings, you may or may not see corresponding arguments in the method 558declarations. For example, in Java and C#, a default argument is handled by 559declaring two separate methods, with one of them having the argument and 560the other one lacking the argument. However, the libSBML documentation will 561be <em>identical</em> for both methods. Consequently, if you are reading 562this and do not see an argument even though one is described, please look 563for descriptions of other variants of this method near where this one 564appears in the documentation. 565</dd></dl> 566 567 * @internal 568 */ public 569 void logError() { 570 libsbmlJNI.SBMLErrorLog_logError__SWIG_8(swigCPtr, this); 571 } 572 573 574/** 575 * Convenience function that combines creating an {@link SBMLError} object and 576 * adding it to the log. 577 * <p> 578 * @param errorId a long integer, the identification number of the error. 579 * <p> 580 * @param level a long integer, the SBML Level 581 * <p> 582 * @param version a long integer, the SBML Level's Version 583 * <p> 584 * @param details a string containing additional details about the error. 585 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 586 * the given message is <em>appended</em> to a predefined message associated 587 * with the given code. If the error code is not recognized, the message 588 * is stored as-is as the text of the error. 589 * <p> 590 * @param line a long integer, the line number at which the error occured. 591 * <p> 592 * @param column a long integer, the column number at which the error occured. 593 * <p> 594 * @param severity an integer indicating severity of the error. 595 * <p> 596 * @param category an integer indicating the category to which the error 597 * belongs. 598 * <p> 599 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 600</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 601The native C++ implementation of this method defines a default argument 602value. In the documentation generated for different libSBML language 603bindings, you may or may not see corresponding arguments in the method 604declarations. For example, in Java and C#, a default argument is handled by 605declaring two separate methods, with one of them having the argument and 606the other one lacking the argument. However, the libSBML documentation will 607be <em>identical</em> for both methods. Consequently, if you are reading 608this and do not see an argument even though one is described, please look 609for descriptions of other variants of this method near where this one 610appears in the documentation. 611</dd></dl> 612 613 * @internal 614 */ public 615 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column, long severity, long category) { 616 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_0(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column, severity, category); 617 } 618 619 620/** 621 * Convenience function that combines creating an {@link SBMLError} object and 622 * adding it to the log. 623 * <p> 624 * @param errorId a long integer, the identification number of the error. 625 * <p> 626 * @param level a long integer, the SBML Level 627 * <p> 628 * @param version a long integer, the SBML Level's Version 629 * <p> 630 * @param details a string containing additional details about the error. 631 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 632 * the given message is <em>appended</em> to a predefined message associated 633 * with the given code. If the error code is not recognized, the message 634 * is stored as-is as the text of the error. 635 * <p> 636 * @param line a long integer, the line number at which the error occured. 637 * <p> 638 * @param column a long integer, the column number at which the error occured. 639 * <p> 640 * @param severity an integer indicating severity of the error. 641 * <p> 642 * @param category an integer indicating the category to which the error 643 * belongs. 644 * <p> 645 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 646</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 647The native C++ implementation of this method defines a default argument 648value. In the documentation generated for different libSBML language 649bindings, you may or may not see corresponding arguments in the method 650declarations. For example, in Java and C#, a default argument is handled by 651declaring two separate methods, with one of them having the argument and 652the other one lacking the argument. However, the libSBML documentation will 653be <em>identical</em> for both methods. Consequently, if you are reading 654this and do not see an argument even though one is described, please look 655for descriptions of other variants of this method near where this one 656appears in the documentation. 657</dd></dl> 658 659 * @internal 660 */ public 661 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column, long severity) { 662 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_1(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column, severity); 663 } 664 665 666/** 667 * Convenience function that combines creating an {@link SBMLError} object and 668 * adding it to the log. 669 * <p> 670 * @param errorId a long integer, the identification number of the error. 671 * <p> 672 * @param level a long integer, the SBML Level 673 * <p> 674 * @param version a long integer, the SBML Level's Version 675 * <p> 676 * @param details a string containing additional details about the error. 677 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 678 * the given message is <em>appended</em> to a predefined message associated 679 * with the given code. If the error code is not recognized, the message 680 * is stored as-is as the text of the error. 681 * <p> 682 * @param line a long integer, the line number at which the error occured. 683 * <p> 684 * @param column a long integer, the column number at which the error occured. 685 * <p> 686 * @param severity an integer indicating severity of the error. 687 * <p> 688 * @param category an integer indicating the category to which the error 689 * belongs. 690 * <p> 691 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 692</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 693The native C++ implementation of this method defines a default argument 694value. In the documentation generated for different libSBML language 695bindings, you may or may not see corresponding arguments in the method 696declarations. For example, in Java and C#, a default argument is handled by 697declaring two separate methods, with one of them having the argument and 698the other one lacking the argument. However, the libSBML documentation will 699be <em>identical</em> for both methods. Consequently, if you are reading 700this and do not see an argument even though one is described, please look 701for descriptions of other variants of this method near where this one 702appears in the documentation. 703</dd></dl> 704 705 * @internal 706 */ public 707 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line, long column) { 708 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_2(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line, column); 709 } 710 711 712/** 713 * Convenience function that combines creating an {@link SBMLError} object and 714 * adding it to the log. 715 * <p> 716 * @param errorId a long integer, the identification number of the error. 717 * <p> 718 * @param level a long integer, the SBML Level 719 * <p> 720 * @param version a long integer, the SBML Level's Version 721 * <p> 722 * @param details a string containing additional details about the error. 723 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 724 * the given message is <em>appended</em> to a predefined message associated 725 * with the given code. If the error code is not recognized, the message 726 * is stored as-is as the text of the error. 727 * <p> 728 * @param line a long integer, the line number at which the error occured. 729 * <p> 730 * @param column a long integer, the column number at which the error occured. 731 * <p> 732 * @param severity an integer indicating severity of the error. 733 * <p> 734 * @param category an integer indicating the category to which the error 735 * belongs. 736 * <p> 737 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 738</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 739The native C++ implementation of this method defines a default argument 740value. In the documentation generated for different libSBML language 741bindings, you may or may not see corresponding arguments in the method 742declarations. For example, in Java and C#, a default argument is handled by 743declaring two separate methods, with one of them having the argument and 744the other one lacking the argument. However, the libSBML documentation will 745be <em>identical</em> for both methods. Consequently, if you are reading 746this and do not see an argument even though one is described, please look 747for descriptions of other variants of this method near where this one 748appears in the documentation. 749</dd></dl> 750 751 * @internal 752 */ public 753 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details, long line) { 754 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_3(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details, line); 755 } 756 757 758/** 759 * Convenience function that combines creating an {@link SBMLError} object and 760 * adding it to the log. 761 * <p> 762 * @param errorId a long integer, the identification number of the error. 763 * <p> 764 * @param level a long integer, the SBML Level 765 * <p> 766 * @param version a long integer, the SBML Level's Version 767 * <p> 768 * @param details a string containing additional details about the error. 769 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 770 * the given message is <em>appended</em> to a predefined message associated 771 * with the given code. If the error code is not recognized, the message 772 * is stored as-is as the text of the error. 773 * <p> 774 * @param line a long integer, the line number at which the error occured. 775 * <p> 776 * @param column a long integer, the column number at which the error occured. 777 * <p> 778 * @param severity an integer indicating severity of the error. 779 * <p> 780 * @param category an integer indicating the category to which the error 781 * belongs. 782 * <p> 783 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 784</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 785The native C++ implementation of this method defines a default argument 786value. In the documentation generated for different libSBML language 787bindings, you may or may not see corresponding arguments in the method 788declarations. For example, in Java and C#, a default argument is handled by 789declaring two separate methods, with one of them having the argument and 790the other one lacking the argument. However, the libSBML documentation will 791be <em>identical</em> for both methods. Consequently, if you are reading 792this and do not see an argument even though one is described, please look 793for descriptions of other variants of this method near where this one 794appears in the documentation. 795</dd></dl> 796 797 * @internal 798 */ public 799 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version, String details) { 800 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_4(swigCPtr, this, arg0, errorId, pkgVersion, level, version, details); 801 } 802 803 804/** 805 * Convenience function that combines creating an {@link SBMLError} object and 806 * adding it to the log. 807 * <p> 808 * @param errorId a long integer, the identification number of the error. 809 * <p> 810 * @param level a long integer, the SBML Level 811 * <p> 812 * @param version a long integer, the SBML Level's Version 813 * <p> 814 * @param details a string containing additional details about the error. 815 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 816 * the given message is <em>appended</em> to a predefined message associated 817 * with the given code. If the error code is not recognized, the message 818 * is stored as-is as the text of the error. 819 * <p> 820 * @param line a long integer, the line number at which the error occured. 821 * <p> 822 * @param column a long integer, the column number at which the error occured. 823 * <p> 824 * @param severity an integer indicating severity of the error. 825 * <p> 826 * @param category an integer indicating the category to which the error 827 * belongs. 828 * <p> 829 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 830</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 831The native C++ implementation of this method defines a default argument 832value. In the documentation generated for different libSBML language 833bindings, you may or may not see corresponding arguments in the method 834declarations. For example, in Java and C#, a default argument is handled by 835declaring two separate methods, with one of them having the argument and 836the other one lacking the argument. However, the libSBML documentation will 837be <em>identical</em> for both methods. Consequently, if you are reading 838this and do not see an argument even though one is described, please look 839for descriptions of other variants of this method near where this one 840appears in the documentation. 841</dd></dl> 842 843 * @internal 844 */ public 845 void logPackageError(String arg0, long errorId, long pkgVersion, long level, long version) { 846 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_5(swigCPtr, this, arg0, errorId, pkgVersion, level, version); 847 } 848 849 850/** 851 * Convenience function that combines creating an {@link SBMLError} object and 852 * adding it to the log. 853 * <p> 854 * @param errorId a long integer, the identification number of the error. 855 * <p> 856 * @param level a long integer, the SBML Level 857 * <p> 858 * @param version a long integer, the SBML Level's Version 859 * <p> 860 * @param details a string containing additional details about the error. 861 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 862 * the given message is <em>appended</em> to a predefined message associated 863 * with the given code. If the error code is not recognized, the message 864 * is stored as-is as the text of the error. 865 * <p> 866 * @param line a long integer, the line number at which the error occured. 867 * <p> 868 * @param column a long integer, the column number at which the error occured. 869 * <p> 870 * @param severity an integer indicating severity of the error. 871 * <p> 872 * @param category an integer indicating the category to which the error 873 * belongs. 874 * <p> 875 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 876</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 877The native C++ implementation of this method defines a default argument 878value. In the documentation generated for different libSBML language 879bindings, you may or may not see corresponding arguments in the method 880declarations. For example, in Java and C#, a default argument is handled by 881declaring two separate methods, with one of them having the argument and 882the other one lacking the argument. However, the libSBML documentation will 883be <em>identical</em> for both methods. Consequently, if you are reading 884this and do not see an argument even though one is described, please look 885for descriptions of other variants of this method near where this one 886appears in the documentation. 887</dd></dl> 888 889 * @internal 890 */ public 891 void logPackageError(String arg0, long errorId, long pkgVersion, long level) { 892 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_6(swigCPtr, this, arg0, errorId, pkgVersion, level); 893 } 894 895 896/** 897 * Convenience function that combines creating an {@link SBMLError} object and 898 * adding it to the log. 899 * <p> 900 * @param errorId a long integer, the identification number of the error. 901 * <p> 902 * @param level a long integer, the SBML Level 903 * <p> 904 * @param version a long integer, the SBML Level's Version 905 * <p> 906 * @param details a string containing additional details about the error. 907 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 908 * the given message is <em>appended</em> to a predefined message associated 909 * with the given code. If the error code is not recognized, the message 910 * is stored as-is as the text of the error. 911 * <p> 912 * @param line a long integer, the line number at which the error occured. 913 * <p> 914 * @param column a long integer, the column number at which the error occured. 915 * <p> 916 * @param severity an integer indicating severity of the error. 917 * <p> 918 * @param category an integer indicating the category to which the error 919 * belongs. 920 * <p> 921 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 922</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 923The native C++ implementation of this method defines a default argument 924value. In the documentation generated for different libSBML language 925bindings, you may or may not see corresponding arguments in the method 926declarations. For example, in Java and C#, a default argument is handled by 927declaring two separate methods, with one of them having the argument and 928the other one lacking the argument. However, the libSBML documentation will 929be <em>identical</em> for both methods. Consequently, if you are reading 930this and do not see an argument even though one is described, please look 931for descriptions of other variants of this method near where this one 932appears in the documentation. 933</dd></dl> 934 935 * @internal 936 */ public 937 void logPackageError(String arg0, long errorId, long pkgVersion) { 938 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_7(swigCPtr, this, arg0, errorId, pkgVersion); 939 } 940 941 942/** 943 * Convenience function that combines creating an {@link SBMLError} object and 944 * adding it to the log. 945 * <p> 946 * @param errorId a long integer, the identification number of the error. 947 * <p> 948 * @param level a long integer, the SBML Level 949 * <p> 950 * @param version a long integer, the SBML Level's Version 951 * <p> 952 * @param details a string containing additional details about the error. 953 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 954 * the given message is <em>appended</em> to a predefined message associated 955 * with the given code. If the error code is not recognized, the message 956 * is stored as-is as the text of the error. 957 * <p> 958 * @param line a long integer, the line number at which the error occured. 959 * <p> 960 * @param column a long integer, the column number at which the error occured. 961 * <p> 962 * @param severity an integer indicating severity of the error. 963 * <p> 964 * @param category an integer indicating the category to which the error 965 * belongs. 966 * <p> 967 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 968</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 969The native C++ implementation of this method defines a default argument 970value. In the documentation generated for different libSBML language 971bindings, you may or may not see corresponding arguments in the method 972declarations. For example, in Java and C#, a default argument is handled by 973declaring two separate methods, with one of them having the argument and 974the other one lacking the argument. However, the libSBML documentation will 975be <em>identical</em> for both methods. Consequently, if you are reading 976this and do not see an argument even though one is described, please look 977for descriptions of other variants of this method near where this one 978appears in the documentation. 979</dd></dl> 980 981 * @internal 982 */ public 983 void logPackageError(String arg0, long errorId) { 984 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_8(swigCPtr, this, arg0, errorId); 985 } 986 987 988/** 989 * Convenience function that combines creating an {@link SBMLError} object and 990 * adding it to the log. 991 * <p> 992 * @param errorId a long integer, the identification number of the error. 993 * <p> 994 * @param level a long integer, the SBML Level 995 * <p> 996 * @param version a long integer, the SBML Level's Version 997 * <p> 998 * @param details a string containing additional details about the error. 999 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 1000 * the given message is <em>appended</em> to a predefined message associated 1001 * with the given code. If the error code is not recognized, the message 1002 * is stored as-is as the text of the error. 1003 * <p> 1004 * @param line a long integer, the line number at which the error occured. 1005 * <p> 1006 * @param column a long integer, the column number at which the error occured. 1007 * <p> 1008 * @param severity an integer indicating severity of the error. 1009 * <p> 1010 * @param category an integer indicating the category to which the error 1011 * belongs. 1012 * <p> 1013 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 1014</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 1015The native C++ implementation of this method defines a default argument 1016value. In the documentation generated for different libSBML language 1017bindings, you may or may not see corresponding arguments in the method 1018declarations. For example, in Java and C#, a default argument is handled by 1019declaring two separate methods, with one of them having the argument and 1020the other one lacking the argument. However, the libSBML documentation will 1021be <em>identical</em> for both methods. Consequently, if you are reading 1022this and do not see an argument even though one is described, please look 1023for descriptions of other variants of this method near where this one 1024appears in the documentation. 1025</dd></dl> 1026 1027 * @internal 1028 */ public 1029 void logPackageError(String arg0) { 1030 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_9(swigCPtr, this, arg0); 1031 } 1032 1033 1034/** 1035 * Convenience function that combines creating an {@link SBMLError} object and 1036 * adding it to the log. 1037 * <p> 1038 * @param errorId a long integer, the identification number of the error. 1039 * <p> 1040 * @param level a long integer, the SBML Level 1041 * <p> 1042 * @param version a long integer, the SBML Level's Version 1043 * <p> 1044 * @param details a string containing additional details about the error. 1045 * If the error code in <code>errorId</code> is one that is recognized by {@link SBMLError}, 1046 * the given message is <em>appended</em> to a predefined message associated 1047 * with the given code. If the error code is not recognized, the message 1048 * is stored as-is as the text of the error. 1049 * <p> 1050 * @param line a long integer, the line number at which the error occured. 1051 * <p> 1052 * @param column a long integer, the column number at which the error occured. 1053 * <p> 1054 * @param severity an integer indicating severity of the error. 1055 * <p> 1056 * @param category an integer indicating the category to which the error 1057 * belongs. 1058 * <p> 1059 * <!-- Don't remove the leading </dl> below. It's a hack for javadoc. --> 1060</dl><dl class='docnote'><dt><b>Documentation note:</b></dt><dd> 1061The native C++ implementation of this method defines a default argument 1062value. In the documentation generated for different libSBML language 1063bindings, you may or may not see corresponding arguments in the method 1064declarations. For example, in Java and C#, a default argument is handled by 1065declaring two separate methods, with one of them having the argument and 1066the other one lacking the argument. However, the libSBML documentation will 1067be <em>identical</em> for both methods. Consequently, if you are reading 1068this and do not see an argument even though one is described, please look 1069for descriptions of other variants of this method near where this one 1070appears in the documentation. 1071</dd></dl> 1072 1073 * @internal 1074 */ public 1075 void logPackageError() { 1076 libsbmlJNI.SBMLErrorLog_logPackageError__SWIG_10(swigCPtr, this); 1077 } 1078 1079 1080/** 1081 * Adds the given {@link SBMLError} to the log. 1082 * <p> 1083 * @param error {@link SBMLError}, the error to be logged. 1084 * @internal 1085 */ public 1086 void add(SBMLError error) { 1087 libsbmlJNI.SBMLErrorLog_add(swigCPtr, this, SBMLError.getCPtr(error), error); 1088 } 1089 1090 1091/** 1092 * Removes an error having errorId from the {@link SBMLError} list. 1093 * <p> 1094 * Only the first item will be removed if there are multiple errors 1095 * with the given errorId. 1096 * <p> 1097 * @param errorId the error identifier of the error to be removed. 1098 */ public 1099 void remove(long errorId) { 1100 libsbmlJNI.SBMLErrorLog_remove(swigCPtr, this, errorId); 1101 } 1102 1103 1104/** 1105 * Returns true if {@link SBMLErrorLog} contains an errorId 1106 * <p> 1107 * @param errorId the error identifier of the error to be found. 1108 */ public 1109 boolean contains(long errorId) { 1110 return libsbmlJNI.SBMLErrorLog_contains(swigCPtr, this, errorId); 1111 } 1112 1113}