options.h

Go to the documentation of this file.

#ifndef options_h_included
#define options_h_included


//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.





#include <string>
#include <vector>
#include <map>

namespace cxxtls
{

class ProgramOptions
        
{

public:

 // types

    class                                  Descriptor;
    class                                  Descriptors;
    class                                  Option;
    class                                  EnvVar;

    typedef std::string                    string;

    typedef std::vector<string>            option_values;  
    typedef option_values::const_iterator  value_iterator; 
    typedef std::map<string,string>        Environment;    

    typedef std::map<string,   Option*>    Options;
        //


    static ProgramOptions*                 global_options_; 

    enum allowed_parms_
    {
      no_values,   
      one_value,   
      many_values  

    };

 // Public Variables

    option_values   argv;           


 // Methods

    ProgramOptions(Descriptors const &  desc,
                   int                  argc,
                   char const * const * argvp,
                   char const * const * environ,
                   bool                 exit_on_error=true
                  )
    : exit_on_error_(exit_on_error),
      error_(false)
    {
      constructor(desc, argc, argvp, environ, exit_on_error);
       //
       //
    }


    ProgramOptions(std::string          option_descriptor_string,
                   int                  argc,
                   char const * const * argvp,
                   char const * const * environ,
                   bool                 exit_on_error=true
                  );
       //

    ProgramOptions()
    : exit_on_error_(true),
      error_(false)
    {
       //
       //
    }

    ~ProgramOptions();       
                                
    Option &add_option(string  const &name);
       //
    void remove_option(string const &name);

                                
    Option const &option(string const &name) const;
       //

    bool error() const { return error_; }
        
    string const& error_text() const { return errmsg_; }
        
    EnvVar  getenv(string const &name) const;
        
    void setenv(string const &name, string const & value);

    Environment const& get_environment() const { return environ_; }
        
    Options const& get_options() const { return options_; }
        
    std::string expand(std::string const &) const;
        
    class Option
       //
    {

    public:

        Option(string const &name);             
        
        void append_value(string const &value); 
        
        value_iterator begin() const { return values_.begin(); }
        
        value_iterator end()   const { return values_.end(); }
        
        operator bool() const { return set_; }

        string value() const;
        
        operator string() const { return value(); } 
        
        string const& name() const { return name_; }  
        
    private:

        friend class ProgramOptions;
        
        Option(); 


        option_values values_;  
        
        string        name_;    

                        
        bool          set_;     
        
    };


    class Descriptor
        //
        //
    {
      public:

        string  name_;   
        int     parms_;  


        Descriptor(string const &name, int parms=no_values)
            //
        : name_(name),
          parms_(parms)
        {
        }

    };


    class EnvVar
        //
    {
      public:

        bool          set_;    
        string        name_;   
        string        value_;  
        
        EnvVar(string const &name)
        : set_(false),
          name_(name)
        {
        }
        
        EnvVar(string const& name, string const &value)
        :  set_(true),
           name_(name),
           value_(value)
        {
        };
        
        operator bool() const { return set_; }
        
        operator string const &() const { return value_; }
        
        string const &name() const { return name_; }

        char const* c_str() const { return value_.c_str(); }
    };


    class Descriptors

    {
    public:

        std::vector<Descriptor> options_; 
        
        void add_option(string const & name, int parms = no_values);

    };

private:

    static Option  null_option_;  

    Options        options_;      




    bool   exit_on_error_;        
    string errmsg_;               
    bool   error_;                

    Environment environ_;         

    Option* get_option(string const&); 

    void constructor(Descriptors const &  desc,
                     int                  argc,
                     char const * const * argv,
                     char const * const * environ,
                     bool                 exit_on_error=true
                    );


};

} // namespace cxxtls

#endif