/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinMessageHandler.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinMessageHandler_H
#define CoinMessageHandler_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif


#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include "CoinFinite.hpp"

/*
 I (jjf) am strongly in favo(u)r of language support for an open
 source project, but I have tried to make it as lightweight as
 possible in the sense that only a subset of messages need to be
 defined - the rest default to US English.  There will be different
 sets of messages for each component - so at present there is a
 Clp component and a Coin component.

 Because messages are only used in a controlled environment and have no
 impact on code and are tested by other tests I have include tests such
 as language and derivation in other unit tests.
*/

class CoinOneMessage {

public:
  CoinOneMessage();
  CoinOneMessage(int externalNumber, char detail,
                const char * message);
  ~CoinOneMessage();
  CoinOneMessage(const CoinOneMessage&);
  CoinOneMessage& operator=(const CoinOneMessage&);


  void replaceMessage(const char * message);

  inline int externalNumber() const
  {return externalNumber_;}
  inline void setExternalNumber(int number) 
  {externalNumber_=number;}
  inline char severity() const
  {return severity_;}
  inline void setDetail(int level)
  {detail_=(char) level;}
  inline int detail() const
  {return detail_;}
  inline char * message() const 
  {return message_;}


    int externalNumber_;
    char detail_;
    char severity_;
  mutable char message_[400];
};

class CoinMessages {

public:
  enum Language {
    us_en = 0,
    uk_en,
    it
  };

  CoinMessages(int numberMessages=0);
  ~CoinMessages();
  CoinMessages(const CoinMessages&);
  CoinMessages& operator=(const CoinMessages&);

  void addMessage(int messageNumber, const CoinOneMessage & message);
  void replaceMessage(int messageNumber, const char * message);
  inline Language language() const
  {return language_;}
  void setLanguage(Language language)
  {language_ = language;}
  void setDetailMessage(int newLevel, int messageNumber);
  void setDetailMessages(int newLevel, int numberMessages,
                         int * messageNumbers);
  void setDetailMessages(int newLevel, int low, int high);
  inline int getClass() const
  { return class_;}
  void toCompact();
  void fromCompact();


  int numberMessages_;
  Language language_;
  char source_[5];
  int class_;
  int lengthMessages_;
  CoinOneMessage ** message_;
};

// for convenience eol
enum CoinMessageMarker {
  CoinMessageEol = 0,
  CoinMessageNewline = 1
};

/*
  Where there are derived classes I (jjf) have started message numbers at 1001.
*/

class CoinMessageHandler  {

friend bool CoinMessageHandlerUnitTest () ;

private:
  void gutsOfCopy(const CoinMessageHandler& rhs);
  
public:
  virtual int print() ;
  virtual void checkSeverity() ;


  CoinMessageHandler();
  CoinMessageHandler(FILE *fp);
  virtual ~CoinMessageHandler();
  CoinMessageHandler(const CoinMessageHandler&);
  CoinMessageHandler& operator=(const CoinMessageHandler&);
  virtual CoinMessageHandler * clone() const;


  inline int detail(int messageNumber, const CoinMessages &normalMessage) const
  { return normalMessage.message_[messageNumber]->detail();}
  inline int logLevel() const
          { return logLevel_;}
  void setLogLevel(int value);
  inline int logLevel(int which) const
  { return logLevels_[which];}
  void setLogLevel(int which, int value);
  void setPrefix(bool yesNo);
  bool  prefix() const;
  inline double doubleValue(int position) const
  { return doubleValue_[position];}
  inline int numberDoubleFields() const
  {return static_cast<int>(doubleValue_.size());}
  inline int intValue(int position) const
  { return longValue_[position];}
  inline int numberIntFields() const
  {return static_cast<int>(longValue_.size());}
  inline char charValue(int position) const
  { return charValue_[position];}
  inline int numberCharFields() const
  {return static_cast<int>(charValue_.size());}
  inline std::string stringValue(int position) const
  { return stringValue_[position];}
  inline int numberStringFields() const
  {return static_cast<int>(stringValue_.size());}

  inline CoinOneMessage  currentMessage() const
  {return currentMessage_;}
  inline std::string currentSource() const
  {return source_;}
  inline const char * messageBuffer() const
  {return messageBuffer_;}
  inline int highestNumber() const
  {return highestNumber_;}
  inline FILE * filePointer() const
  { return fp_;}
  inline void setFilePointer(FILE * fp)
  { fp_ = fp;}
  
  CoinMessageHandler & message(int messageNumber,
                              const CoinMessages & messages);
  CoinMessageHandler & message();
  CoinMessageHandler & message(int externalNumber,const char * header,
                              const char * msg,char severity);
  CoinMessageHandler & operator<< (int intvalue);
#if COIN_BIG_INDEX==1

  CoinMessageHandler & operator<< (long longvalue);
#endif
#if COIN_BIG_INDEX==2

  CoinMessageHandler & operator<< (long long longvalue);
#endif

  CoinMessageHandler & operator<< (double doublevalue);
  CoinMessageHandler & operator<< (const std::string& stringvalue);
  CoinMessageHandler & operator<< (char charvalue);
  CoinMessageHandler & operator<< (const char *stringvalue);
  CoinMessageHandler & operator<< (CoinMessageMarker);
  int finish();
  CoinMessageHandler & printing(bool onOff);

  char * nextPerCent(char * start , const bool initial=false);
  int internalPrint();

#define COIN_NUM_LOG 4
protected:

  std::vector<double> doubleValue_;
  std::vector<long> longValue_;
  std::vector<char> charValue_;
  std::vector<std::string> stringValue_;
  int logLevel_;
  int logLevels_[COIN_NUM_LOG];
  int prefix_;
  CoinOneMessage  currentMessage_;
  int internalNumber_;
  char * format_;
  char messageBuffer_[1000];
  char * messageOut_;
  std::string source_;
  int printStatus_;
  int highestNumber_;
  FILE * fp_;
};

//#############################################################################
bool
CoinMessageHandlerUnitTest();

#endif

---