textfile.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/>.
 
// Started in July 1997. Last revision: February 25, 2013.
 
 
#ifndef _CHOMP_SYSTEM_TEXTFILE_H_
#define _CHOMP_SYSTEM_TEXTFILE_H_
 
#include "chomp/system/config.h"
 
#include <ctime>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
 
namespace chomp {
namespace homology {
 
 
// classes defined within this header file:
class textfile;
class outputstream;
 
 
// --------------------------------------------------
// ----------------- OUTPUT STREAM ------------------
// --------------------------------------------------
 
class outputstream
{
public:
        outputstream (std::ostream &_out = std::cout,
                bool _show = true, bool _flush = false);
 
        ~outputstream ();
 
        void logfile (const char *filename);
 
        void logfile (const outputstream &other);
 
        bool show;
 
        bool log;
 
        bool flush;
 
        std::ofstream *getlogstream (void);
 
        std::ostream &out;
 
        void keepforever (void);
 
        int precision () const;
 
        struct mute
        {
                mute (outputstream &_stream): stream (_stream),
                        show (_stream. show), log (_stream. log)
                        {stream. show = false; stream. log = false; return;}
                ~mute () {stream. show = show;
                        stream. log = log; return;}
                outputstream &stream;
                bool show;
                bool log;
        };
 
protected:
        std::ofstream *logstream;
 
        bool copied;
 
}; /* class outputstream */
 
// --------------------------------------------------
 
inline outputstream::outputstream (std::ostream &_out, bool _show,
        bool _flush): out (_out)
{
        show = _show;
        flush = _flush;
        log = false;
        logstream = NULL;
        copied = false;
        return;
} /* outputstream::outputstream */
 
inline void outputstream::logfile (const char *filename)
{
        // delete the previous log stream
        if (logstream && !copied)
                delete logstream;
 
        // make a note that this output stream is the master copy
        copied = false;
 
        // create a file stream to log the output to;
        // note: if "keepforever" is applied to the output stream
        // then this data structure is not released and produces
        // a small memory leak; however, the file is automatically
        // closed by the system; this may be necessary to avoid
        // a crash of the program if any other output streams
        // still want to write to a copy of this stream
        // upon program's shutdown
        logstream = new std::ofstream (filename);
 
        // warn if the log file could not be created
        if (!logstream || !*logstream)
        {
                out << "WARNING: Can't create '" << filename <<
                        "'. Logging to a file has been turned off." <<
                        std::endl;
                if (logstream)
                        delete logstream;
                logstream = NULL;
        }
 
        // otherwise set a flag indicating that logging to a file is on
        else
                log = true;
 
        return;
} /* outputstream::logfile */
 
inline void outputstream::logfile (const outputstream &other)
{
        if (!copied && logstream)
                delete logstream;
        logstream = other. logstream;
        if (logstream)
        {
                copied = true;
                log = true;
        }
        return;
} /* outputstream::logfile */
 
inline outputstream::~outputstream ()
{
        if (!copied && logstream)
                delete logstream;
        return;
} /* outputstream::~outputstream */
 
inline std::ofstream *outputstream::getlogstream (void)
{
        return logstream;
} /* outputstream::getlogstream */
 
inline void outputstream::keepforever (void)
{
        copied = true;
        return;
} /* outputstream::getlogstream */
 
inline int outputstream::precision () const
{
        return out. precision ();
} /* outputstream::precision */
 
template<typename type>
inline outputstream &operator << (outputstream &out, const type &object)
{
        if (out. flush)
        {
                if (out. show)
                        out. out << object << std::flush;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object << std::flush;
        }
        else
        {
                if (out. show)
                        out. out << object;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object;
        }
        return out;
} /* operator << */
 
inline outputstream &operator << (outputstream &out, const char *object)
{
        if (out. flush)
        {
                if (out. show)
                        out. out << object << std::flush;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object << std::flush;
        }
        else
        {
                if (out. show)
                        out. out << object;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object;
        }
        return out;
} /* operator << */
 
inline outputstream &operator << (outputstream &out,
        std::ostream& (*object)(std::ostream&))
{
        if (out. flush)
        {
                if (out. show)
                        out. out << object << std::flush;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object << std::flush;
        }
        else
        {
                if (out. show)
                        out. out << object;
                if (out. log && out. getlogstream ())
                        (*(out. getlogstream ())) << object;
        }
        return out;
} /* operator << */
 
// --------------------------------------------------
 
#ifndef OUTPUTSTREAM
#define OUTPUTSTREAM
#endif
 
extern outputstream sout;
 
extern outputstream scon;
 
extern outputstream serr;
 
extern outputstream slog;
 
extern outputstream sbug;
 
extern outputstream sseq;
 
 
// --------------------------------------------------
// ----------------- various tools ------------------
// --------------------------------------------------
 
template <class type>
inline void swapelements (type &x, type &y)
{
        type z (x);
        x = y;
        y = z;
        return;
} /* swapelements */
 
template <class type>
inline int sortelements (type *tab, int n)
{
        switch (n)
        {
        case 0:
                return 0;
        case 1:
                return 1;
        case 2:
                if (tab [0] == tab [1])
                        return 1;
                else if (tab [0] > tab [1])
                        swapelements (tab [0], tab [1]);
                return 2;
        default:
                for (int i = 0; i < n - 1; ++ i)
                {
                        for (int j = i + 1; j < n; ++ j)
                                if (tab [i] > tab [j])
                                        swapelements (tab [i],
                                                tab [j]);
 
                        if (tab [i] == tab [i + 1])
                        {
                                -- n;
                                for (int j = i + 1; j < n; ++ j)
                                        tab [j] = tab [j + 1];
                        }
                }
                break;
        }
        return n;
} /* sortelements */
 
inline void ignoreline (std::istream &in)
{
        in. ignore (0x7FFFFFFFl, '\n');
        return;
} /* ignoreline */
 
inline void ignorecomments (std::istream &in)
{
        int ch = in. peek ();
        while (true)
        {
                switch (ch)
                {
                case ';':
                        ignoreline (in);
                        ch = in. peek ();
                        break;
                case ' ':
                case '\t':
                case '\r':
                case '\n':
                        in. get ();
                        ch = in. peek ();
                        break;
                default:
                        return;
                }
        }       
} /* ignorecomments */
 
inline int closingparenthesis (int ch)
{
        switch (ch)
        {
                case '(':
                        return ')';
                case '{':
                        return '}';
                case '[':
                        return ']';
                case '<':
                        return '>';
                case '/':
                        return '/';
                default:
                        return EOF;
        }
} /* closingparenthesis */
 
inline int readparenthesis (std::istream &in)
{
        int closing = closingparenthesis (in. peek ());
        if (closing != EOF)
                in. get ();
        return closing;
} /* readparenthesis */
 
inline std::string commandline (int argc, char *argv [])
{
        std::string s;
        for (int i = 0; i < argc; ++ i)
        {
                if (i)
                        s += ' ';
                s += argv [i];
        }
        return s;
} /* commandline */
 
inline const char *currenttime (void)
{
        std::time_t t;
        std::time (&t);
        return std::asctime (std::localtime (&t));
} /* currenttime */
 
template <class settype>
static void savetheset (const settype &c, const char *prefix,
        const char *filename, const char *name)
{
        // if there is no prefix given, do not save the file
        if (!prefix)
                return;
 
        // prepare the full file name
        std::string str;
        if (prefix)
                str = std::string (prefix) + std::string (filename);
        else
                str = filename;
        const char *s = str. c_str ();
 
        // create the output file
        std::ofstream out (s);
        if (!out)
        {
                sout << "WARNING: Cannot save the file '" << s << "'.\n";
                return;
        }
 
        // write the cubes to the output file
        sout << "Saving " << name << " to '" << s << "'... ";
        out << "; This is " << name << ".\n";
        out << c;
        sout << "Done.\n";
 
        return;
} /* savetheset */
 
 
// --------------------------------------------------
// ----------------- ERROR MESSAGE ------------------
// --------------------------------------------------
 
#define ERRORMSG {std::ostringstream error_msg_string; error_msg_string
 
#define THROW ""; throw error_msg_string. str (). c_str (); }
 
// --------------------------------------------------
 
inline void fileerror (const char *filename, const char *what = "open")
{
        ERRORMSG << "Cannot " << what << " the file '" <<
                filename << "'." << THROW
        return;
} /* fileerror */
 
 
// --------------------------------------------------
// -------------------- TEXTFILE --------------------
// --------------------------------------------------
 
#define MAXTEXTLENGTH 200
 
class textfile
{
public:
        textfile ();
 
        textfile (std::istream &in);
 
        // a constructor which opens a file
//      textfile (char *filename);
 
        int open (const char *filename);
 
        void close ();
 
        ~textfile ();
 
        long readnumber (long defaultnumber = 0, int ignorecolons = 0);
 
        int checkchar ();
 
        int readchar ();
 
        int readword (char *buf, int maxlength);
 
        int readphrase (const char *phrase);
 
        void ignoreline ();
 
        long linenumber ();
 
        operator int ();
 
private:
        int ch;
 
        long line;
 
        std::ifstream *fs;
 
        std::istream *s;
 
        void ignorespaces ();
 
}; /* class textfile */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_SYSTEM_TEXTFILE_H_