interface.h

/***** interface.h ********************************
 * Description: Accepts arguments, sets flags, autoformats usage, verison, and help
 * Not POSIX compliant...yet.
 * Author: Matthew Ackerman
 * Date: Mon Dec 09 12:00:00 2014.
 * Licence: GNU General Public
 ***************************************************/ 


#ifndef _INTERFACE_H_
#define _INTERFACE_H_

#include <vector>
#include <list>
#include <iostream>
#include "typedef.h"
#include "region.h"

#define ARG_ERROR   -1

/* /defgroup arg_parser Argument parsers
 * @{
*/

//
int arg_set_vector_str(int, char **, void *);   
inline int arg_set(int a, char **b, std::vector<std::string> &c){return arg_set_vector_str(a,b, &c); }

//
int arg_set_region(int, char **, void *);   
inline int arg_set(int a, char **b, Region &c){return arg_set_region(a,b, &c); }

//
int arg_set_vector_uli(int, char **, void *);   
inline int arg_set(int a, char **b, std::vector<unsigned long int> &c){return arg_set_vector_uli(a,b, &c); }

int arg_set_vector_ulli(int, char **, void *);  
inline int arg_set(int a, char **b, std::vector<unsigned long long int> &c){return arg_set_vector_ulli(a,b, &c); }

//
int arg_set_vector_ui(int, char **, void *);    
inline int arg_set(int a, char **b, std::vector<unsigned int> &c){return arg_set_vector_ui(a,b, &c); }

int arg_set_int(int, char **, void *);      
inline int arg_set(int a, char **b, int &c){return arg_set_int(a,b, &c); }

//
int arg_set_vector_usi(int, char **, void *);   
inline int arg_set(int a, char **b, std::vector<unsigned short int> &c){return arg_set_vector_usi(a,b, &c); }

//<! Takes a reference to ...
int arg_set_str(int, char **, void *);      
inline int arg_set(int a, char **b, std::string &c){return arg_set_str(a,b, &c); }

//<! Same.
int arg_set_char(int, char **, void *); 
inline int arg_set(int a, char **b, char &c){return arg_set_char(a,b, &c); }

//<! Same.
int arg_set_float(int, char **, void *);
inline int arg_set(int a, char **b, float &c){return arg_set_float(a,b, &c); }

//<! Same.
int arg_set_double(int, char **, void *);
inline int arg_set(int a, char **b, double &c){return arg_set_double(a,b, &c); }

//<! Same.
int arg_set_long_double(int, char **, void *);
inline int arg_set(int a, char **b, long double &c){return arg_set_long_double(a,b, &c); }

//<! Same.
//int arg_setc_str(int, char **, void *);   
//int arg_set(int, char **, char **);
/* @}
 */

int flag_set(void *);
int flag_usage(void *);             
int flag_version(void *);           
int flag_help(void *);              
int flag_commands(void *);              
int flag_options(void *);               

int arg_error(int, char **, void *);        
int flag_error(void *);             
int command_error(int, char **);        


class Flag {
    private:
    public:
    Flag(){
        opt='?';
        lopt="error";
        func=&flag_error;
        emsg="emsg unset";
        umsg="umsg unset";
    };

    Flag (char opt_, char* lopt_, void *parm_, int (*func_)(void *), char *emsg_, char *umsg_){
        opt=opt_;
        lopt=lopt_;
        func=func_;
        parm=parm_;
        emsg=emsg_;
        umsg=umsg_;
    };

    bool set;   
    char opt;   
    char *lopt; 
    void *parm;     
    int (*func)(void *);    
    char *emsg;     
    char *umsg;     
};

/*  
 *
 */
class Argument {
    private:
    public:

    Argument(){
        opt='?';
        lopt="error";
        func=&arg_error;
        emsg="emsg unset";
        umsg="umsg unset";
        set=false;
        required=false;
        operand_type="none";
    };


    Argument(const char opt_, 
        char *lopt_, 
        void *parm_, 
        int (*func_)(int, char **, void *), 
        char *emsg_, 
        char *umsg_){
        opt=opt_;
        lopt=lopt_;
        parm=parm_;
        func=func_;
        emsg=emsg_;
        umsg=umsg_;
        set=false;
        required=false;
        operand_type="none";
    }
    
    template <class Type>
    Argument(const char opt_, 
        char *lopt_, 
        Type &parm_, 
        char *emsg_, 
        char *umsg_){
        opt=opt_;
        lopt=lopt_;
        parm=(void *)(&parm_);
        func=(int (*)(int, char **, void*) )( (int (*)(int, char **, Type &) )&arg_set);
        emsg=emsg_;
        umsg=umsg_;
        set=false;
        required=false;
        operand_type="none";
    }

    bool set;   
    bool required; 
    char opt;   
    char *lopt; 
    void *parm; 
    int (*func)(int, char **, void *);  
    char *emsg; 
    char *umsg; 
    char *operand_type; 
};

/* These are the subcommands of mapgd. They should generally take one or more 
 * data classes, and produce one or more data classes.
 */
class Command {
    private:
    public:
    Command(){
        opt='?';
        lopt="error";
        emsg="emsg unset";
        func=&command_error;
        umsg="umsg unset";
        set=false;
    };
    Command(char opt_, char* lopt_, int (*func_)(int, char **), char *emsg_, char*umsg_){
        opt=opt_;
        lopt=lopt_;
        func=func_;
        emsg=emsg_;
        umsg=umsg_;
        set=false;
    };
    bool set;   
    char opt;   
    char *lopt; 
    int (*func)(int, char **);  
    char *emsg; 
    char *umsg; 
};

/* TODO Write a long description you jerk!
 *
 */
class Environment{
private:
public:
    void set_name(const char *c)
    {
        name=c;
    };

    void set_version(const char *c)
    {
        version=c;
    };

    void set_author(const char *c){
        author=c;
    };

    void set_description(const char *c){
        description=c;
    };

    const char *name;       
    const char *version;        
    const char *author;     
    const char *description;    
    const char *footer_;        

    std::list <Flag> flags;         
    std::list <Argument> args;              
    std::list <Command> commands;           

    std::list <Argument *> required_args;       
    std::list <Argument *> positional_args;     
    std::list <Command *> required_coms;        

    Environment(){
        name="Unnamed program";
        version="0.0";
        author="Unknown";
        description="Unknown purpose";
        footer_="Fin";
    }
    
    void optional_arg (char opt_, char* lopt_, void * parm_, int (*func_)(int, char **, void *), char *emsg_, char*umsg_)
    {
        args.push_back(Argument(opt_, lopt_, parm_, func_, emsg_, umsg_) );
    }

    template <class Type>
    inline void optional_arg (char opt_, char* lopt_, Type &parm_, char *emsg_, char*umsg_)
    {
        args.push_back(Argument(opt_, lopt_, parm_, emsg_, umsg_) );
    }

    template <class Type>
    void positional_arg (char opt_, char* lopt_, Type &parm_, char *emsg_, char*umsg_)
    {
        args.push_back(Argument(opt_, lopt_, parm_, emsg_, umsg_) );
        positional_args.push_back(&args.back() );
    }

    template <class Type>
    void positional_arg (Type &parm_, char *emsg_, char*umsg_)
    {
        args.push_back(Argument("", "", parm_, emsg_, umsg_) );
        positional_args.push_back(&args.back() );
    }


    void required_arg (char opt_, char* lopt_, void * parm_, int (*func_)(int, char **, void *), char *emsg_, char*umsg_)
    {
        args.push_back(Argument(opt_, lopt_, parm_, func_, emsg_, umsg_) );
        args.back().required=true;
        required_args.push_back(&args.back());
        
    }

    template <class Type>
    void required_arg (char opt_, char* lopt_, Type &parm_, char *emsg_, char*umsg_)
    {
        args.push_back(Argument(opt_, lopt_, parm_, emsg_, umsg_) );
        args.back().required=true;
        required_args.push_back(&args.back());
    }

    void command (char opt_, char* lopt_, int (*func_)(int, char **), char *emsg_, char*umsg_)
    {
        commands.push_back(Command(opt_, lopt_, func_, emsg_, umsg_) );
    }

    void flag (char opt_, char* lopt_, void * parm_, int (*func_)(void *), char *emsg_, char*umsg_)
    {
        flags.push_back(Flag(opt_, lopt_, parm_, func_, emsg_, umsg_) );
    }

    bool required_set (void)
    {
        std::list <Argument *>::iterator rarg=required_args.begin();
        std::list <Argument *>::iterator end=required_args.end();
        while(rarg!=end){
            if(!(*rarg)->set) {std::cerr << (*rarg)->emsg << std::endl; return false;}
            ++rarg;
        };
        return true;
    }
    void set_footer(const char *);
    void close(void);
};

void Usage(Environment);
int parsargs(int argc, char *argv[], Environment &env);

void print_help(Environment env);

void print_version(Environment env);

void print_commands(Environment env);

void print_usage(Environment env);
#endif