BaseLib::TCLAPOutput Class Reference

Detailed Description

Definition at line 57 of file TCLAPOutput.h.

#include <TCLAPOutput.h>

Inheritance diagram for BaseLib::TCLAPOutput:

Collaboration diagram for BaseLib::TCLAPOutput:

Public Member Functions
virtual void	usage (TCLAP::CmdLineInterface &_cmd)

Private Member Functions
template<typename T>
void	tryPrintValue (TCLAP::Arg *arg, std::ostream &os, bool required)

Member Function Documentation

tryPrintValue()

template<typename T>

void BaseLib::TCLAPOutput::tryPrintValue ( TCLAP::Arg * arg, std::ostream & os, bool required )

inlineprivate

Definition at line 158 of file TCLAPOutput.h.

    {
        if (auto val = dynamic_cast<TCLAP::ValueArg<T>*>(arg))
        {
            os << " (" << type_name<T>();
            if (!required)
            {
                if constexpr (std::is_same_v<T, std::string>)
                {
                    // print non-empty default value only
                    if (val->getValue() != "")
                    {
                        os << ", default: " << val->getValue();
                    }
                }
                else
                {
                    os << ", default: " << val->getValue();
                }
            }
            os << ")";
        }
    }

References BaseLib::type_name().

Referenced by usage().

usage()

virtual void BaseLib::TCLAPOutput::usage ( TCLAP::CmdLineInterface & _cmd )

inlinevirtual

Definition at line 60 of file TCLAPOutput.h.

    {
        // Follows implementation from tclap
        std::cout << std::endl << "USAGE: " << std::endl << std::endl;
        _shortUsage(_cmd, std::cout);
        std::cout << std::endl
                  << std::endl
                  << "Where: " << std::endl
                  << std::endl;
 
        std::string const message = _cmd.getMessage();
        std::list<TCLAP::ArgGroup*> argSets = _cmd.getArgGroups();
 
        std::list<TCLAP::Arg*> unlabelled;
        for (auto& argSet : argSets)
        {
            TCLAP::ArgGroup& argGroup = *argSet;
 
            int const visible = CountVisibleArgs(argGroup);
            bool const exclusive = visible > 1 && argGroup.isExclusive();
            bool const forceRequired = visible == 1 && argGroup.isRequired();
            if (exclusive)
            {
                spacePrint(std::cout,
                           argGroup.isRequired() ? "One of:" : "Either of:", 75,
                           3, 0);
            }
 
            for (auto& it : argGroup)
            {
                TCLAP::Arg& arg = *it;
 
                if (!arg.visibleInHelp())
                {
                    continue;
                }
 
                if (!arg.hasLabel())
                {
                    unlabelled.push_back(&arg);
                    continue;
                }
 
                // Added by LB:
                std::string const shortID = arg.shortID();
                std::smatch match;
                bool const required = arg.isRequired() || forceRequired;
                std::stringstream ss;
                if (std::regex_search(shortID, match, std::regex("<([^>]+)>")))
                {
                    std::string const identifier = match[1];
 
                    ss << identifier;
                    tryPrintValue<std::string>(it, ss, required);
                    tryPrintValue<int>(it, ss, required);
                    tryPrintValue<double>(it, ss, required);
                    tryPrintValue<float>(it, ss, required);
                    tryPrintValue<size_t>(it, ss, required);
                    tryPrintValue<unsigned>(it, ss, required);
                    tryPrintValue<unsigned int>(it, ss, required);
                    ss << ": ";
                }
                ss << arg.getDescription(required);
 
                if (exclusive)
                {
                    spacePrint(std::cout, arg.longID(), 75, 6, 3);
                    spacePrint(std::cout, ss.str(), 75, 8, 0);
                }
                else
                {
                    spacePrint(std::cout, arg.longID(), 75, 3, 3);
                    spacePrint(std::cout, ss.str(), 75, 5, 0);
                }
                std::cout << '\n';
            }
        }
 
        for (TCLAP::ArgListIterator it = unlabelled.begin();
             it != unlabelled.end();
             ++it)
        {
            const TCLAP::Arg& arg = **it;
            spacePrint(std::cout, arg.longID(), 75, 3, 3);
            spacePrint(std::cout, arg.getDescription(), 75, 5, 0);
            std::cout << '\n';
        }
 
        if (!message.empty())
        {
            spacePrint(std::cout, message, 75, 3, 0);
        }
 
        std::cout.flush();
    }

References tryPrintValue().

---

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

• TCLAPOutput.h