IpJournalist.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpJournalist.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPJOURNALIST_HPP__
#define __IPJOURNALIST_HPP__

#include "IpoptConfig.h"
#include "IpTypes.hpp"
#include "IpReferenced.hpp"
#include "IpSmartPtr.hpp"

#ifdef HAVE_CSTDARG
# include <cstdarg>
#else
# ifdef HAVE_STDARG_H
#  include <stdarg.h>
# else
#  error "don't have header file for stdarg"
# endif
#endif

#include <string>
#include <vector>

namespace Ipopt
{

  // forward declarations
  class Journal;
  class FileJournal;

  enum EJournalLevel {
    J_INSUPPRESSIBLE=-1,
    J_NONE=0,
    J_ERROR,
    J_WARNING,
    J_SUMMARY,
    J_ITERSUMMARY,
    J_DETAILED,
    J_MOREDETAILED,
    J_VECTOR,
    J_MOREVECTOR,
    J_MATRIX,
    J_MOREMATRIX,
    J_ALL,
    J_LAST_LEVEL
  };

  enum EJournalCategory {
    J_DBG=0,
    J_STATISTICS,
    J_MAIN,
    J_INITIALIZATION,
    J_BARRIER_UPDATE,
    J_SOLVE_PD_SYSTEM,
    J_FRAC_TO_BOUND,
    J_LINEAR_ALGEBRA,
    J_LINE_SEARCH,
    J_HESSIAN_APPROXIMATION,
    J_SOLUTION,
    J_DOCUMENTATION,
    J_NLP,
    J_TIMING_STATISTICS,
    J_USER_APPLICATION  ,
    J_LAST_CATEGORY
  };

  class Journalist : public ReferencedObject
  {
  public:
    Journalist();

    virtual ~Journalist();

    void Printf(EJournalLevel level, EJournalCategory category,
                const char* format, ...) const;

    void PrintStringOverLines(EJournalLevel level, EJournalCategory category,
                              Index indent_spaces, Index max_length,
                              const std::string& line) const;

    void PrintfIndented(EJournalLevel level,
                        EJournalCategory category,
                        Index indent_level,
                        const char* format, ...) const;

    void VPrintf(EJournalLevel level,
                 EJournalCategory category,
                 const char* pformat,
                 va_list ap) const;

    void VPrintfIndented(EJournalLevel level,
                         EJournalCategory category,
                         Index indent_level,
                         const char* pformat,
                         va_list ap) const;

    bool ProduceOutput(EJournalLevel level,
                       EJournalCategory category) const;


    void FlushBuffer() const;

    bool AddJournal(const SmartPtr<Journal> jrnl);

    SmartPtr<Journal> AddFileJournal(
      const std::string& location_name,    
      const std::string& fname,
      EJournalLevel default_level = J_WARNING
    );

    SmartPtr<Journal> GetJournal(const std::string& location_name);

  private:
    Journalist(const Journalist&);

    void operator=(const Journalist&);

    //** Private Data Members. */
    std::vector< SmartPtr<Journal> > journals_;
  };

  class Journal : public ReferencedObject
  {
  public:
    Journal(const std::string& name, EJournalLevel default_level);

    virtual ~Journal();

    std::string Name();

    void SetPrintLevel(
      EJournalCategory category, EJournalLevel level
    );

    void SetAllPrintLevels(
      EJournalLevel level
    );

    bool IsAccepted(
      EJournalCategory category, EJournalLevel level
    ) const;

    void Print(const char* str)
    {
      PrintImpl(str);
    }

    void Printf(const char* pformat, va_list ap)
    {
      PrintfImpl(pformat, ap);
    }

    void FlushBuffer()
    {
      FlushBufferImpl();
    }

  protected:
    virtual void PrintImpl(const char* str)=0;

    virtual void PrintfImpl(const char* pformat, va_list ap)=0;

    virtual void FlushBufferImpl()=0;

  private:
    Journal();

    Journal(const Journal&);

    void operator=(const Journal&);

    std::string name_;

    Index print_levels_[J_LAST_CATEGORY];
  };


  class FileJournal : public Journal
  {
  public:
    FileJournal(const std::string& name, EJournalLevel default_level);

    virtual ~FileJournal();

    bool Open(const char* fname);

  protected:
    virtual void PrintImpl(const char* str);

    virtual void PrintfImpl(const char* pformat, va_list ap);

    virtual void FlushBufferImpl();

  private:
    FileJournal();

    FileJournal(const FileJournal&);

    void operator=(const FileJournal&);

    FILE* file_;
  };
}

#endif