textfile.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.

// Started in July 1997. Last revision: March 5, 2008.


#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);

        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)
{
        if (logstream && !copied)
                delete logstream;
        copied = false;
        logstream = new std::ofstream (filename);
        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;
        }
        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 */

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_