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}