commandline.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_UTILS_COMMANDLINE
#define ELEMENTA_UTILS_COMMANDLINE
 
#include <vector>
#include "elementa/base/strings.h"
#include "elementa/base/enums.h"
#include "elementa/base/exceptions.h"
#include "elementa/base/serial_channels.h"
 
namespace elementa
{
 
namespace utils
{
 
/* **********************************************************************
 
    Class: CLOption
 
*************************************************************************/
 
 
class CLOption
{
 public:
 
 
    ELE_CLASS_ENUM(ValKind,
                    kFreeText,  
                    kNatural,   
                    kPositive,  
                    kInteger,   
                    kNumber,    
                    kEnum,      
                    kNone       
                    );
 
    ELE_CLASS_ENUM(PresenceKind, 
                    kMandatory, 
                    kOptional,  
                    kAlone      
                    );
 
 
    class StringGroups: public std::vector<elementa::base::Strings>
    {
     public:
 
        using Base = std::vector<elementa::base::Strings>;
 
        using Base::Base;
 
 
        void check(elementa::base::Strings::size_type minnumelems = 0) const;
 
        std::string to_string(const std::string & preffix = "",
                              const std::string & sep = " ") const;
    };
 
    struct CLData
    {
        class Vector: public std::vector<CLData>
        {
         public:
 
            using Base = std::vector<CLData>;
 
            using Base::Base;
 
            Base::const_iterator find(const std::string & shortname) const;
            std::string to_string(const std::string & preff,
                                  const std::string & sep = " ") const;
        };
 
        std::string shortname; 
        std::string value; 
    };
 
 
    class Vector: public std::vector<CLOption>
    {
     public:
 
        using Base = std::vector<CLOption>;
 
        using Base::Base;
 
        Base::const_iterator find(const std::string & n, 
                                  bool shortn = true) const;
 
 
        void checkSpec(void) const;
 
 
        bool therearedeps(void) const;
    };
 
 
    class Error: public elementa::base::Exc
    {
     public:
 
        Error(const std::string & explanation):
                            elementa::base::Exc{
                                std::string{"Command line error: "} + 
                                explanation}
            {}
            
        ELE_CLASS_EXCOVERRIDE(Error)            
    };
    
    class InvOptSpec: public Error
    {
     public:
 
        InvOptSpec(const std::string & details):
                        Error{elementa::base::concatWithMiddle(
                                "Invalid option specification",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvOptSpec)           
    };
 
    class InvOptValue: public Error
    {
     public:
 
        InvOptValue(const std::string & details):
                        Error{elementa::base::concatWithMiddle(
                                "Invalid value for option",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvOptValue)          
    };
 
    class InvStringGroup: public Error
    {
     public:
 
        InvStringGroup(const std::string & details):
                        Error{elementa::base::concatWithMiddle(
                                "Invalid group of strings",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvStringGroup)           
    };
 
 
    std::string shortname; 
    std::string longname; 
    PresenceKind presence; 
    ValKind valkind; 
    elementa::base::Strings values; 
    bool mandatoryval; 
    std::string dflt; 
    StringGroups dependencies; 
    std::string help; 
 
 
    void checkSpec(void) const;
 
    void checkValue(const std::string & v) const;
 
 
    elementa::base::Strings::size_type whichIsDflt(void) const;
 
    std::string helpValues(void) const;
    
    bool dependsOn(const CLOption & other) const;
 
    bool operator==(const CLOption & oo) const
        { return(shortname == oo.shortname); }
 
    bool operator!=(const CLOption & oo) const
        { return(!operator==(oo)); }
};
 
 
/* **********************************************************************
 
    Class: CLOptionManager
 
*************************************************************************/
 
class CLOptionManager
{
 public:
 
    class InvPreffix: public CLOption::Error
    {
     public:
 
        InvPreffix(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                        "Invalid preffix in a CL argument",
                                        details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(InvPreffix)           
    };
 
    class UnknownOption: public CLOption::Error
    {
     public:
 
        UnknownOption(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                            "Unknown option",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(UnknownOption)            
    };
 
    class MandatoryOption: public CLOption::Error
    {
     public:
 
        MandatoryOption(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                            "Mandatory option not found",
                                            details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(MandatoryOption)          
    };
 
    class MandatoryValue: public CLOption::Error
    {
     public:
 
        MandatoryValue(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                        "Mandatory value not found",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(MandatoryValue)           
    };
 
    class MustBeAlone: public CLOption::Error
    {
     public:
 
        MustBeAlone(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                            "Option must be alone",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(MustBeAlone)          
    };
 
    class UnmetDeps: public CLOption::Error
    {
     public:
 
        UnmetDeps(const std::string & details):
                        CLOption::Error{elementa::base::concatWithMiddle(
                                            "Option dependencies are not met", 
                                            details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(UnmetDeps)            
    };
 
    class IncompOpts: public CLOption::Error
    {
     public:
 
        IncompOpts(const std::string & details):
                    CLOption::Error{elementa::base::concatWithMiddle(
                                        "Incompatible options",details)}
            {}
            
        ELE_CLASS_EXCOVERRIDE(IncompOpts)           
    };
 
 
 
    CLOptionManager(const std::string & progname, 
                    const CLOption::Vector & opts,
                    const CLOption::StringGroups & incomps,
                    const std::string preff = "-");
 
    virtual ~CLOptionManager(void) = default;
 
 
    const std::string & progName(void) const noexcept
        { return(nameofprog_); }
 
    const std::string & preffix(void) const noexcept
        { return(preff_); }
 
 
    std::string help(const std::string & shortname = "", 
                     unsigned charwidth = 80);
 
 
    void process(int argc, char *argv[]);
 
 
    bool present(const std::string & shortn, std::string & val) const;
    
 
    bool present(const std::string & shortn) const;
 
 
    const CLOption & optDef(const std::string & shortn) const;
 
 
    elementa::base::Strings depOpts(const std::string & shortn) const;
 
 
    std::string processed_tostring(void) const
        { return(argvdata_.to_string(preff_,", ")); }
 
    
 private:
 
    const std::string nameofprog_;
    const CLOption::Vector & opts_;
    const CLOption::StringGroups & optincs_;
    const std::string preff_;
    CLOption::CLData::Vector argvdata_;
 
    std::string helpOpt(const CLOption & opt, bool withdepinfo, size_t depth,
                        unsigned charwidth);
    void recursivehelp(std::vector<CLOption::Vector::size_type> parents,
                       std::string & h, unsigned charwidth, size_t depth = 0);
    std::string formHelp(bool hierarchized, unsigned charwidth);
    std::string preffixedOpt(const CLOption & opt, bool shortn = true);
    std::string getoptfromtxt(const std::string & o) const;
};
 
  // CommandLine
 
} // End os namespace
 
} // End elementa namespace 
 
 
#endif