Args.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2020, Cascoda Ltd.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef POSIX_APP_CHILICTL_COMMON_ARGS_H_
#define POSIX_APP_CHILICTL_COMMON_ARGS_H_
 
#include <functional>
#include <limits>
#include <stdio.h>
#include <vector>
 
#include "ca821x_error.h"
 
namespace ca {
 
class ArgOpt
{
    friend class Args;
    using argCallback                          = std::function<ca_error(const char *)>;
    template <class T> using argCallbackMemRaw = ca_error (T::*)(const char *argument);
 
public:
    enum ArgPerm
    {
        NO_ARG = 0,    
        OPTIONAL_ARG,  
        MANDATORY_ARG, 
    };
 
    ArgOpt(char aShortArg, const char *aLongArg, ArgPerm aArgPerm = ArgPerm::NO_ARG);
 
    void SetHelpString(const char *aHelpString) { helpstr = aHelpString; }
 
    void SetArgHint(const char *aArgHint) { arghint = aArgHint; }
 
    void SetCallback(argCallback aCallback) { callback = aCallback; }
 
    template <class T> void SetCallback(argCallbackMemRaw<T> aCallback, T &aInstance)
    {
        callback = std::bind(aCallback, &aInstance, std::placeholders::_1);
    }
 
    int GetCallCount(void) { return count; }
 
private:
    char        shortarg;      
    const char *longarg;       
    const char *helpstr;       
    const char *arghint;       
    bool        optional_arg;  
    bool        mandatory_arg; 
    argCallback callback;      
 
    int count; 
 
    ca_error call_callback(const char *aArg)
    {
        count++;
        if (callback)
            return callback(aArg);
        return CA_ERROR_SUCCESS;
    }
};
 
class Args
{
public:
    Args()
        : mFinalOpt(std::numeric_limits<int>::max())
        , mOptions(){};
 
    ca_error ProcessOption(int &argi, int argc, const char *argv[]);
 
    void PrintOptionHelpStrings(FILE *aOutFile);
 
    void AddOption(ArgOpt &aOption) { mOptions.push_back(&aOption); }
 
private:
    int                   mFinalOpt; 
    std::vector<ArgOpt *> mOptions;  
 
    static bool is_shortopt(const char *aStr);
 
    static bool is_longopt(const char *aStr);
 
    static bool is_end_of_opts(const char *aStr);
 
    static bool is_opt(const char *aStr);
 
    ca_error process_short_opts(int &argi, int argc, const char *argv[]);
 
    ca_error process_long_opt(int &argi, int argc, const char *argv[]);
 
    void print_longopt_error(const char *optptr, size_t optlen);
 
    void print_opt_help_string(FILE *out, ArgOpt *opt);
};
 
} /* namespace ca */
 
#endif /* POSIX_APP_CHILICTL_COMMON_ARGS_H_ */