timeused.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 3 of the License, or (at your option) any later version.
//
// This software 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 software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// You may want to include "textfile.h" before this file.
// Started on March 23, 2002. Last revision: February 9, 2003.
 
// NOTE: If you do not want to control the time measurement, but only want
// to make your program display a "Time used" message at its termination,
// then it is enough that you only link your program with "timeused.cpp"
// without even including this header file in your code.
 
 
#ifndef _CHOMP_SYSTEM_TIMEUSED_H_
#define _CHOMP_SYSTEM_TIMEUSED_H_
 
#include "chomp/system/config.h"
 
#include <ctime>
#include <iostream>
 
namespace chomp {
namespace homology {
 
 
// classes defined within this header file:
class timeused;
 
 
// --------------------------------------------------
// ------------------- TIMEUSED ---------------------
// --------------------------------------------------
 
class timeused
{
public:
        timeused (const char *msg = NULL);
        timeused (std::ostream &out, const char *msg = NULL);
 
        ~timeused ();
 
        timeused &operator = (std::ostream &out);
 
        #ifdef OUTPUTSTREAM
        timeused &operator = (outputstream &out);
        #endif
 
        timeused &operator = (int n);
 
        timeused &operator = (const char *msg);
 
        timeused &reset ();
 
        operator double ();
 
        void show (std::ostream &out, const char *message = NULL) const;
 
        void show (const char *message = NULL) const;
 
        friend std::ostream &operator << (std::ostream &out,
                const timeused &t);
 
protected:
        double cpu0;
        
        std::time_t t0;
 
        std::ostream *outstream1;
 
        std::ostream *outstream2;
 
        const char *message;
 
        int display;
 
}; /* timeused */
 
// --------------------------------------------------
 
inline timeused::timeused (const char *msg)
{
        reset ();
        outstream1 = NULL;
        outstream2 = NULL;
        message = msg;
        display = -1;
        return;
} /* timeused::timeused */
 
inline timeused::timeused (std::ostream &out, const char *msg)
{
        reset ();
        outstream1 = &out;
        outstream2 = NULL;
        message = msg;
        display = -1;
        return;
} /* timeused::timeused */
 
inline void timeused::show (std::ostream &out, const char *msg) const
{
        if (!msg)
                msg = message;
        if (!msg)
                msg = "Time used:";
 
        out << msg << ' ' << *this << '.' << std::endl;
 
        return;
} /* timeused::show */
 
inline timeused::~timeused ()
{
        if (!display || (!outstream1 && !outstream2))
                return;
        if ((display > 0) || (double (*this) > 1))
        {
                if (outstream1)
                        show (*outstream1);
                if (outstream2)
                        show (*outstream2);
        }
        return;
} /* timeused::~timeused */
 
inline timeused &timeused::operator = (std::ostream &out)
{
        outstream1 = &out;
        outstream2 = NULL;
        return *this;
} /* timeused::operator = */
 
#ifdef OUTPUTSTREAM
inline timeused &timeused::operator = (outputstream &out)
{
        if (out. show)
                outstream1 = &(out. out);
        else
                outstream1 = NULL;
        if (out. log)
                outstream2 = out. getlogstream ();
        else
                outstream2 = NULL;
        return *this;
} /* operator = */
#endif
 
inline timeused &timeused::operator = (int n)
{
        display = n;
        return *this;
} /* timeused::operator = */
 
inline timeused &timeused::operator = (const char *msg)
{
        message = msg;
        return *this;
} /* timeused::operator = */
 
inline void timeused::show (const char *msg) const
{
        if (outstream1)
                show (*outstream1, msg);
        if (outstream2)
                show (*outstream2, msg);
        return;
} /* timeused::show */
 
// --------------------------------------------------
 
#ifndef TIMEUSED
#define TIMEUSED
#endif
 
extern timeused program_time;
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_SYSTEM_TIMEUSED_H_