Subversion Repositories w11

// $Id: RtclArgs.hpp 521 2013-05-20 22:16:45Z mueller $

//

// Copyright 2011-2013 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>

//

// This program is free software; you may redistribute and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation, either version 2, or at your option any later version.

//

// This program 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 complete details.

// 

// Revision History: 

// Date         Rev Version  Comment

// 2013-05-19   521   1.0.9  add NextSubOpt() method, pass optset's as const

// 2013-03-05   495   1.0.8  add SetResult(bool)

// 2013-03-02   494   1.0.7  add Quit() method

// 2013-02-12   487   1.0.6  add CurrentArg() method

// 2013-02-01   479   1.0.5  add Objv() method

// 2011-03-26   373   1.0.4  add GetArg(flt/dbl), SetResult(str,sos,int,dbl)

// 2011-03-13   369   1.0.3  add GetArg(vector<unit8_t>)

// 2011-03-06   367   1.0.2  add min to GetArg(unsigned); add Config() methods;

// 2011-03-05   366   1.0.1  fObjc,fNDone now size_t; add NDone(), NOptMiss();

//                           add SetResult(), GetArg(Tcl_Obj), PeekArgString();

// 2011-02-26   364   1.0    Initial version

// 2011-02-06   359   0.1    First draft

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

/*!

  \file

  \version $Id: RtclArgs.hpp 521 2013-05-20 22:16:45Z mueller $

  \brief   Declaration of class RtclArgs.

*/

#ifndef included_Retro_RtclArgs

#define included_Retro_RtclArgs 1

#include "tcl.h"

#include <cstddef>

#include <vector>

#include <limits>

#include <sstream>

#include "RtclNameSet.hpp"

namespace Retro {

  class RtclArgs {

    public:

    const static int8_t   int8_min   = 0xff;

    const static int8_t   int8_max   = 0x7f;

    const static uint8_t  uint8_max  = 0xff;

    const static int16_t  int16_min  = 0xffff;

    const static int16_t  int16_max  = 0x7fff;

    const static uint16_t uint16_max = 0xffff;

    const static int32_t  int32_min  = 0xffffffff;

    const static int32_t  int32_max  = 0x7fffffff;

    const static uint32_t uint32_max = 0xffffffff;

                        RtclArgs();

                        RtclArgs(Tcl_Interp* interp, int objc,

                                 Tcl_Obj* const objv[], size_t nskip=1);

                        RtclArgs(const RtclArgs& rhs);

                        ~RtclArgs();

      Tcl_Interp*       Interp() const;

      int               Objc() const;

      Tcl_Obj* const *  Objv() const;

      Tcl_Obj*          Objv(size_t ind) const;

      bool              GetArg(const char* name, Tcl_Obj*& pval);

      bool              GetArg(const char* name, const char*& val);

      bool              GetArg(const char* name, std::string& val);

      bool              GetArg(const char* name, int8_t& val,

                               int8_t min=int8_min, int8_t max=int8_max);

      bool              GetArg(const char* name, uint8_t& val,

                               uint8_t max=uint8_max, uint8_t min=0);

      bool              GetArg(const char* name, int16_t& val,

                               int16_t min=int16_min, int16_t max=int16_max);

      bool              GetArg(const char* name, uint16_t& val,

                               uint16_t max=uint16_max, uint16_t min=0);

      bool              GetArg(const char* name, int32_t& val,

                               int32_t min=int32_min, int32_t max=int32_max);

      bool              GetArg(const char* name, uint32_t& val,

                               uint32_t max=uint32_max, uint32_t min=0);

      bool              GetArg(const char* name, float& val,

                               float min=-1.e30, float max=+1.e30);

      bool              GetArg(const char* name, double& val,

                               double min=-1.e30, double max=+1.e30);

      bool              GetArg(const char* name, std::vector<uint8_t>& val,

                               size_t lmin=0, size_t lmax=uint32_max);

      bool              GetArg(const char* name, std::vector<uint16_t>& val,

                               size_t lmin=0, size_t lmax=uint32_max);

      bool              Config(const char* name, std::string& val);

      bool              Config(const char* name, uint32_t& val,

                               uint32_t max=uint32_max, uint32_t min=0);

      bool              NextOpt(std::string& val);

      bool              NextOpt(std::string& val, const RtclNameSet& optset);

      int               NextSubOpt(std::string& val, const RtclNameSet& optset);

      bool              OptValid() const;

      Tcl_Obj*          CurrentArg() const;

      bool              AllDone();

      size_t            NDone() const;

      size_t            NOptMiss() const;

      const char*       PeekArgString(int rind) const;

      void              SetResult(const std::string& str);

      void              SetResult(std::ostringstream& sos);

      void              SetResult(bool val);

      void              SetResult(int val);

      void              SetResult(double val);

      void              SetResult(Tcl_Obj* pobj);

      void              AppendResult(const char* str, ...);

      void              AppendResult(const std::string& str);

      void              AppendResult(std::ostringstream& sos);

      void              AppendResultLines(const std::string& str);

      void              AppendResultLines(std::ostringstream& sos);

      int               Quit(const std::string& str);

      Tcl_Obj*          operator[](size_t ind) const;

    protected:

      bool              NextArg(const char* name, Tcl_Obj*& pobj);

      bool              NextArgList(const char* name, int& objc,

                                    Tcl_Obj**& objv, size_t lmin=0,

                                    size_t lmax=uint32_max);

      void              ConfigNameCheck(const char* name);

      bool              ConfigReadCheck();

    protected:

      Tcl_Interp*       fpInterp;           //!< pointer to tcl interpreter

      size_t            fObjc;              //!< original args count

      Tcl_Obj* const *  fObjv;              //!< original args vector

      size_t            fNDone;             //!< number of processed args

      size_t            fNOptMiss;          //!< number of missed optional args

      size_t            fNConfigRead;       //!< number of read mode config's

      bool              fOptErr;            //!< option processing error flag

      bool              fArgErr;            //!< argument processing error flag

  };

} // end namespace Retro

#include "RtclArgs.ipp"

#endif