CoinUtils  trunk
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
CoinMessageHandler.hpp
Go to the documentation of this file.
00001 /* $Id$ */
00002 // Copyright (C) 2002, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
00005 
00006 #ifndef CoinMessageHandler_H
00007 #define CoinMessageHandler_H
00008 
00009 #include "CoinUtilsConfig.h"
00010 #include "CoinPragma.hpp"
00011 
00012 #include <iostream>
00013 #include <cstdio>
00014 #include <string>
00015 #include <vector>
00016 
00031 /*
00032  I (jjf) am strongly in favo(u)r of language support for an open
00033  source project, but I have tried to make it as lightweight as
00034  possible in the sense that only a subset of messages need to be
00035  defined - the rest default to US English.  There will be different
00036  sets of messages for each component - so at present there is a
00037  Clp component and a Coin component.
00038 
00039  Because messages are only used in a controlled environment and have no
00040  impact on code and are tested by other tests I have included tests such
00041  as language and derivation in other unit tests.
00042 */
00043 /*
00044   Where there are derived classes I (jjf) have started message numbers at 1001.
00045 */
00046 
00047 
00058 class CoinOneMessage {
00059 
00060 public:
00064   CoinOneMessage();
00066   CoinOneMessage(int externalNumber, char detail,
00067                 const char * message);
00069   ~CoinOneMessage();
00071   CoinOneMessage(const CoinOneMessage&);
00073   CoinOneMessage& operator=(const CoinOneMessage&);
00075 
00078 
00079   void replaceMessage(const char * message);
00081 
00085   inline int externalNumber() const
00086   {return externalNumber_;}
00092   inline void setExternalNumber(int number) 
00093   {externalNumber_=number;}
00095   inline char severity() const
00096   {return severity_;}
00098   inline void setDetail(int level)
00099   {detail_=static_cast<char> (level);}
00101   inline int detail() const
00102   {return detail_;}
00104   inline char * message() const 
00105   {return message_;}
00107 
00110 
00111     int externalNumber_;
00113     char detail_;
00115     char severity_;
00117   mutable char message_[400];
00119 };
00120 
00128 class CoinMessages {
00129 
00130 public:
00136   enum Language {
00137     us_en = 0,
00138     uk_en,
00139     it
00140   };
00141 
00145   CoinMessages(int numberMessages=0);
00147   ~CoinMessages();
00149   CoinMessages(const CoinMessages&);
00151   CoinMessages& operator=(const CoinMessages&);
00153 
00161   void addMessage(int messageNumber, const CoinOneMessage & message);
00167   void replaceMessage(int messageNumber, const char * message);
00169   inline Language language() const
00170   {return language_;}
00172   void setLanguage(Language newlanguage)
00173   {language_ = newlanguage;}
00175   void setDetailMessage(int newLevel, int messageNumber);
00183   void setDetailMessages(int newLevel, int numberMessages,
00184                          int * messageNumbers);
00186   void setDetailMessages(int newLevel, int low, int high);
00187 
00189   inline int getClass() const
00190   { return class_;}
00192   void toCompact();
00194   void fromCompact();
00196 
00199 
00200   int numberMessages_;
00202   Language language_;
00204   char source_[5];
00206   int class_;
00210   int lengthMessages_;
00212   CoinOneMessage ** message_;
00214 };
00215 
00216 // for convenience eol
00217 enum CoinMessageMarker {
00218   CoinMessageEol = 0,
00219   CoinMessageNewline = 1
00220 };
00221 
00327 class CoinMessageHandler  {
00328 
00329 friend bool CoinMessageHandlerUnitTest () ;
00330 
00331 public:
00336   virtual int print() ;
00339   virtual void checkSeverity() ;
00341 
00344 
00345   CoinMessageHandler();
00347   CoinMessageHandler(FILE *fp);
00349   virtual ~CoinMessageHandler();
00351   CoinMessageHandler(const CoinMessageHandler&);
00353   CoinMessageHandler& operator=(const CoinMessageHandler&);
00355   virtual CoinMessageHandler * clone() const;
00357 
00359 
00360   inline int detail(int messageNumber, const CoinMessages &normalMessage) const
00361   { return normalMessage.message_[messageNumber]->detail();}
00363   inline int logLevel() const
00364           { return logLevel_;}
00382   void setLogLevel(int value);
00384   inline int logLevel(int which) const
00385   { return logLevels_[which];}
00390   void setLogLevel(int which, int value);
00391 
00393   void setPrecision(unsigned int new_precision);
00395   inline int precision() { return (g_precision_) ; }
00396 
00398   void setPrefix(bool yesNo);
00400   bool  prefix() const;
00406   inline double doubleValue(int position) const
00407   { return doubleValue_[position];}
00412   inline int numberDoubleFields() const
00413   {return static_cast<int>(doubleValue_.size());}
00419   inline int intValue(int position) const
00420   { return longValue_[position];}
00425   inline int numberIntFields() const
00426   {return static_cast<int>(longValue_.size());}
00432   inline char charValue(int position) const
00433   { return charValue_[position];}
00438   inline int numberCharFields() const
00439   {return static_cast<int>(charValue_.size());}
00445   inline std::string stringValue(int position) const
00446   { return stringValue_[position];}
00451   inline int numberStringFields() const
00452   {return static_cast<int>(stringValue_.size());}
00453 
00455   inline CoinOneMessage  currentMessage() const
00456   {return currentMessage_;}
00458   inline std::string currentSource() const
00459   {return source_;}
00461   inline const char * messageBuffer() const
00462   {return messageBuffer_;}
00464   inline int highestNumber() const
00465   {return highestNumber_;}
00467   inline FILE * filePointer() const
00468   { return fp_;}
00470   inline void setFilePointer(FILE * fp)
00471   { fp_ = fp;}
00473   
00482   CoinMessageHandler &message(int messageNumber,
00483                               const CoinMessages &messages) ;
00484 
00498   CoinMessageHandler & message(int detail = -1) ;
00499 
00512   CoinMessageHandler &message(int externalNumber, const char *source,
00513                               const char *msg,
00514                               char severity, int detail = -1) ;
00515 
00520   CoinMessageHandler & operator<< (int intvalue);
00521 #if COIN_BIG_INDEX==1
00522 
00526   CoinMessageHandler & operator<< (long longvalue);
00527 #endif
00528 #if COIN_BIG_INDEX==2
00529 
00533   CoinMessageHandler & operator<< (long long longvalue);
00534 #endif
00535 
00539   CoinMessageHandler & operator<< (double doublevalue);
00544   CoinMessageHandler & operator<< (const std::string& stringvalue);
00549   CoinMessageHandler & operator<< (char charvalue);
00554   CoinMessageHandler & operator<< (const char *stringvalue);
00559   CoinMessageHandler & operator<< (CoinMessageMarker);
00564   int finish();
00574   CoinMessageHandler & printing(bool onOff);
00575 
00577 
00586 #define COIN_NUM_LOG 4
00587 
00588 #define COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE 1000
00589 protected:
00592 
00593   std::vector<double> doubleValue_;
00594   std::vector<int> longValue_;
00595   std::vector<char> charValue_;
00596   std::vector<std::string> stringValue_;
00598   int logLevel_;
00600   int logLevels_[COIN_NUM_LOG];
00602   int prefix_;
00604   CoinOneMessage  currentMessage_;
00606   int internalNumber_;
00608   char * format_;
00610   char messageBuffer_[COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE];
00612   char * messageOut_;
00614   std::string source_;
00623   int printStatus_;
00625   int highestNumber_;
00627   FILE * fp_;
00629   char g_format_[8];
00631   int g_precision_ ;
00633 
00634 private:
00635 
00637   void gutsOfCopy(const CoinMessageHandler &rhs) ;
00638 
00643   char *nextPerCent(char *start, const bool initial = false) ;
00644 
00649   int internalPrint() ;
00650 
00652   void calcPrintStatus(int msglvl, int msgclass) ;
00653     
00654 
00655 };
00656 
00657 //#############################################################################
00663 bool
00664 CoinMessageHandlerUnitTest();
00665 
00666 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines