Homec4science
Diffusion lammps (lammm-master-deprecated) Browse

lammps/tools/pymol_asphere/src/error.h
f3e746d501d6lammm-master-deprecated

Last Change
Raw File

error.h
View Options

/***************************************************************************
error.h
-------------------
Class for error handling
__________________________________________________________________________
begin : Thu Oct 9 2003
copyright : (C) 2003 by W. Michael Brown
email : wmbrown@sandia.gov
***************************************************************************/
#ifndef ERRORCLASS
#define ERRORCLASS
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <math.h>
#ifdef MUSE_MPI
#include <mpi.h>
#endif
using namespace std;
// forward declarations
namespace a {
string itoa(unsigned int);
void format_fit(unsigned, const string &, vector<string> &);
}
/// Notice Class for Handling Object Output
/** A notice object stores an ostream for output and a notice_level.
* All output is sent along with a level. Any output whose level is
* greater than notice_level is sent to a null stream. The C++ output
* operator '<<' can be used with the Notice operator '[]' which passes
* the level:
* \verbatim notice_object[29] << "This notice has level 29" << endl;
* \endverbatim
*
* The guidelines for output notice levels are:
* - \e 0: Information that must be output
* - \e 1 - 9: Normal program output
* - \e 10-19: Parameters useful for storing how the program was run
* - \e 20-29: Extraneous information useful that may be useful to user
* - \e 30- : Debugging information */
class Notice {
public:
/// Standard output (cout) is the default notice output ostream
/** The default maximum notice level is 9 \e (notice_level=10) */
Notice();
~Notice();
/// Set the output stream for notice output
void setostream(ostream &out);
/// Returns a null stream if level is two high, else returns notice stream
ostream & operator[] (const unsigned level);
/// Set the degree of program output
void set_notice_level(unsigned l);
/// Get the degree of program output
unsigned get_notice_level();
/// Generate a notice with a specified calling class
void notice(unsigned level, const string calling_class, const string note);
/// Generate a notice with a specified calling class
void notice(unsigned level, const string calling_class,
vector<string> &notes);
/// Generate a notice
void notice(unsigned level, const string note);
/// Generate a notice
void notice(unsigned level, vector<string> &note);
private:
unsigned notice_level;
ostream *nullout; // Null stream for redirecting output to nowhere
ostream *noteout; // Output for notices
};
/// Error and Notice Handling
/** This class is intended to handle all output to the user. Output is
* divided into notices and warnings/errors. Output of any message is
* associated with a level. For notices, if level is greater than or equal to
* max_notice_level, no output is generated. For warnings, if level is less
* than min_warning_level, it is dismissed with no output. If the level is
* greater than max_warning_level, the program is terminated and all warnings
* and errors are output.
*
* \note By default, on destruction of an Error object, all unhandled
* warnings and errors are output
*
* A log file can be specified for each object. In this case, all notices
* are output to the log file only and errors are output to both stderr
* and the log file
*
* Errors can be generated with a string or using the internal message buffer:
\verbatim
Error error;
error.buffer() << "Incorrect file format for file: " << filename;
error.addbuf(512,19,"FooClass";
// --- OR
string message = "Incorrect file format for file: "+filename;
error.addwarning(512,19,"FooClass",message);
\endverbatim
*
* Newlines will be inserted into the error message automatically in order
* to format it for the string. Forced newlines can be specified with \n
*
* Programs can check whether or not errors have been generated using the []
* operator and can 'handle' them by outputing the message or dismissing
* them without any output
*
* Notices are generated using the public Notice class (see Notice())
*
* \b Error \b Levels:
* - \e 0 - 1: Errors expected to happen during normal execution
* - \e 2 - 9: Errors that a non-interactive program can handle and continue
* - \e 10-19: Errors that interactive program can handle (file not found,etc.)
* - \e 20- : Serious errors that should terminate execution
**/
class Error {
public:
/// Default constructor (use cerr for output and no log file)
/** Default max notice level is 9, min warning level is 2, and max warning
* level is 9 */
Error();
~Error();
/// Set a log file for error AND notice output
void set_logfile(ostream &out);
/// Returns the number of errors (if any) generated with id
unsigned operator[](unsigned id);
/// Add warning, terminate if level is greater than max level
/** Newlines will be inserted into the message automatically when the
* message is formatted for output. However, forced newlines can also
* be inserted. **/
void addwarning(unsigned ID, unsigned level, const string calling_class,
const string warning);
/// Add serious error (terminates execution)
void generate_error(unsigned ID, const string calling_class,
const string error);
/// Add an message to the error buffer. Warning generated with addbuf()
/** Newlines will be inserted into the message automatically when the
* message is formatted for output. However, forced newlines can also
* be inserted.
*
\verbatim
Error error;
error.buffer() << "Choice not supported: " << choice;
error.addbuf(512,9,"FooClass");
\endverbatim **/
ostringstream & buffer();
/// Generate warning with message in buffer
/** \sa buffer() **/
void addbuf(unsigned ID, unsigned level, const string calling_class);
/// Generate serious error with message in buffer
/** \sa buffer() **/
void addbuf(unsigned ID, const string calling_class);
/// Number of Unhandled Warnings
unsigned warnings();
/// Total number of warnings
unsigned total_warnings();
/// Handle all warnings with this ID by writing them to out
void writewarning(unsigned ID);
/// Handle LAST warning with this ID WITHOUT writing it
void dismiss_warning(unsigned ID);
/// Handle ALL warnings with this ID WITHOUT writing it
void dismiss_all_warnings(unsigned ID);
/// Handle all warnings by writing them out
void writewarnings();
/// Handle all warnings without writing
void dismiss_warnings();
/// Write out the total warnings (write errorcount errors)
void writetotals(unsigned errorcount);
/// For generating notices
/** \sa Notice **/
Notice note;
private:
struct ErrCom;
map<unsigned,vector<ErrCom> > warning_list;
typedef multimap<unsigned, vector<ErrCom> >::iterator warning_iter;
unsigned handled_warnings;
unsigned unhandled_warnings;
bool handleatend; // Write any unhandled errors on destruct
bool writetotalatend; // Write totals on destruct if not 0
unsigned min_level; // Don't output warnings less than min_level
unsigned max_level; // if a warning has a level>max_level error!
ostream *errout, *logout; // Output for errors and warnings!
ostream *nullout; // No output
ostringstream buffer_stream; // For creating messages for warnings
unsigned column_width;
void write_err(unsigned ID, ErrCom &err);
void writeline();
};
struct Error::ErrCom {
unsigned level;
string calling_class;
string message;
};
#endif
c4science · Help