CoinMessageHandler.hpp

// 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>

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 void setDetail(int level)
  {detail_=level;}
  inline int detail() const
  {return detail_;}
   char * message() const
  {return message_;}


    inline int externalNumber() const
  {return externalNumber_;}
    inline void setExternalNumber(int number) 
  {externalNumber_=number;}
  inline char severity() const
  {return severity_;}


    int externalNumber_;
    char detail_;
    char severity_;
  char * message_;
};

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);


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

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

class CoinMessageHandler  {
  
public:
   virtual int print() ;


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

  inline int logLevel() const
          { return logLevel_;}
  void setLogLevel(int value);
  void setPrefix(bool yesNo);
  bool  prefix() const;
  inline double doubleValue(int position) const
  { return doubleValue_[position];}
  inline int numberDoubleFields() const
  {return numberDoubleFields_;}
  inline int intValue(int position) const
  { return longValue_[position];}
  inline int numberIntFields() const
  {return numberIntFields_;}
  inline char charValue(int position) const
  { return charValue_[position];}
  inline int numberCharFields() const
  {return numberCharFields_;}
  inline std::string stringValue(int position) const
  { return stringValue_[position];}
  inline int numberStringFields() const
  {return numberStringFields_;}
  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();
  char * nextPerCent(char * start , const bool initial=false);
  CoinMessageHandler & operator<< (int intvalue);
  CoinMessageHandler & operator<< (long longvalue);
  CoinMessageHandler & operator<< (double doublevalue);
  CoinMessageHandler & operator<< (std::string stringvalue);
  CoinMessageHandler & operator<< (char charvalue);
  CoinMessageHandler & operator<< (const char *stringvalue);
  CoinMessageHandler & operator<< (CoinMessageMarker);
  int finish();
  CoinMessageHandler & printing(bool onOff);

  CoinMessageHandler & message(int externalNumber,const char * header,
                              const char * msg,char severity);
  
  
private:

  double doubleValue_[10];
  long longValue_[10];
  char charValue_[10];
  std::string stringValue_[10];
  int logLevel_;
  int prefix_;
  CoinOneMessage  currentMessage_;
  int internalNumber_;
  char * format_;
  int numberDoubleFields_;
  int numberIntFields_;
  int numberCharFields_;
  int numberStringFields_;
  char messageBuffer_[1000];
  char * messageOut_;
  std::string source_;
  int printStatus_;
  int highestNumber_;
  FILE * fp_;
};

#endif

---