CoinMessageHandler.hpp

Go to the documentation of this file.

/* $Id: CoinMessageHandler.hpp 1514 2011-12-10 23:35:23Z lou $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinMessageHandler_H
#define CoinMessageHandler_H

#include "CoinUtilsConfig.h"
#include "CoinPragma.hpp"

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>

/*
 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 included tests such
 as language and derivation in other unit tests.
*/
/*
  Where there are derived classes I (jjf) have started message numbers at 1001.
*/


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_=static_cast<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 newlanguage)
  {language_ = newlanguage;}
  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
};

class CoinMessageHandler  {

friend bool CoinMessageHandlerUnitTest () ;

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 setPrecision(unsigned int new_precision);
  inline int precision() { return (g_precision_) ; }

  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(int detail = -1) ;

  CoinMessageHandler &message(int externalNumber, const char *source,
                              const char *msg,
                              char severity, int detail = -1) ;

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


#define COIN_NUM_LOG 4
#define COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE 1000
protected:
  std::vector<double> doubleValue_;
  std::vector<int> 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_[COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE];
  char * messageOut_;
  std::string source_;
  int printStatus_;
  int highestNumber_;
  FILE * fp_;
  char g_format_[8];
  int g_precision_ ;

private:

  void gutsOfCopy(const CoinMessageHandler &rhs) ;

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

  int internalPrint() ;

  void calcPrintStatus(int msglvl, int msgclass) ;
    

};

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

#endif