arg.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" and "timeused.h" before this file.
// Started on March 3, 2002. Last revision: March 9, 2007.


#ifndef _CHOMP_SYSTEM_ARG_H_
#define _CHOMP_SYSTEM_ARG_H_

#include "chomp/system/config.h"

#include <iostream>
#include <iomanip>
#include <cstring>
#include <sstream>
#include <cctype>

namespace chomp {
namespace homology {

// the main front-end class defined in this file
class arguments;


// --------------------------------------------------
// -------------------- argflags --------------------
// --------------------------------------------------

class argflags
{
public:
        enum names {obligatory = 0x01, hasdefault = 0x02,
                filled = 0x04, breakinterpreting = 0x08,
                toomany = 0x10, missingvalue = 0x20,
                readerror = 0x40, ignorevalue = 0x80};

        argflags (): n (0) {}

        ~argflags () {}

        void set (int flag) {n |= flag;}

        void unset (int flag) {n &= ~flag;}

        bool get (int flag) const {return !!(n & flag);}

private:
        int n;

}; /* argflags */


// --------------------------------------------------
// ------------------- argelement -------------------
// --------------------------------------------------

class argelement
{
public:
        argelement (const char *_name);

        virtual ~argelement ();

        const char *getname () const;

        char *getvalue (char *str);

        virtual int setvalue (char *str, char *next) = 0;

        virtual void restore () = 0;

        virtual void show (std::ostream &out) const = 0;

        void resetflags ();

        void set (int flag);

        void unset (int flag);

        bool get (int flag) const;

private:
        char *name;

        argflags flags;

}; /* class argelement */

inline argelement::argelement (const char *_name): flags ()
{
        if (!_name || !*_name)
                name = NULL;
        else
        {
                name = new char [strlen (_name) + 1];
                strcpy (name, _name);
        }
        return;
} /* argelement::argelement */

inline argelement::~argelement ()
{
        if (name)
                delete [] name;
        return;
} /* argelement::~argelement */

inline const char *argelement::getname () const
{
        return name;
} /* argelement::getname */

inline void argelement::resetflags ()
{
        flags. unset (argflags::filled);
        flags. unset (argflags::readerror);
        flags. unset (argflags::toomany);
        flags. unset (argflags::missingvalue);
        return;
} /* argelement::resetflags */

inline void argelement::set (int flag)
{
        flags. set (flag);
        return;
} /* argelement::set */

inline void argelement::unset (int flag)
{
        flags. unset (flag);
        return;
} /* argelement::unset */

inline bool argelement::get (int flag) const
{
        return flags. get (flag);
} /* argelement::get */

inline std::ostream &operator << (std::ostream &out, const argelement &p)
{
        p. show (out);
        return out;
} /* operator << */


// --------------------------------------------------
// -------------------- argunit ---------------------
// --------------------------------------------------

template <class type>
class argunit: public argelement
{
public:
        argunit (const char *_name, type &_value);

        argunit (const char *_name, type &_value, type defaultvalue);

        argunit (const char *_name, type *_value, int &_count,
                int _size);

        argunit (const char *_name, type *_value, int &_count,
                int _size, type defaultvalue);

        int setvalue (char *str, char *next);

        void restore ();

        void show (std::ostream &out) const;

private:
        type &value;

        type defaultvalue;

        type previousvalue;

        type *table;

        int *count;

        int previouscount;

        int size;

}; /* class argunit */

template <class type>
inline argunit<type>::argunit (const char *_name, type &_value):
        argelement (_name), value (_value), previousvalue (_value),
        table (NULL)
{
        return;
} /* argunit<type>::argunit */

template <class type>
inline argunit<type>::argunit (const char *_name, type &_value,
        type _defaultvalue):
        argelement (_name), value (_value), defaultvalue (_defaultvalue),
        previousvalue (_value), table (NULL)
{
        set (argflags::hasdefault);
        return;
} /* argunit<type>::argunit */

template <class type>
inline argunit<type>::argunit (const char *_name, type *_value,
        int &_count, int _size):
        argelement (_name), value (*_value), previousvalue (*_value),
        table (_value), count (&_count), previouscount (_count),
        size (_size)
{
        return;
} /* argunit<type>::argunit */

template <class type>
inline argunit<type>::argunit (const char *_name, type *_value,
        int &_count, int _size, type _defaultvalue):
        argelement (_name), value (*_value), defaultvalue (_defaultvalue),
        previousvalue (*_value), table (_value),
        count (&_count), previouscount (_count), size (_size)
        
{
        set (argflags::hasdefault);
        return;
} /* argunit<type>::argunit */

template <class type>
inline int readfromstring (char *str, type &t)
{
        std::istringstream s (str);
        try
        {
                s >> t;
                if (!s)
                        return -1;
        }
        catch (...)
        {
                return -1;
        }
        return 0;
} /* readfromstring */

inline int readfromstring (char *str, char *&t)
{
        t = str;
        return 0;
} /* readfromstring */

// This function was added by Tomek Kapela. His remark
// justifying this addition: "e.g to replace default constant C strings".
inline int readfromstring (char *str, const char *&t)
{
        t = str;
        return 0;
} /* readfromstring */

inline int readfromstring (char *str, bool &t)
{
        switch (*str)
        {
                case 'T':
                case 't':
                case 'Y':
                case 'y':
                case '1':
                        t = true;
                        return 0;
                case 'F':
                case 'f':
                case 'N':
                case 'n':
                case '0':
                        t = false;
                        return 0;
                default:
                        return -1;
        }
} /* readfromstring */

template <class type>
inline int argunit<type>::setvalue (char *str, char *next)
{
        // determine the string from which the value should be read
        int usenext = 0;
        char *s;
        if (str && *str)
                s = str;
        else
        {
                if (next && *next && ((*next != '-') ||
                        std::isdigit (next [1])))
                {
                        s = next;
                        usenext = 1;
                }
                else
                        s = NULL;
        }

        // read the element from the string if available
        int result = -1;
        type element;
        if (s)
                result = readfromstring (s, element);

        // if could not read the string, try the default value
        if (result < 0)
        {
                if (get (argflags::hasdefault))
                {
                        element = defaultvalue;
                        usenext = 0;
                }
                else
                {
                        if (s)
                                set (argflags::readerror);
                        else
                                set (argflags::missingvalue);
                        return 0;
                }
        }

        // put the element to its place
        if (table)
                // if there is still room in the table, put the element there
                if (*count < size)
                        table [(*count) ++] = element;
                // if the table is full, indicate it
                else
                {
                        set (argflags::toomany);
                        set (argflags::filled);
                }
        else
        {
                value = element;
                set (argflags::filled);
        }

        return usenext;
} /* argunit<type>::setvalue */

template <class type>
void argunit<type>::restore ()
{
        if (!table)
                value = previousvalue;
        else
                *count = previouscount;
        resetflags ();
        return;
} /* argunit<type>::restore */

template <class type>
void argunit<type>::show (std::ostream &out) const
{
        if (get (argflags::obligatory))
                out << "Oblig. ";
        if (getname () && *getname ())
        {
                if (get (argflags::ignorevalue))
                        out << "Switch";
                else
                        out << "Param.";
                out << " '-" << getname () << "'";
        }
        else
                out << "Word";
        if (!table && get (argflags::filled))
                out << " set to '" << value << "'";
        else if (table && *count)
        {
                for (int i = 0; i < *count; ++ i)
                        out << (i ? ", " : " set to '") << table [i];
                out << "'";
                if (get (argflags::toomany))
                        out << " [too many!]";
        }
        else
                out << " not found";
        if (get (argflags::hasdefault))
                out << " (default: '" << defaultvalue << "')";
        else
                out << " (no default value)";
        out << "." << std::endl;
        return;
} /* argunit<type>::show */


// --------------------------------------------------
// ------------------- arguments --------------------
// --------------------------------------------------

class arguments
{
public:
        arguments ();

        ~arguments ();

        void add (argelement *p);

        int remove (char *name);

        int analyze (int argc, char *argv [],
                std::ostream &out = std::cerr);

        void reset ();

        friend std::ostream &operator << (std::ostream &out,
                arguments &p);

private:
        int n;

        int length;

        argelement **tab;

        void inctable ();

}; /* class arguments */

inline arguments::arguments ()
{
        n = 0;
        length = 0;
        tab = NULL;
        return;
} /* arguments::arguments */

inline void arguments::add (argelement *p)
{
        inctable ();
        tab [n ++] = p;
        return;
} /* arguments::add */

// --------------------------------------------------

template <class type>
inline void arg (arguments &a, const char *name, type &value)
{
        argunit<type> *p = new argunit<type> (name, value);
        a. add (p);
        return;
} /* arg */

template <class type>
inline void arg (arguments &a, const char *name, type &value,
        type defaultvalue)
{
        argunit<type> *p = new argunit<type> (name, value, defaultvalue);
        a. add (p);
        return;
} /* arg */

inline void arg (arguments &a, const char *name, char *&value,
        const char *defaultvalue)
{
        argunit<char *> *p =
                new argunit<char *> (name, value,
                        const_cast<char *> (defaultvalue));
        a. add (p);
        return;
} /* arg */

template <class type>
inline void arg (arguments &a, const char *name, type *value,
        int &count, int size)
{
        argunit<type> *p = new argunit<type> (name, value, count, size);
        a. add (p);
        return;
} /* arg */

template <class type>
inline void arg (arguments &a, const char *name, type *value,
        int &count, int size, type defaultvalue)
{
        argunit<type> *p = new argunit<type> (name, value, count, size,
                defaultvalue);
        a. add (p);
        return;
} /* argoblig */

template <class type>
inline void argoblig (arguments &arg, const char *name, type &value)
{
        argunit<type> *p = new argunit<type> (name, value);
        p -> set (argflags::obligatory);
        arg. add (p);
        return;
} /* argoblig */

template <class type>
inline void argoblig (arguments &arg, const char *name, type &value,
        type defaultvalue)
{
        argunit<type> *p = new argunit<type> (name, value, defaultvalue);
        p -> set (argflags::obligatory);
        arg. add (p);
        return;
} /* argoblig */

inline void argoblig (arguments &arg, const char *name, char *&value,
        const char *defaultvalue)
{
        argunit<char *> *p =
                new argunit<char *> (name, value, (char *) defaultvalue);
        p -> set (argflags::obligatory);
        arg. add (p);
        return;
} /* argoblig */

template <class type>
inline void argbreak (arguments &arg, const char *name, type &value)
{
        argunit<type> *p = new argunit<type> (name, value);
        p -> set (argflags::breakinterpreting);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argbreak */

template <class type>
inline void argbreak (arguments &arg, const char *name, type &value,
        type defaultvalue)
{
        argunit<type> *p = new argunit<type> (name, value, defaultvalue);
        p -> set (argflags::breakinterpreting);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argbreak */

inline void argbreak (arguments &arg, const char *name, char *&value,
        const char *defaultvalue)
{
        argunit<char *> *p =
                new argunit<char *> (name, value, (char *) defaultvalue);
        p -> set (argflags::breakinterpreting);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argbreak */

inline void argbreak (arguments &arg, const char *name)
{
        char *dummystring = NULL;
        argunit<char *> *p = new argunit<char *> (name, dummystring);
        p -> set (argflags::breakinterpreting);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argbreak */

template <class type>
inline void argswitch (arguments &arg, const char *name, type &value,
        const type &defaultvalue)
{
        argunit<type> *p = new argunit<type> (name, value, defaultvalue);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argswitch */

inline void argswitch (arguments &arg, const char *name, char *&value,
        const char *defaultvalue)
{
        argunit<char *> *p =
                new argunit<char *> (name, value, (char *) defaultvalue);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argswitch */

inline void argswitch (arguments &arg, const char *name)
{
        char *dummystring = NULL;
        argunit<char *> *p = new argunit<char *> (name, dummystring);
        p -> set (argflags::ignorevalue);
        arg. add (p);
        return;
} /* argswitch */

inline void arghelp (arguments &a)
{
        argbreak (a, "?");
        argbreak (a, "h");
        argbreak (a, "H");
        argbreak (a, "-help");
        return;
} /* arghelp */

// --------------------------------------------------

#ifdef OUTPUTSTREAM

inline void argstreams (arguments &a, char *&logfilename, char *&seqfilename,
        bool &quiet, bool &debug)
{
        arg (a, "-log", logfilename);
        arg (a, "-seq", seqfilename);
        argswitch (a, "-quiet", quiet, true);
        argswitch (a, "-debug", debug, true);
        return;
} /* argstreams */

inline void setstreams (const char *logfilename, char *seqfilename,
        bool quiet, bool debug)
{
        if (debug)
                sbug. show = true;
        if (quiet)
        {
                sout. show = false;
                scon. show = false;
                sbug. show = false;
        }
        if (logfilename)
        {
                slog. logfile (logfilename);
                slog. keepforever ();
                sout. logfile (slog);
                serr. logfile (slog);
                if (debug)
                        sbug. logfile (slog);
        }
        if (seqfilename)
                sseq. logfile (seqfilename);
#ifdef TIMEUSED
        program_time = sout;
#endif
        return;
} /* setstreams */

#ifndef algstreamprepare



#define argstreamprepare(a) \
char *arg_logfilename = NULL; \
char *arg_seqfilename = NULL; \
char *arg_computername = NULL; \
bool arg_quiet = false; \
bool arg_debug = false; \
arg (a, "-comp", arg_computername); \
argstreams (a, arg_logfilename, arg_seqfilename, arg_quiet, arg_debug);
#endif

#ifndef argstreamset



#define argstreamset() \
setstreams (arg_logfilename, arg_seqfilename, arg_quiet, arg_debug); \
slog << commandline (argc, argv) << "\n\n"; \
if (arg_computername) slog << "Running on " << arg_computername << ". "; \
slog << "Start time: " << currenttime () << '\n';
#endif

#endif
/* */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_SYSTEM_ARG_H_