timeused.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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 of the License, or (at your option) any later version.
//
// This library 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// 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_