arg.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" 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_