---

option.hh

/*
*  Name:      option.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Option for PREFS
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program 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 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 more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_UTIL_PREFS_OPTION__
#define _MPCL_UTIL_PREFS_OPTION__

#include <iostream>
#include <vector>
#include "../../io/output_streamable.hh"
#include "../../text/string.hh"
#include "defs.hh"


namespace mpcl
{

  namespace util
  {

    namespace prefs
    {

      using io::IOutputStreamable;
      using text::TString;

      class TOption : public IOutputStreamable<>
      {

        private:

          static const TString   _kyDefaultHelpString;

          TString   yName;

          TString   yShortcut;

          TString   yDefaultValue;

          TString   yHelp;

          std::vector<TString>   tValueVector;

          bool   gIsAtCmdLine;

          bool   gIsParameterAble;


        public:

          typedef
            std::vector<TString>::size_type
            size_type;


        protected:

          //
          //  S E L E C T O R S
          //
          void write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const;


        public:

          //
          //  C O N S T R U C T O R S
          //

          TOption (void)                               :
            IOutputStreamable<> ()                     ,
            yName               ()                     ,
            yShortcut           ()                     ,
            yDefaultValue       ()                     ,
            yHelp               (_kyDefaultHelpString) ,
            tValueVector        ()                     ,
            gIsAtCmdLine        (false)                ,
            gIsParameterAble    (true)                 {}

          TOption (const TOption& rktSOURCE_OPTION)                 :
            IOutputStreamable<> ()                                  ,
            yName               (rktSOURCE_OPTION.yName)            ,
            yShortcut           (rktSOURCE_OPTION.yShortcut)        ,
            yDefaultValue       (rktSOURCE_OPTION.yDefaultValue)    ,
            yHelp               (rktSOURCE_OPTION.yHelp)            ,
            tValueVector        (rktSOURCE_OPTION.tValueVector)     ,
            gIsAtCmdLine        (rktSOURCE_OPTION.gIsAtCmdLine)     ,
            gIsParameterAble    (rktSOURCE_OPTION.gIsParameterAble) {}

          TOption (const TString& rkyNAME, const TString& rkySHORTCUT) :
            IOutputStreamable<> ()                                     ,
            yName               (rkyNAME)                              ,
            yShortcut           (rkySHORTCUT)                          ,
            yDefaultValue       ()                                     ,
            yHelp               (_kyDefaultHelpString)                 ,
            tValueVector        ()                                     ,
            gIsAtCmdLine        (false)                                ,
            gIsParameterAble    (false)                                {}

          TOption ( const TString& rkyNAME          ,
                    const TString& rkySHORTCUT      ,
                    const TString& rkyDEFAULT_VALUE )  :
            IOutputStreamable<> ()                     ,
            yName               (rkyNAME)              ,
            yShortcut           (rkySHORTCUT)          ,
            yDefaultValue       (rkyDEFAULT_VALUE)     ,
            yHelp               (_kyDefaultHelpString) ,
            tValueVector        ()                     ,
            gIsAtCmdLine        (false)                ,
            gIsParameterAble    (true)                 {}

          virtual ~TOption (void) {}

          void addValue (const TString& rkyVALUE)
          {
            if ( !gIsParameterAble )
            {
              throw TNotParameterAbleException (yName.c_str(), __FILE__, __LINE__);
            }
            else
            {
              tValueVector.push_back (rkyVALUE);
            }
          }

          TOption& operator = (const TOption& rktSOURCE_OPTION)
          {
            yName            = rktSOURCE_OPTION.yName;
            yShortcut        = rktSOURCE_OPTION.yShortcut;
            yDefaultValue    = rktSOURCE_OPTION.yDefaultValue;
            yHelp            = rktSOURCE_OPTION.yHelp;
            tValueVector     = rktSOURCE_OPTION.tValueVector;
            gIsAtCmdLine     = rktSOURCE_OPTION.gIsAtCmdLine;
            gIsParameterAble = rktSOURCE_OPTION.gIsParameterAble;
            return *this;
          }

          void setCmdLinePresence (void)
          {
            gIsAtCmdLine = true;
          }

          void setUsageString (const TString& rkyVALUE)
          {
            yHelp = rkyVALUE;
          }

          void setValue (const TString& rkyVALUE)
          {
            tValueVector.clear();
            addValue (rkyVALUE);
          }


        public:

          //
          //  S E L E C T O R S
          //

          const TString& getValue (void) const
            throw (TNotParameterAbleException)
          {
            if ( !gIsParameterAble )
            {
              throw TNotParameterAbleException (yName.c_str(), __FILE__, __LINE__);
            }
            return ( tValueVector.empty() ) ? yDefaultValue : tValueVector.back();
          }

          const std::vector<TString>& getValues (void) const
            throw (TNotParameterAbleException)
          {
            if ( !gIsParameterAble )
            {
              throw TNotParameterAbleException (yName.c_str(), __FILE__, __LINE__);
            }
            return tValueVector;
          }

          bool hasValue (const TString& rkySOURCE_VALUE) const;

          TString help (void) const
          {
            return yHelp;
          }

          bool isAtCmdLine (void) const
          {
            return gIsAtCmdLine;
          }

          bool isEmpty (void) const
          {
            return ( yName.empty() );
          }

          bool isParameterAble (void) const
          {
            return gIsParameterAble;
          }

          TString name (void) const
          {
            return yName;
          }

          const TString& operator [] (size_type zINDEX) const
          {
            return tValueVector [zINDEX];
          }

          TString& operator [] (size_type zINDEX)
          {
            return tValueVector [zINDEX];
          }

          bool operator == (const TOption& rktSOURCE_OPTION) const
          {
            return ( yName == rktSOURCE_OPTION.yName );
          }

          TString shortcut (void) const
          {
            return yShortcut;
          }

          size_type valueCount (void) const
          {
            return tValueVector.size();
          }

      };  // class TOption

    }  // namespace prefs

  }  // namespace util

}  // namespace mpcl


#endif  // not _MPCL_UTIL_PREFS_OPTION__

---