#include <Argx.hpp>

Public Member Functions
	Argx ()
	Argx (const std::string &id, int argc, char *argv[])
	Create Argx with the specific id, argc and argv
	~Argx ()
	Deconstruct allocated objects.
void	add (ARGXOptions option) const
	Add param options.
bool	compareArgs (std::vector< ARGXOptions > options, std::vector< std::string > argv)
	Compare if options contains the required id, if the ID does not exist, return false.
std::string	createDocs (ARGXStyle style, const std::string &title, const std::string &mainInfo)
	Create documentation for the parameters with the specific style, title and main information.
int	findParam (const std::string &id)
	Find parameter and sub-parameter index.
int	getArgc () const
	Get the main options from the main() function as argc.
int	getArgIDPos (const std::string &arg)
	Get argument using ID.
int	getArgPos (const std::string &arg)
	Get argument position with specified arg
std::string	getID () const
	Get Argx ID.
std::vector< std::string >	getMainArgs () const
	Get main arguments from main() function argv
ARGXOptions	getOption (const std::string &id)
	Get Options from specified ID.
std::vector< ARGXOptions >	getOptions () const
	Get main set options as ARGXOptions.
ARGXParam	getParam (const std::string &id)
	Get the param from id
bool	getSubParam (const argx::ARGXParam &param, const std::string &id)
	Get the sub-param from id
std::vector< std::string >	getSubValue (const std::string &id)
	Get sub-parameter values, starting from the first value found until the first found value that corresponds to a registered parameter.
int	getWrongArgs (const std::vector< std::string > &argv)
	Get the incorrect arguments and sub-arguments that were not registered.
bool	hasTag (const std::string &id, const std::string &tag)
	Check if the tag exists in option with ID of id
bool	paramExists (const std::string &id)
	Get if param exists in the param options.
std::string	paramToID (const std::string &param)
	Normal parameter or sub-paramter to its corresponding ID.
bool	subParamExists (const std::string &id)
	Get if sub-param exists in the param options.

Static Public Member Functions
static int	formatWrongArgs (const int &_int)
	Format to a positive number if number is negative for a correct execution of code.

Private Attributes
std::string	id

Static Private Attributes
static unsigned int	mainArgc
static std::vector< std::string > *	mainArgs = nullptr
static std::vector< ARGXOptions >	options

Detailed Description

Definition at line 17 of file Argx.hpp.

Constructor & Destructor Documentation

◆ Argx() [1/2]

argx::Argx::Argx	(	const std::string &	id,
		int	argc,
		char *	argv[] )

Create Argx with the specific id, argc and argv

Parameters

id	Set the ID of the Argx
argc	Set the argc of the main() function
argv	Set the argv of the main() function

Definition at line 34 of file Argx.cpp.

        : id(id)
    {
        this->mainArgs = new std::vector<std::string>(argv, argv + argc);
        this->mainArgc = argc;
 
        if (!this->mainArgs)
            std::cerr << "`Args::mainArgs` is not valid for ID of " + id + " variable is NULL";
    }

References Argx(), id, mainArgc, and mainArgs.

Referenced by Argx().

◆ Argx() [2/2]

argx::Argx::Argx ( )

Definition at line 45 of file Argx.cpp.

46 { }

◆ ~Argx()

argx::Argx::~Argx ( )

Deconstruct allocated objects.

Definition at line 48 of file Argx.cpp.

    {
        if (this->mainArgs) { delete this->mainArgs; this->mainArgs = nullptr; }
    }

References mainArgs.

Member Function Documentation

◆ add()

void argx::Argx::add ( ARGXOptions option ) const

Add param options.

Parameters

option Add the option to the main params

Definition at line 93 of file Argx.cpp.

94 { this->options.emplace_back(option); }

argx::Argx::options

static std::vector< ARGXOptions > options

Definition Argx.hpp:22

References options.

◆ compareArgs()

bool argx::Argx::compareArgs	(	std::vector< ARGXOptions >	options,
		std::vector< std::string >	argv )

Compare if options contains the required id, if the ID does not exist, return false.

Parameters

options	Return ARGXOptions vector
id	ID to find

Returns: bool

Definition at line 489 of file Argx.cpp.

    {
        // iterate over argv and skip program name
        for (size_t i = 1; i < argv.size(); ++i)
        {
            const std::string &arg = argv[i];
 
            // find a matching top-level option
            const ARGXOptions *matched = nullptr;
 
            for (const auto &opt : options)
            {
                if (opt.sparam == arg || opt.param == arg)
                {
                    matched = &opt;
 
                    break;
                }
            }
 
            // No matched top-level option
            if (!matched) return false;
 
            // if option supports subparams, try to get them
            if (matched->hasSubParams || matched->hasAnySubParams)
            {
                size_t j = i + 1;
 
                while (j < argv.size())
                {
                    const std::string &next = argv[j];
 
                    // Check the next declared subparam of `matched`
                    bool isSub = false;
 
                    for (const auto &sub : matched->subParams)
                    {
                        if (next == sub.param || next == sub.sparam)
                        {
                            isSub = true;
 
                            break;
                        }
                    }
 
                    // Get it and continue scanning for more subparams
                    if (isSub)
                    {
                        ++j;
 
                        continue;
                    }
 
                    // not a subparam then check if it's a known top-level option
                    bool isGlobal = false;
 
                    for (const auto &g : options)
                    {
                        if (next == g.param || next == g.sparam)
                        {
                            isGlobal = true;
                            break;
                        }
                    }
 
 
                    // stop scanning subparams; outer loop will handle this global option
                    if (isGlobal) break;
 
                    // neither a subparam nor a global option to an invalid sequence
                    return false;
                }
 
                // advance outer index to the last consumed token ( j - 1 ).
                // outer for-loop will increment i, so set `i = j - 1` to continue at j
                if (j > i + 1)
                    i = j - 1;
            }
        }
 
        return true;
    }

References argx::ARGXOptions::hasAnySubParams, argx::ARGXOptions::hasSubParams, options, and argx::ARGXOptions::subParams.

◆ createDocs()

std::string argx::Argx::createDocs	(	ARGXStyle	style,
		const std::string &	title,
		const std::string &	mainInfo )

Create documentation for the parameters with the specific style, title and main information.

Parameters

style	Set the style using ARGXStyle
title	Title for docs
Main	information

Returns: std::string Documentation as a string

Definition at line 293 of file Argx.cpp.

    {
        std::string contentStr;
 
        if (style == ARGXStyle::Professional)
        {
            for (const auto &x : this->options)
            {
                // Main option header line
                contentStr += "ID: " + x.id + "\n";
                contentStr += "[ " + x.sparam + " | " + x.param;
 
                if (x.hasSubParams && !x.subParams.empty())
                {
                    contentStr += " [ ";
 
                    for (size_t i = 0; i < x.subParams.size(); ++i)
                    {
                        const auto &sub = x.subParams[i];
 
                        contentStr += sub.param;
 
                        if (i < x.subParams.size() - 1) contentStr += " | ";
                        else if (i <= x.subParams.size()) contentStr += ' ';
                    }
 
                    contentStr += "] ] ";
                }
 
                else contentStr += " ] ";
 
                contentStr += x.info + "\n";
 
                // Print all sub-options with sparam and param, aligned with ideographic spaces if there are
                if (x.hasSubParams && !x.subParams.empty())
                {
                    for (const auto &sub : x.subParams)
                    {
                        // Create ideographic spaces matching the length of main param for alignment
                        std::wstring wideSpaces(x.param.size(), L'\u3000');
                        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
                        std::string spacing = converter.to_bytes(wideSpaces);
 
                        contentStr += spacing + "  [ " + sub.sparam + " | " + sub.param + " ] " + sub.info + "\n";
                    }
                }
            }
        }
 
        else if (style == ARGXStyle::Simple)
        {
            for (const auto &x : this->options)
            {
                contentStr += x.sparam + ", " + x.param + " - " + x.info + "\n";
 
                if (x.hasSubParams && !x.subParams.empty())
                {
                    for (const auto &sub : x.subParams)
                    {
                        contentStr += "  " + sub.sparam + ", " + sub.param + " - " + sub.info + "\n";
                    }
                }
            }
        } // ARGXStyle
 
        return title + "\n" + mainInfo + "\n" + contentStr;
    }

References options, argx::Professional, and argx::Simple.

◆ findParam()

int argx::Argx::findParam ( const std::string & id )

Find parameter and sub-parameter index.

Parameters

id	ID to find

Returns: int Index

Definition at line 96 of file Argx.cpp.

    {
        // First check if it's a main parameter
        for (size_t i = 0; i < this->options.size(); i++)
        {
            if (this->options[i].id == id)
            {
                // Check if this main parameter exists in arguments
                for (const std::string &arg : *this->mainArgs)
                {
                    if (arg == this->options[i].param || arg == this->options[i].sparam)
                    {
                        return static_cast<int>(i);
                    }
                }
            }
        }
 
        // Then look for sub-parameters
        for (const auto &opt : this->options)
        {
            // Check if the parent option exists in the arguments
            bool parentExists = false;
 
            for (const std::string &arg : *this->mainArgs)
            {
                if (arg == opt.param || arg == opt.sparam)
                {
                    parentExists = true;
                    break;
                }
            }
 
            if (parentExists)
            {
                // Find the index of the requested sub-parameter
                for (size_t i = 0; i < opt.subParams.size(); i++)
                {
                    if (opt.subParams[i].id == id) return static_cast<int>(i);
                }
            }
        }
 
        return -1; // Not found
    }

References mainArgs, and options.

Referenced by getSubParam(), hasTag(), and paramExists().

◆ formatWrongArgs()

int argx::Argx::formatWrongArgs ( const int & _int )

static

Format to a positive number if number is negative for a correct execution of code.

Parameters

_int	Number to convert

Returns: int Positive value number

Definition at line 482 of file Argx.cpp.

    {
        if (_int < 0) return -_int; // Convert to unsigned SAFELY
 
        return _int;
    }

◆ getArgc()

int argx::Argx::getArgc ( ) const

Get the main options from the main() function as argc.

Returns: int Number of params including the executable param

Definition at line 636 of file Argx.cpp.

637 { return this->mainArgc; }

References mainArgc.

◆ getArgIDPos()

int argx::Argx::getArgIDPos ( const std::string & arg )

Get argument using ID.

Parameters

arg	Argument to find

Returns: int Argument position

Definition at line 53 of file Argx.cpp.

    {
        ARGXOptions option = this->getOption(arg);
        
        int argPos = this->getArgPos(option.param);
        int shortArgPos = this->getArgPos(option.sparam);
 
        if (argPos >= 0) return argPos;
        if (shortArgPos >= 0) return shortArgPos;
 
        return -1;
    }

References getArgPos(), getOption(), argx::ARGXOptions::param, and argx::ARGXOptions::sparam.

◆ getArgPos()

int argx::Argx::getArgPos ( const std::string & arg )

Get argument position with specified arg

Parameters

arg	Find argument

Returns: int Return position of found arg from the options

Definition at line 79 of file Argx.cpp.

    {
        if (!this->mainArgs)
            return -2;
 
        for (size_t i = 0; i < this->mainArgs->size(); ++i)
        {
            if (this->mainArgs->at(i) == arg)
                return i;
        }
 
        return -1;
    }

References mainArgs.

Referenced by getArgIDPos(), and getSubValue().

◆ getID()

std::string argx::Argx::getID ( ) const

Get Argx ID.

Returns: std::string Argx ID

Definition at line 642 of file Argx.cpp.

643 { return this->id; }

◆ getMainArgs()

std::vector< std::string > argx::Argx::getMainArgs ( ) const

Get main arguments from main() function argv

Returns: std::vector<std::string> Vector of strings for main arguments from argv

Definition at line 633 of file Argx.cpp.

634 { return *this->mainArgs; }

References mainArgs.

Referenced by getSubValue().

◆ getOption()

ARGXOptions argx::Argx::getOption ( const std::string & id )

Get Options from specified ID.

Parameters

id	ID to find
ARGXOptions	Option information

Definition at line 572 of file Argx.cpp.

    {
        for (const auto &x : this->options)
            if (x.id == id) return x;
 
        return {};
    }

References options.

Referenced by getArgIDPos(), and getSubValue().

◆ getOptions()

std::vector< ARGXOptions > argx::Argx::getOptions ( ) const

Get main set options as ARGXOptions.

Returns: std::vector<ARGXOptions> Options to return

Definition at line 639 of file Argx.cpp.

640 { return this->options; }

References options.

◆ getParam()

ARGXParam argx::Argx::getParam ( const std::string & id )

Get the param from id

Parameters

id	The ID to get

Returns: ARGXParam Returnted parameter to get

Definition at line 171 of file Argx.cpp.

    {
        if (this->mainArgc <= 1) return {};
 
        ARGXParam result;
 
        // First, check if this is a top-level option
        for (const auto &opt : this->options)
        {
            if (opt.id == id)
            {
                // Find the position of the main option in arguments
                int mainOptionPos = -1;
 
                for (size_t i = 0; i < this->mainArgs->size(); ++i)
                {
                    if ((*this->mainArgs)[i] == opt.param || (*this->mainArgs)[i] == opt.sparam)
                    {
                        result.exists = true;
                        mainOptionPos = i;
                        break;
                    }
                }
 
                if (result.exists)
                {
                    if (opt.hasSubParams || opt.hasAnySubParams)
                    {
                        // Check each sub-parameter
                        for (const auto &sub : opt.subParams)
                        {
                            bool subMatched = false;
 
                            // Look for sub-parameters after the main option
                            for (size_t i = mainOptionPos + 1; i < this->mainArgs->size(); ++i)
                            {
                                if ((*this->mainArgs)[i] == sub.param || (*this->mainArgs)[i] == sub.sparam)
                                {
                                    subMatched = true;
                                    break;
                                }
                            }
 
                            result.subExists.push_back(subMatched);
                        }
                    }
 
                    return result;
                }
            }
        }
 
        // If not found as top-level, check if it's a sub-parameter
        for (const auto &opt : this->options)
        {
            // Find if the parent option exists and get its position
            size_t parentPos = -1;
 
            for (size_t i = 0; i < this->mainArgs->size(); ++i)
            {
                if ((*this->mainArgs)[i] == opt.param || (*this->mainArgs)[i] == opt.sparam)
                {
                    parentPos = i;
                    break;
                }
            }
 
            if (parentPos > -1 && (opt.hasSubParams || opt.hasAnySubParams))
            {
                // Check if the requested sub-parameter exists after the parent
                for (const auto &sub : opt.subParams)
                {
                    if (sub.id == id)
                    {
                        for (size_t i = parentPos + 1 ; i < this->mainArgs->size(); ++i)
                        {
                            if ((*this->mainArgs)[i] == sub.param || (*this->mainArgs)[i] == sub.sparam)
                            {
                                result.exists = true;
                                break;
                            }
                        }
 
                        if (!result.exists && parentPos + 1 < this->mainArgs->size())
                        {
                            std::string nextArg = (*this->mainArgs)[parentPos + 1];
 
                            if (nextArg == sub.param || nextArg == sub.sparam) result.exists = true;
                        }
 
                        // Handle any sub-sub-parameters if they exist
                        if (result.exists && (sub.hasSubParams || sub.hasAnySubParams))
                        {
                            for (const auto &subsub : sub.subParams)
                            {
                                bool subsubMatched = false;
 
                                for (size_t i = 0; i < this->mainArgs->size(); ++i)
                                {
                                    if ((*this->mainArgs)[i] == subsub.param || (*this->mainArgs)[i] == subsub.sparam)
                                    {
                                        subsubMatched = true;
                                        break;
                                    }
                                }
 
                                result.subExists.push_back(subsubMatched);
                            }
                        }
 
                        return result;
                    }
                }
            }
        }
 
        return result;
    }

References argx::ARGXParam::exists, mainArgc, mainArgs, options, and argx::ARGXParam::subExists.

◆ getSubParam()

bool argx::Argx::getSubParam	(	const argx::ARGXParam &	param,
		const std::string &	id )

Get the sub-param from id

Parameters

param	Original param
id	The ID to get

Returns: bool

Definition at line 290 of file Argx.cpp.

291 { return this->paramExists(id) && param.subExists[this->findParam(id)]; }

argx::Argx::paramExists

bool paramExists(const std::string &id)

Get if param exists in the param options.

Definition Argx.cpp:142

argx::Argx::findParam

int findParam(const std::string &id)

Find parameter and sub-parameter index.

Definition Argx.cpp:96

argx::ARGXParam::subExists

std::vector< bool > subExists

Definition types.hpp:60

References findParam(), paramExists(), and argx::ARGXParam::subExists.

◆ getSubValue()

std::vector< std::string > argx::Argx::getSubValue ( const std::string & id )

Get sub-parameter values, starting from the first value found until the first found value that corresponds to a registered parameter.

Parameters

id	ID to find to get sub-value

Returns: std::vector<std::string> Values found from first to last

Definition at line 580 of file Argx.cpp.

    {
        // Use `Argx::getArgPos()` function for sub-params
        size_t idPos = this->getArgPos(id) + 1;
 
        if (idPos < 0 || idPos == std::string::npos)
            return {this->getOption(id).defaultValue};
 
        std::vector<std::string> values;
 
        for (size_t i = idPos ; i < this->getMainArgs().size() ; i++)
        {
            // End of the sub-parameter finding
            // Assume the search is done due to an existsing sub-param
            if (i != idPos && this->subParamExists(this->getMainArgs()[i]))
                break;
 
            values.emplace_back(this->getMainArgs()[i]);
        }
 
        std::string defaultValue;
 
        {
            bool breakOut = false;
 
            for (size_t i = 0; i < this->mainArgs->size(); ++i)
            {
                for (size_t j = 0 ; j < this->options.size() ; ++j)
                {
                    if (this->options[i].subParams.size() > j)
                    {
                        if (this->options[i].subParams[j].id == id)
                        {
                            defaultValue = this->options[i].subParams[j].defaultValue;
 
 
                            breakOut = true;
 
                            break;
                        }
                    }
                }
 
                if (breakOut) break;
            }
        }
 
        if (values.empty())
            values.emplace_back(defaultValue);
 
        return values;
    }

References argx::ARGXOptions::defaultValue, getArgPos(), getMainArgs(), getOption(), mainArgs, options, and subParamExists().

◆ getWrongArgs()

int argx::Argx::getWrongArgs ( const std::vector< std::string > & argv )

Get the incorrect arguments and sub-arguments that were not registered.

Parameters

argv	Main arguments from argv

Returns: int Argument position

Definition at line 395 of file Argx.cpp.

    {
        int pos = 1; // skip program name
        bool isNormalParam = true;
 
        while (pos < (int)argv.size())
        {
            const std::string &arg = argv[pos];
 
            // Find matching top-level option
            const ARGXOptions *matched = nullptr;
 
            for (const auto &opt : this->options)
            {
                if (arg == opt.param || arg == opt.sparam)
                {
                    matched = &opt;
                    break;
                }
            }
            
            // unknown top-level arg
            if (!matched) return (isNormalParam ? pos : -pos);
 
            // matched a top-level option
            isNormalParam = true;
 
            if (matched->hasSubParams || matched->hasAnySubParams)
            {
                isNormalParam = false;
 
                int scanPos = pos + 1;
 
                while (scanPos < (int)argv.size())
                {
                    const std::string &nextArg = argv[scanPos];
 
                    // Is it a declared subparam for this option?
                    bool isSub = false;
 
                    for (const auto &subOpt : matched->subParams)
                    {
                        if (nextArg == subOpt.param || nextArg == subOpt.sparam)
                        {
                            isSub = true;
                            break;
                        }
                    }
 
                    if (isSub)
                    {
                        // Consume that subparam and continue scanning
                        pos = scanPos;
                        ++scanPos;
 
                        continue;
                    }
 
                    // If not a subparam, is it a global option? (do **NOT** consume it)
                    bool isGlobalOpt = false;
 
                    for (const auto &globalOpt : this->options)
                    {
                        if (nextArg == globalOpt.param || nextArg == globalOpt.sparam)
                        {
                            isGlobalOpt = true;
 
                            break;
                        }
                    }
 
                    // valid global option follows; stop subparam scan and let outer loop handle it
                    if (isGlobalOpt) break;
 
                    // neither subparam nor global option; it's an invalid sub-parameter token
                    return -scanPos;
                }
            }
 
            ++pos;
        }
 
        // If nothing wrong found; return your existing success codes
        if (isNormalParam) return (this->mainArgs->size() > 2 ? 2 : 1);
        else return (this->mainArgs->size() > 2 ? -2 : -1);
    }

References argx::ARGXOptions::hasAnySubParams, argx::ARGXOptions::hasSubParams, mainArgs, options, and argx::ARGXOptions::subParams.

◆ hasTag()

bool argx::Argx::hasTag	(	const std::string &	id,
		const std::string &	tag )

Check if the tag exists in option with ID of id

Parameters

id	ID from option
tag	Tag to find

Returns: bool Return false if there is no match, else, return true

Definition at line 159 of file Argx.cpp.

    {
        int paramID = this->findParam(id);
 
        if (paramID < 0) return false;
        
        // Validate if tag from options is equal to this tag from function param
        if (this->options[paramID].tag == tag) return true;
 
        return false;
    }

References findParam(), and options.

◆ paramExists()

bool argx::Argx::paramExists ( const std::string & id )

Get if param exists in the param options.

Parameters

id ID to get

Returns: bool

Definition at line 142 of file Argx.cpp.

    {
        if (this->findParam(id) >= 0) return true;
 
        return false;
    }

References findParam().

Referenced by getSubParam().

◆ paramToID()

std::string argx::Argx::paramToID ( const std::string & param )

Normal parameter or sub-paramter to its corresponding ID.

Parameters

param Parameter value or name

Returns: std::string ID of the param or sub-param

Definition at line 66 of file Argx.cpp.

    {
        std::string id;
 
        for (const auto &option : this->options)
        {
            if (option.param == param || option.sparam == param)
                return option.id;
        }
 
        return id;
    }

References id, and options.

◆ subParamExists()

bool argx::Argx::subParamExists ( const std::string & id )

Get if sub-param exists in the param options.

Parameters

id ID to get

Returns: bool

Definition at line 149 of file Argx.cpp.

    {
        for (const auto &p : this->options)
        {
            if (p.sparam == id) return true;
        }
        
        return false;
    }

References options.

Referenced by getSubValue().

Member Data Documentation

◆ id

std::string argx::Argx::id

private

Definition at line 20 of file Argx.hpp.

Referenced by Argx(), and paramToID().

◆ mainArgc

unsigned int argx::Argx::mainArgc

staticprivate

Definition at line 25 of file Argx.hpp.

Referenced by Argx(), getArgc(), and getParam().

◆ mainArgs

std::vector< std::string > * argx::Argx::mainArgs = nullptr

staticprivate

Definition at line 23 of file Argx.hpp.

Referenced by Argx(), ~Argx(), findParam(), getArgPos(), getMainArgs(), getParam(), getSubValue(), and getWrongArgs().

◆ options

std::vector< ARGXOptions > argx::Argx::options

staticprivate

Definition at line 22 of file Argx.hpp.

Referenced by add(), compareArgs(), createDocs(), findParam(), getOption(), getOptions(), getParam(), getSubValue(), getWrongArgs(), hasTag(), paramToID(), and subParamExists().

The documentation for this class was generated from the following files:

inc/Argx.hpp
src/Argx.cpp

Public Member Functions

Static Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Argx() [1/2]

◆ Argx() [2/2]

◆ ~Argx()

Member Function Documentation

◆ add()

◆ compareArgs()

◆ createDocs()

◆ findParam()

◆ formatWrongArgs()

◆ getArgc()

◆ getArgIDPos()

◆ getArgPos()

◆ getID()

◆ getMainArgs()

◆ getOption()

◆ getOptions()

◆ getParam()

◆ getSubParam()

◆ getSubValue()

◆ getWrongArgs()

◆ hasTag()

◆ paramExists()

◆ paramToID()

◆ subParamExists()

Member Data Documentation

◆ id

◆ mainArgc

◆ mainArgs

◆ options