CoinMessageHandler.hpp

Go to the documentation of this file.

/* $Id: CoinMessageHandler.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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 "CoinTypes.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 CoinBigIndex 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< CoinBigIndex > 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

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/