messages.h

Go to the documentation of this file.

/* Copyright (C) 2000, 2001 Stefan Buehler <sbuehler@uni-bremen.de>

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */

#ifndef messages_h
#define messages_h

#include <iostream>
#include <fstream>
#include "arts.h"

class Messages {
public:
  Messages() : screen(-1), file(-1) { /* nothing to do here */ }
  Index screen;
  Index file;
};


template<class T> 
void MessagePrint(ostream& os, Index priority, const T& t)
{
  extern Messages messages;
  extern ofstream report_file;

  // cout << "Printing object of type: " << typeid(t).name() << endl;

  if (messages.screen >= priority)
    os << t;

  if (messages.file >= priority)
    //    if (report_file)              // Check if report file is good
    {
      report_file << t;
      report_file.flush ();
    }
}

/* Parent class for all output streams. These control the level of detail
    for your output. There are four output streams altogether, out0 to
    out3. Out0 means highest priority, out3 lowest. Out0 and out1
    should not be used within methods, only by the ARTS engine.

    Nothing is done in this class, it just servers to group the four
    output stream classes together.

    \see Messages */
//class OutStream {
//};


class Out0 {
};

class Out1 {
};

class Out2 {
};

class Out3 {
};

//--------------------< Output Operators >--------------------

template<class T>
Out0& operator<<(Out0& os, const T& t)
{
  MessagePrint(cerr,0,t);
  return os;
}

template<class T>
Out1& operator<<(Out1& os, const T& t)
{
  //  cout << "Outing Object Of Type: " << Typeid(T).Name() << Endl;
  MessagePrint(cout,1,t);
  return os;
}

template<class T>
Out2& operator<<(Out2& os, const T& t)
{
  MessagePrint(cout,2,t);
  return os;
}

template<class T>
Out3& operator<<(Out3& os, const T& t)
{
  MessagePrint(cout,3,t);
  return os;
}

//----------< Make output streams globally visible >----------

extern Out0 out0;
extern Out1 out1;
extern Out2 out2;
extern Out3 out3; 



#endif // messages_h

---