---

CTBargv.hxx

Go to the documentation of this file.

#ifndef _CTBargv_HXX
#define _CTBargv_HXX 1

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <strstream.h>

class CTBargv {

  public:

                    CTBargv();
                    CTBargv(int argc, char* argv[]);

                    ~CTBargv();

    int             Argc() const;
    const char*     Argv(int i_ind) const;

    bool            Locate(const char* c_opt, int i_npar = 0);

    const char*     NextArg();

    void            CheckUnused();
    bool            CheckErrors();
    bool            CheckErrors(ostream& os);

    void            SetupStream(istrstream& istr);
    void            CheckStream(istrstream& istr);

    void            ToStream(ostream& os = cout) const;
  
    const char*     operator[](int i_ind) const;

  private:

    struct argdsc {                         // argument descriptor
                    argdsc();               // constructor
      char*         mc_arg;                 // pointer to argument
      int           mi_nchar;               // number of chars for argument
      int           mi_ncharleft;           // number of left over chars
      bool          mb_used;                // used flag
      int           mi_errorflags;          // error flags
    };

    static const int mi_error_conv   = 0x0001; // conversion error flag
    static const int mi_error_npar   = 0x0002; // insufficient parameters avail.
    static const int mi_error_unused = 0x0004; // unused arguent
  
    int             mi_argc;                // argument count
    char*           mc_args;                // compound argument string
    argdsc*         m_argv;                 // array of argument descriptors
    int             mi_curarg;              // current argument index
};

    ostream&        operator<<(ostream& os, const CTBargv& av);

    template <class T>
    CTBargv&        operator>>(             // extraction operator for type T
                      CTBargv& av,          // argv >> obj
                      T& obj);

//------------------------------------------+-----------------------------------
// Definition of member functions and operators which are always inlined

template <class T>
inline CTBargv& operator>>(                 // extraction operator for type T
    CTBargv& av,
    T& obj)
{
  const char* c_arg = av.NextArg();         // get pointer to next argument
  
  if (c_arg) {                              // if defined
    istrstream istr(c_arg);                 // create string stream
    av.SetupStream(istr);                   // setup stream attributes
    istr >> obj;                            // use stream extraction operator
    av.CheckStream(istr);                   // and check complete conversion
  }
  return av;                                // to allow: argv >> i >> j >> k;
}

//CTB_TemplateFullSpecialization    // ??? vms didn't like the template
//
//Note: the `specialization' of oper>> must be defined inline for G++
//      or it will be utterly confused between template and explicit definition.
//
inline CTBargv& operator>>(                 // extraction operator for
    CTBargv& av,
    const char*& obj)                       //   C strings
{
  const char* c_arg = av.NextArg();         // get pointer to next argument
  
  if (c_arg) {                              // if defined
    obj = c_arg;
  }
  return av;                                // to allow: argv >> i >> j >> k;
}

//------------------------------------------+-----------------------------------

#if !(defined(CTB__OutLine) || defined(CTBargv__OutLine))
#include "CTBargv.icc"
#endif

#endif

---