CommandOption.hpp

Go to the documentation of this file.

#pragma ident "$Id: CommandOption.hpp 2333 2010-02-25 01:35:45Z yanweignss $"



#ifndef COMMANDOPTION_HPP
#define COMMANDOPTION_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software developed by Applied Research Laboratories at the University of
//Texas at Austin, under contract to an agency or agencies within the U.S. 
//Department of Defense. The U.S. Government retains all rights to use,
//duplicate, distribute, disclose, or release this software. 
//
//Pursuant to DoD Directive 523024 
//
// DISTRIBUTION STATEMENT A: This software has been approved for public 
//                           release, distribution is unlimited.
//
//=============================================================================






#ifdef __SUNPRO_CC
#include "getopt.h"
#elif defined (_AIX)
#include "getopt.h"
#else
#include "getopt.h"
#endif

#include <string>
#include <vector>

namespace gpstk
{

      // forward declaration
   class CommandOption;
   typedef std::vector<CommandOption*> CommandOptionVec;

   extern CommandOptionVec defaultCommandOptionList;

   class CommandOption
   {
   public:
      friend class CommandOptionParser;

      enum CommandOptionFlag
      {
         noArgument = 0,         
         hasArgument = 1         
      };

      enum CommandOptionType
      {
         trailingType, 
         stdType,      
         metaType      
      };

      CommandOption(const CommandOptionFlag of, 
                    const CommandOptionType ot,
                    const char shOpt, 
                    const std::string& loOpt, 
                    const std::string& desc,
                    const bool req = false,
                    CommandOptionVec& optVectorList =  
                       defaultCommandOptionList)
            : optFlag(of),  optType(ot),
              shortOpt(shOpt), longOpt(loOpt), description(desc),
              required(req), count(0), maxCount(0), order(0)
         {optVectorList.push_back(this);}

      CommandOption& setMaxCount(const unsigned long l)
         {maxCount = l; return *this;}

      virtual std::string getOptionString() const;

      std::string getFullOptionString() const;

      virtual std::string getArgString() const
      { return "ARG"; }

      struct option toGetoptLongOption() const;
      std::string toGetoptShortOption() const;

      virtual unsigned long getCount() const { return count; }

      std::vector<std::string> getValue() const { return value; }

         //  If it can be repeated, this order represents the order of
      unsigned int getOrder() const { return order; }

      std::ostream& dumpValue(std::ostream& out) const;

      std::string getDescription() const;

      virtual std::string checkArguments();

      virtual ~CommandOption() {}

   protected:
      CommandOptionFlag optFlag;
      CommandOptionType optType;
      char shortOpt;
      std::string longOpt;
      std::string description;
      std::vector<std::string> value;
      bool required;
      unsigned long count;
      unsigned long maxCount;
      unsigned long order;

      CommandOption() {}
   };

   class RequiredOption : public CommandOption
   {
   public:
      RequiredOption(const CommandOptionFlag of,
                     const CommandOptionType ot,
                     const char shOpt, 
                     const std::string& loOpt, 
                     const std::string& desc)
            : CommandOption(of, ot, shOpt, loOpt, desc, true)
         {}

      virtual ~RequiredOption() {}

   protected:
      RequiredOption() {}
   };

   class CommandOptionNoArg : public CommandOption
   {
   public:
      CommandOptionNoArg(const char shOpt, 
                         const std::string& loOpt, 
                         const std::string& desc,
                         const bool required = false)
            : CommandOption(noArgument, stdType, shOpt, loOpt, desc, required)
         {}
         
      virtual ~CommandOptionNoArg() {}
      operator bool() const throw() { return (getCount() != 0); }

   protected:
      CommandOptionNoArg() {}
   };

   class CommandOptionWithArg : public CommandOption
   {
   public:
      CommandOptionWithArg(const CommandOptionType ot,
                           const char shOpt, 
                           const std::string& loOpt, 
                           const std::string& desc,
                           const bool required = false)
            : CommandOption(hasArgument, ot, shOpt, loOpt, desc, required)
         {}

      virtual ~CommandOptionWithArg() {}

   protected:
      CommandOptionWithArg() {}
   };

   class CommandOptionWithAnyArg : public CommandOptionWithArg
   {
   public:
      CommandOptionWithAnyArg(const char shOpt, 
                              const std::string& loOpt, 
                              const std::string& desc,
                              const bool required = false)
            : CommandOptionWithArg(stdType, shOpt, loOpt, desc, required)
         {}

      virtual ~CommandOptionWithAnyArg() {}

   protected:
      CommandOptionWithAnyArg() {}
   };

   class CommandOptionWithStringArg : public CommandOptionWithArg
   {
   public:
      CommandOptionWithStringArg(const char shOpt, 
                                 const std::string& loOpt, 
                                 const std::string& desc,
                                 const bool required = false)
            : CommandOptionWithArg(stdType, shOpt, loOpt, desc, required)
         {}

      virtual ~CommandOptionWithStringArg() {}

      virtual std::string checkArguments();

      virtual std::string getArgString() const
      { return "<alpha>"; }

   protected:
      CommandOptionWithStringArg() {}
   };

   class CommandOptionWithNumberArg : public CommandOptionWithArg
   {
   public:
      CommandOptionWithNumberArg(const char shOpt, 
                                 const std::string& loOpt, 
                                 const std::string& desc,
                                 const bool required = false)
            : CommandOptionWithArg(stdType, shOpt, loOpt, desc, required)
         {}

      virtual ~CommandOptionWithNumberArg() {}

      virtual std::string checkArguments();

      virtual std::string getArgString() const
      { return "NUM"; }

   protected:
      CommandOptionWithNumberArg() {}
   };

   class CommandOptionRest : public CommandOptionWithArg
   {
   public:
      CommandOptionRest(const std::string& desc,
                        const bool required = false)
            : CommandOptionWithArg(trailingType, 0, "", desc, required)
      {}
      
      virtual ~CommandOptionRest() {}
      
      virtual std::string checkArguments();

   protected:
      CommandOptionRest() {}
   };

   class CommandOptionOneOf : public CommandOption
   {
   public:
      CommandOptionOneOf()
            : CommandOption(noArgument, metaType, 0, "", "")
      {}
      
      virtual ~CommandOptionOneOf() {}

      virtual std::string checkArguments();

      void addOption(CommandOption* opt)
      { optionVec.push_back(opt); }

      CommandOption* whichOne() const;
      
   protected:
      CommandOptionVec optionVec;
   };

   class CommandOptionAllOf : public CommandOptionOneOf
   {
   public:
      CommandOptionAllOf()
      {}
      
      virtual ~CommandOptionAllOf() {}

      virtual std::string checkArguments();

      virtual unsigned long getCount() const;

   private:
         // hide this as it doesn't make sense for this class
      CommandOption* whichOne() const;
   };

   class CommandOptionMutex : public CommandOptionOneOf
   {
   public:
      CommandOptionMutex(const bool required = false)
            : doOneOfChecking(required)
      {}
      
      virtual ~CommandOptionMutex() {}

      virtual std::string checkArguments();

   protected:
      bool doOneOfChecking;
   };

   class CommandOptionDependent : public CommandOption
   {
   public:
      CommandOptionDependent(const CommandOption* parent,
                             const CommandOption* child)
            : CommandOption(noArgument, metaType, 0, "", ""),
              requiree(parent), requirer(child)
      {}

      virtual ~CommandOptionDependent() {}

      virtual std::string checkArguments();

   protected:
      CommandOptionDependent() {}

      const CommandOption *requiree, *requirer;
   };

   class CommandOptionGroupOr : public CommandOptionOneOf
   {
   public:
      CommandOptionGroupOr()
      {}
      
      virtual ~CommandOptionGroupOr() {}

      virtual std::string checkArguments() { return std::string(); }

      virtual unsigned long getCount() const;

      virtual std::string getOptionString() const;
   };

   class CommandOptionGroupAnd : public CommandOptionGroupOr
   {
   public:
      CommandOptionGroupAnd()
      {}
      
      virtual ~CommandOptionGroupAnd() {}

      virtual unsigned long getCount() const;
   };

   
} // namespace gpstk
#endif

---