Gambit::Logging Namespace Reference

Forward declare minimial logging components needed to use logger. More...

Classes
class	BaseLogger
	Logger virtual base class. More...
struct	endofmessage
	Special (empty) struct for signalling end of message to LogMaster stream. More...
class	LogMaster
	Logging "controller" object Keeps track of the various "Logger" objects. More...
struct	Message
	structure for storing log messages and metadata More...
struct	SortedMessage
	structure for storing log messages and metadata after tags are sorted More...
class	StdLogger
	Logger for 'standard' messages. More...

Typedefs
typedef std::ostream &(*	manip1) (std::ostream &)
typedef std::basic_ios< std::ostream::char_type, std::ostream::traits_type >	ios_type
typedef ios_type &(*	manip2) (ios_type &)
typedef std::ios_base &(*	manip3) (std::ios_base &)

Functions
int	str2tag (const std::string &)
std::map< int, std::string > &	tag2str ()
std::set< int > &	components ()
const std::set< LogTag > &	msgtypes ()
const std::set< LogTag > &	flags ()
const std::set< LogTag > &	echoes ()
int	getfreetag ()
void	checktags ()
	Function to inspect tags and their associated strings. For testing purposes only. More...
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &, const std::string &)
	Stream functions for use with LogMaster. More...
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &logobj, const LogTag &tag)
	Handle LogTag input. More...
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &logobj, const endofmessage &eom)
	Handle end of message character. More...
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &logobj, const manip1 fp)
	Handle various stream manipulators. More...
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &, const manip2)
EXPORT_SYMBOLS LogMaster &	operator<< (LogMaster &, const manip3)
template<typename TYPE >
LogMaster &	operator<< (LogMaster &logobj, const TYPE &input)
template<typename TYPE >
LogMaster &	operator<< (LogMaster &logobj, TYPE &input)

Variables
const bool	verbose = false

Detailed Description

Forward declare minimial logging components needed to use logger.

Typedef Documentation

ios_type

typedef std::basic_ios< std::ostream::char_type, std::ostream::traits_type > Gambit::Logging::ios_type

Definition at line 58 of file logger.hpp.

manip1

typedef std::ostream&(* Gambit::Logging::manip1) (std::ostream &)

Definition at line 57 of file logger.hpp.

manip2

typedef ios_type&(* Gambit::Logging::manip2) (ios_type &)

Definition at line 59 of file logger.hpp.

manip3

typedef std::ios_base&(* Gambit::Logging::manip3) (std::ios_base &)

Definition at line 60 of file logger.hpp.

Function Documentation

checktags()

void Gambit::Logging::checktags

(

)

Function to inspect tags and their associated strings. For testing purposes only.

Definition at line 163 of file logging.cpp.

References components(), echoes(), flags(), msgtypes(), and tag2str().

    {
       std::cout<<"Checking message type LogTags..."<<std::endl;
       for(std::set<LogTag>::iterator tag = msgtypes().begin(); tag != msgtypes().end(); ++tag)
       {
         std::cout<<"  "<<*tag<<" : "<<tag2str()[*tag]<<std::endl;
       }
       std::cout<<"Checking message flag LogTags..."<<std::endl;
       for(std::set<LogTag>::iterator tag = flags().begin(); tag != flags().end(); ++tag)
       {
         std::cout<<"  "<<*tag<<" : "<<tag2str()[*tag]<<std::endl;
       }
       std::cout<<"Checking message echo LogTags..."<<std::endl;
       for(std::set<LogTag>::iterator tag = echoes().begin(); tag != echoes().end(); ++tag)
       {
         std::cout<<"  "<<*tag<<" : "<<tag2str()[*tag]<<std::endl;
       }
       std::cout<<"Checking Gambit component LogTags..."<<std::endl;
       for(std::set<int>::iterator tag = components().begin(); tag != components().end(); ++tag)
       {
         std::cout<<"  "<<*tag<<" : "<<tag2str()[*tag]<<std::endl;
       }
       std::cout<<"LogTag check finished."<<std::endl;
    }

Here is the call graph for this function:

components()

std::set< int > & Gambit::Logging::components

(

)

Definition at line 81 of file logging.cpp.

References Gambit::LogTags::backends, Gambit::LogTags::core, Gambit::LogTags::debug, Gambit::LogTags::def, Gambit::LogTags::dependency_resolver, Gambit::LogTags::err, Gambit::LogTags::fatal, Gambit::LogTags::info, Gambit::LogTags::inifile, Gambit::LogTags::logs, Gambit::LogTags::models, Gambit::LogTags::nonfatal, Gambit::LogTags::printers, Gambit::LogTags::repeat_to_cerr, Gambit::LogTags::repeat_to_cout, Gambit::LogTags::scanner, Gambit::LogTags::utils, and Gambit::LogTags::warn.

Referenced by checktags(), Gambit::register_module_with_log(), and Gambit::Logging::SortedMessage::SortedMessage().

    {
      // We add the core components here, but the module and backend numbers are added later, so the set cannot be const.
      static LogTag core_a[] = {def, core, logs, models, dependency_resolver, scanner, inifile, printers, utils, backends};
      static std::set<int> components_set(core_a, core_a+sizeof(core_a)/sizeof(core_a[0]));
      return components_set;
    }

Here is the caller graph for this function:

echoes()

const std::set< LogTag > & Gambit::Logging::echoes

(

)

Definition at line 73 of file logging.cpp.

References Gambit::LogTags::repeat_to_cerr, and Gambit::LogTags::repeat_to_cout.

Referenced by checktags(), and Gambit::Logging::SortedMessage::SortedMessage().

    {
      static LogTag echoes_a[] = {repeat_to_cout, repeat_to_cerr};
      static const std::set<LogTag> echoes_set(echoes_a, echoes_a+sizeof(echoes_a)/sizeof(echoes_a[0]));
      return echoes_set;
    }

Here is the caller graph for this function:

flags()

const std::set< LogTag > & Gambit::Logging::flags

(

)

Definition at line 65 of file logging.cpp.

References Gambit::LogTags::fatal, and Gambit::LogTags::nonfatal.

Referenced by checktags(), Gambit::Scanner::Plugins::Plugin_Loader::Plugin_Loader(), and Gambit::Logging::SortedMessage::SortedMessage().

    {
      static LogTag flags_a[] = {fatal, nonfatal};
      static const std::set<LogTag> flags_set(flags_a, flags_a+sizeof(flags_a)/sizeof(flags_a[0]));
      return flags_set;
    }

Here is the caller graph for this function:

getfreetag()

int Gambit::Logging::getfreetag

(

)

Definition at line 138 of file logging.cpp.

References tag2str().

Referenced by Gambit::register_module_with_log().

    {
      for(int i=0; i<std::numeric_limits<int>::max(); ++i)
      {
        if( tag2str().count(i) == 0 ) { return i; }
      }
      // Uh oh, seems like we ran out of integers. If this happens you are screwed, and we have to rewrite the code to use long ints instead, or you have to unhook some modules.
      // Cannot log this because we are outside the LogMaster class code.
      std::ostringstream ss;
      ss << "Error in logger.cpp! It seems that you have so many logging tags that you have exceeded the maximum allowed integer. There is no way you can fix this except to have fewer modules hooked up to gambit all at once. Otherwise we have to rewrite the logger to work with long ints or some such" << std::endl;
      throw std::overflow_error( ss.str() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

msgtypes()

const std::set< LogTag > & Gambit::Logging::msgtypes

(

)

Definition at line 57 of file logging.cpp.

References Gambit::LogTags::debug, Gambit::LogTags::err, Gambit::LogTags::info, and Gambit::LogTags::warn.

Referenced by checktags(), and Gambit::Logging::SortedMessage::SortedMessage().

    {
      static LogTag msg_a[] = {debug, info, warn, err};
      static const std::set<LogTag> msgtypes_set(msg_a, msg_a+sizeof(msg_a)/sizeof(msg_a[0]));
      return msgtypes_set;
    }

Here is the caller graph for this function:

operator<<() [1/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const std::string &	in
	)

Stream functions for use with LogMaster.

{@ Stream functions overloads for working with the logger

Stream functions for use with LogMaster

Definition at line 52 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(in);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [2/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const LogTag &	tag
	)

Handle LogTag input.

Definition at line 59 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(tag);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [3/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const endofmessage &	eom
	)

Handle end of message character.

Definition at line 66 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(eom);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [4/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const manip1	fp
	)

Handle various stream manipulators.

Definition at line 73 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(fp);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [5/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const manip2	fp
	)

Definition at line 79 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(fp);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [6/8]

LogMaster & Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const manip3	fp
	)

Definition at line 85 of file logger.cpp.

References Gambit::Logging::LogMaster::input().

     {
        logobj.input(fp);
        return logobj;
     }

Here is the call graph for this function:

operator<<() [7/8]

template<typename TYPE >

LogMaster& Gambit::Logging::operator<<	(	LogMaster &	logobj,
		const TYPE &	input
	)

Definition at line 78 of file logger.hpp.

     {
       using ::Gambit::operator<<; // Unhide operator overloads in Gambit scope
       std::stringstream ss;
       ss << input;
       logobj << ss.str();
       return logobj;
     }

operator<<() [8/8]

template<typename TYPE >

LogMaster& Gambit::Logging::operator<<	(	LogMaster &	logobj,
		TYPE &	input
	)

Definition at line 88 of file logger.hpp.

     {
       using ::Gambit::operator<<; // Unhide operator overloads in Gambit scope
       std::stringstream ss;
       ss << input;
       logobj << ss.str();
       return logobj;
     }

str2tag()

int Gambit::Logging::str2tag

(

const std::string &

tagname

)

Definition at line 152 of file logging.cpp.

References tag2str().

Referenced by Gambit::backend_functor_common< TYPE(*)(ARGS...), TYPE, ARGS... >::backend_functor_common(), Gambit::Logging::LogMaster::initialise(), and Gambit::module_functor_common::module_functor_common().

    {
       for(std::map<int,std::string>::iterator tag = tag2str().begin(); tag != tag2str().end(); ++tag)
       {
         if (tag->second == tagname) { return tag->first; }
       }
       // Uh oh, no match found. Return fail code and let caller deal with it
       return -1;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

tag2str()

std::map< int, std::string > & Gambit::Logging::tag2str

(

)

Definition at line 130 of file logging.cpp.

Referenced by checktags(), getfreetag(), Gambit::register_module_with_log(), Gambit::Logging::SortedMessage::SortedMessage(), str2tag(), and Gambit::Logging::StdLogger::writetags().

    {
      // Can't be const because we will add to it from the module/backend macros
      static std::map<int,std::string> tag2str_map = create_tag_names();
      return tag2str_map;
    }

Here is the caller graph for this function:

Variable Documentation

verbose

const bool Gambit::Logging::verbose = false

Definition at line 52 of file logging.cpp.

Referenced by Gambit::PostProcessor::get_done_points(), and scanner_plugin().