clOptions.cpp

Go to the documentation of this file.

/** \file clOptions.cpp
 * \author Jared R. Males
 * \brief Implementatino of a command line parser
 *
 * \ingroup mxApp_files
 */
 
//***********************************************************************//
// Copyright 2021 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "app/clOptions.hpp"
 
namespace mx
{
namespace app
{
 
static const char *falseStr = "false";
static const char *trueStr = "true";
static const char *blankStr = "";
 
static option::ArgStatus Arg_Required( const option::Option &option, bool msg )
{
    static_cast<void>( msg );
 
    if( option.arg != 0 )
        return option::ARG_OK;
 
    return option::ARG_ILLEGAL;
}
 
clOptions::~clOptions()
{
    if( options )
        delete[] options;
    if( buffer )
        delete[] buffer;
}
 
void clOptions::clear()
{
    if( options )
        delete[] options;
    options = 0;
 
    if( buffer )
        delete[] buffer;
    buffer = 0;
 
    map.clear();
    typeMap.clear();
    descriptions.clear();
}
 
void clOptions::add( const std::string &optName, const char *const shortOpt, const char *const longOpt, int argT )
{
    mapIterator it;
    it = map.find( optName );
 
    if( it == map.end() )
    {
        if( argT == argType::Optional )
        {
            descriptions.push_back( { nOpts, argT, shortOpt, longOpt, option::Arg::Optional, "" } );
        }
        else if( argT == argType::Required )
        {
            descriptions.push_back( { nOpts, argT, shortOpt, longOpt, Arg_Required, "" } );
        }
        else
        {
            descriptions.push_back( { nOpts, argT, shortOpt, longOpt, option::Arg::None, "" } );
        }
 
        map.insert( { optName, nOpts } );
        typeMap.insert( { optName, argT } );
 
        ++nOpts;
        return;
    }
}
 
void clOptions::parse( int argc, char **argv, std::vector<std::string> *nonOptions )
{
    argc -= ( argc > 0 );
    argv += ( argc > 0 ); // skip program name argv[0] if present
 
    // If not already done, we push the unknown catcher and the termination descriptor.
    if( descriptions.back().index != 0 )
    {
        descriptions.push_back(
            { nOpts, 0, "", "", option::Arg::None, "" } ); // This is inserted to catch unknown options
        descriptions.push_back( { 0, 0, 0, 0, 0, 0 } );
    }
 
    // Now allocate.
    option::Stats stats( descriptions.data(), argc, argv );
    options = new option::Option[stats.options_max];
    buffer = new option::Option[stats.buffer_max];
 
    option::Parser parse( false, descriptions.data(), argc, argv, options, buffer );
 
    if( nonOptions )
    {
        nonOptions->resize( parse.nonOptionsCount() );
 
        for( int i = 0; i < parse.nonOptionsCount(); ++i )
        {
            ( *nonOptions )[i] = parse.nonOption( i );
        }
    }
}
 
const char *clOptions::operator[]( const std::string &key )
{
    mapIterator it = map.find( key );
 
    if( it == map.end() )
    {
        std::cerr << "oh no\n";
        return 0;
    }
 
    int typeDesc = typeMap[key];
 
    // If this option is not pressent, either return the opposite T/F condition or blank
    if( options[it->second].type() == argType::None )
    {
        if( typeDesc == argType::False )
            return trueStr;
        if( typeDesc == argType::True )
            return falseStr;
        return blankStr;
    }
 
    if( typeDesc == argType::False || typeDesc == argType::True )
    {
        if( options[it->second].last()->type() == argType::False )
            return falseStr;
        else
            return trueStr;
    }
 
    if( options[it->second].arg == 0 )
        return blankStr;
 
    return options[it->second].last()->arg;
}
 
int clOptions::count( const std::string &key )
{
    mapIterator it = map.find( key );
 
    if( it == map.end() )
        return -1;
 
    return options[it->second].count();
}
 
void clOptions::getAll( std::vector<std::string> &args, const std::string &key )
{
    mapIterator it = map.find( key );
 
    if( it == map.end() )
    {
        std::cerr << "oh no\n";
        return;
    }
 
    int typeDesc = typeMap[key];
 
    // If this option is not present, either return the opposite T/F condition or blank
    if( options[it->second].type() == argType::None )
    {
 
        if( typeDesc == argType::False )
        {
            args.resize( 1 );
            args[0] = trueStr;
            return;
        }
 
        if( typeDesc == argType::True )
        {
            args.resize( 1 );
            args[0] = falseStr;
            return;
        }
 
        args.clear();
 
        return;
    }
 
    if( typeDesc == argType::False || typeDesc == argType::True )
    {
        args.resize( 1 );
 
        if( options[it->second].last()->type() == argType::False )
            args[0] = falseStr;
        else
            args[0] = trueStr;
        return;
    }
 
    if( options[it->second].arg == 0 )
    {
        args.clear();
        return;
    }
 
    int N = options[it->second].count();
 
    args.resize( N );
 
    int i = 0;
 
    for( option::Option *opt = options[it->second]; opt != NULL && i < N; opt = opt->next() )
    {
        args[i] = opt->arg;
        ++i;
    }
}
 
bool clOptions::optSet( const std::string &key )
{
    mapIterator it = map.find( key );
 
    if( it == map.end() )
        return false; // Not found --> e.g. if neither command line short nor long option set.
 
    if( options[it->second].type() != argType::None )
        return true;
    return false;
};
 
int clOptions::numUnknown()
{
    // The dummy description to catch unknown options is inserted at position nOpts.
    return options[nOpts].count();
}
 
int clOptions::unknown( std::vector<std::string> &unk )
{
    unk.clear();
 
    if( numUnknown() == 0 )
        return 0;
 
    for( option::Option *opt = options[nOpts]; opt != NULL; opt = opt->next() )
    {
        unk.push_back( opt->name );
    }
 
    return 0;
}
 
} // namespace app
} // namespace mx