#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 ()

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 index.

int	getArgc () const
	Get the main options from the `main()` function as argc.

std::string	getID () const
	Get Argx ID.

std::vector< std::string >	getMainArgs () const
	Get main arguments from `main()` function `argv`

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`

bool	paramExists (const std::string &id)
	Get if param exists in the param options.

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 23 of file Argx.cpp.

        : id(id)
    {
        this->mainArgs = new std::vector<std::string>(argv, argv + argc);
        this->mainArgc = argc;
    }

References id, mainArgc, and mainArgs.

◆ Argx() [2/2]

argx::Argx::Argx ( )

Definition at line 30 of file Argx.cpp.

31 { }

◆ ~Argx()

argx::Argx::~Argx ( )

Definition at line 33 of file Argx.cpp.

    {
        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 38 of file Argx.cpp.

    {
        ARGXError error = {
            .type = "success",
            .code = 0
        };
 
        this->options.emplace_back(option);
    }

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 293 of file Argx.cpp.

    {
        // Skip program name ( as arg )
        for (size_t i = 1 ; i < argv.size() ; ++i)
        {
            const std::string &arg = argv[i];
 
            bool found = false;
            for (const auto &option : options)
            {
                if (option.sparam == arg || option.param == arg)
                {
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                return false; // Unknown argument
            }
        }
        return true; // All arguments are valid
    }

References options.

◆ 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 225 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 index.

Definition at line 48 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(), and paramExists().

◆ 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 320 of file Argx.cpp.

321 { return this->mainArgc; }

References mainArgc.

◆ getID()

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

Get Argx ID.

Returns: std::string Argx ID

Definition at line 326 of file Argx.cpp.

327 { return this->id; }

References 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 317 of file Argx.cpp.

318 { return *this->mainArgs; }

References mainArgs.

◆ getOptions()

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

Get main set options as ARGXOptions.

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

Definition at line 323 of file Argx.cpp.

324 { 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 103 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)
                    {
                        // 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)
            {
                // 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)
                        {
                            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 222 of file Argx.cpp.

223 { 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:94

argx::Argx::findParam

int findParam(const std::string &id)

Find parameter index.

Definition Argx.cpp:48

argx::ARGXParam::subExists

std::vector< bool > subExists

Definition types.hpp:51

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

◆ 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 94 of file Argx.cpp.

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

References findParam().

Referenced by getSubParam().

Member Data Documentation

◆ id

std::string argx::Argx::id

private

Definition at line 20 of file Argx.hpp.

Referenced by Argx(), and getID().

◆ 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(), getMainArgs(), and getParam().

◆ options

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

staticprivate

Definition at line 22 of file Argx.hpp.

Referenced by add(), compareArgs(), createDocs(), findParam(), getOptions(), and getParam().

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

inc/Argx.hpp
src/Argx.cpp

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()

◆ getArgc()

◆ getID()

◆ getMainArgs()

◆ getOptions()

◆ getParam()

◆ getSubParam()

◆ paramExists()

Member Data Documentation

◆ id

◆ mainArgc

◆ mainArgs

◆ options