CommandOption.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was 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.
//
//==============================================================================
 
#ifndef COMMANDOPTION_HPP
#define COMMANDOPTION_HPP
 
#include "gnsstk_export.h"
#include "getopt.h"
 
#include <string>
#include <vector>
 
namespace gnsstk
{
 
 
      // forward declaration
   class CommandOptionParser;
   class CommandOption;
   typedef std::vector<CommandOption*> CommandOptionVec;
 
   GNSSTK_EXPORT 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);
 
      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; }
 
      const std::vector<std::string>& getValue() const { return value; }
 
      unsigned long getOrder(unsigned long idx = -1) const;
 
      std::ostream& dumpValue(std::ostream& out) const;
 
      std::string getDescription() const;
 
      void setDescription(const std::string& desc)
      { description = desc; }
 
      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;
      std::vector<unsigned long> order;
      CommandOptionParser *parser;
 
      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 noexcept { 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 CommandOptionWithDecimalArg : public CommandOptionWithArg
   {
   public:
      CommandOptionWithDecimalArg(const char shOpt,
                                  const std::string& loOpt,
                                  const std::string& desc,
                                  const bool required = false)
            : CommandOptionWithArg(stdType, shOpt, loOpt, desc, required)
      {}
 
      virtual ~CommandOptionWithDecimalArg() {}
 
      virtual std::string checkArguments();
 
      virtual std::string getArgString() const
      { return "DEC"; }
 
   protected:
      CommandOptionWithDecimalArg() {}
   };
 
   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 CommandOptionNOf : public CommandOption
   {
   public:
      CommandOptionNOf(const unsigned long num)
            : CommandOption(noArgument, metaType, 0, "", ""),
              N(num)
      {
         setMaxCount(num);
      }
 
      virtual ~CommandOptionNOf() {}
 
      virtual std::string checkArguments();
 
      void addOption(CommandOption* opt);
 
      std::vector<CommandOption*> which() const;
 
   protected:
      CommandOptionVec optionVec;
      unsigned long N;
   };
 
   class CommandOptionOneOf : public CommandOption
   {
   public:
      CommandOptionOneOf()
            : CommandOption(noArgument, metaType, 0, "", "")
      {}
 
      virtual ~CommandOptionOneOf() {}
 
      virtual std::string checkArguments();
 
      void addOption(CommandOption* 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);
 
      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;
   };
 
   class CommandOptionHelp : public CommandOption
   {
   public:
      CommandOptionHelp(const CommandOption::CommandOptionFlag of,
                        const char shOpt,
                        const std::string& loOpt,
                        const std::string& desc)
            : CommandOption(of, stdType, shOpt, loOpt, desc, false)
      {}
 
      virtual ~CommandOptionHelp() {}
      virtual void printHelp(std::ostream& out, bool pretty = true) = 0;
   };
 
   class CommandOptionHelpUsage : public CommandOptionHelp
   {
   public:
      CommandOptionHelpUsage(const char shOpt = 'h',
                             const std::string& loOpt = "help",
                             const std::string& desc = "Print help usage")
            : CommandOptionHelp(noArgument, shOpt, loOpt, desc)
      {}
 
      virtual ~CommandOptionHelpUsage() {}
      virtual void printHelp(std::ostream& out, bool pretty = true);
   };
 
   class CommandOptionHelpSimple : public CommandOptionHelp
   {
   public:
      CommandOptionHelpSimple(const char shOpt,
                              const std::string& loOpt,
                              const std::string& desc,
                              const std::string& help)
            : CommandOptionHelp(noArgument, shOpt, loOpt, desc),
              helpText(help)
      {}
 
      virtual ~CommandOptionHelpSimple() {}
      virtual void printHelp(std::ostream& out, bool pretty = true)
      {
         out << helpText;
      }
   protected:
      std::string helpText;
   };
 
 
} // namespace gnsstk
#endif