advgetopt_data.cpp

Go to the documentation of this file.

// Copyright (c) 2006-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/advgetopt
// contact@m2osw.com
//
// This program 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 2 of the License, or
// (at your option) any later version.
//
// This program 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 this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
// self
//
#include    "advgetopt/advgetopt.h"
 
#include    "advgetopt/conf_file.h"
#include    "advgetopt/exception.h"
#include    "advgetopt/validator_double.h"
#include    "advgetopt/validator_integer.h"
#include    "advgetopt/version.h"
 
 
// cppthread
//
#include    <cppthread/log.h>
 
 
// C
//
#include    <string.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
 
namespace advgetopt
{
 
 
 
 
 
bool getopt::is_defined(std::string const & name) const
{
    is_parsed();
 
    option_info::pointer_t opt(get_option(name));
    if(opt != nullptr)
    {
        return opt->is_defined();
    }
 
    return false;
}
 
 
size_t getopt::size(std::string const & name) const
{
    is_parsed();
 
    option_info::pointer_t opt(get_option(name));
    if(opt != nullptr)
    {
        return opt->size();
    }
    return 0;
}
 
 
bool getopt::has_default(std::string const & name) const
{
    option_info::pointer_t opt(get_option(name));
    if(opt != nullptr)
    {
        return opt->has_default();
    }
 
    return false;
}
 
 
std::string getopt::get_default(std::string const & name) const
{
    option_info::pointer_t opt(get_option(name));
    if(opt != nullptr)
    {
        return opt->get_default();
    }
 
    return std::string();
}
 
 
long getopt::get_long(std::string const & name, int idx, long min, long max) const
{
    is_parsed();
 
    option_info::pointer_t opt(get_option(name));
    if(opt == nullptr)
    {
        throw getopt_logic_error(
                  "there is no --"
                + name
                + " option defined.");
    }
 
    long result(0.0);
    if(!opt->is_defined())
    {
        std::string const d(opt->get_default());
        if(d.empty())
        {
            throw getopt_logic_error(
                      "the --"
                    + name
                    + " option was not defined on the command line and it has no or an empty default.");
        }
        if(!validator_integer::convert_string(d, result))
        {
            // here we throw because this default value is defined in the
            // options of the tool and not by the user
            //
            throw getopt_logic_error(
                      "invalid default number \""
                    + d
                    + "\" for option --"
                    + name);
        }
    }
    else
    {
        result = opt->get_long(idx);
    }
 
    // TODO: replace with validators
    //
    if(result < min || result > max)
    {
        cppthread::log << cppthread::log_level_t::error
                       << result
                       << " is out of bounds ("
                       << min
                       << ".."
                       << max
                       << " inclusive) in parameter --"
                       << name
                       << "."
                       << cppthread::end;
        result = -1;
    }
 
    return result;
}
 
 
double getopt::get_double(std::string const & name, int idx, double min, double max) const
{
    is_parsed();
 
    option_info::pointer_t opt(get_option(name));
    if(opt == nullptr)
    {
        throw getopt_logic_error(
                  "there is no --"
                + name
                + " option defined.");
    }
 
    double result(0);
    if(!opt->is_defined())
    {
        std::string const d(opt->get_default());
        if(d.empty())
        {
            throw getopt_logic_error(
                      "the --"
                    + name
                    + " option was not defined on the command line and it has no or an empty default.");
        }
        if(!validator_double::convert_string(d, result))
        {
            // here we throw because this default value is defined in the
            // options of the tool and not by the user
            //
            throw getopt_logic_error(
                      "invalid default number \""
                    + d
                    + "\" for option --"
                    + name
                    + ".");
        }
    }
    else
    {
        result = opt->get_double(idx);
    }
 
    if(result < min || result > max)
    {
        cppthread::log << cppthread::log_level_t::error
                       << result
                       << " is out of bounds ("
                       << min
                       << ".."
                       << max
                       << " inclusive) in parameter --"
                       << name
                       << "."
                       << cppthread::end;
        result = -1.0;
    }
 
    return result;
}
 
 
std::string getopt::get_string(
      std::string const & name
    , int idx
    , bool raw) const
{
    is_parsed();
 
    option_info::pointer_t opt(get_option(name));
    if(opt == nullptr)
    {
        throw getopt_logic_error(
                  "there is no --"
                + name
                + " option defined.");
    }
 
    if(!opt->is_defined())
    {
        if(opt->has_default())
        {
            return opt->get_default();
        }
        throw getopt_logic_error(
                  "the --"
                + name
                + " option was not defined on the command line and it has no default.");
    }
 
    // it was defined, but if REQUIRED is not set and the value is empty
    // then we want to return the default if it has such defined
    //
    std::string const value(opt->get_value(idx, raw));
    if(value.empty()
    && opt->has_default()
    && !opt->has_flag(GETOPT_FLAG_REQUIRED))
    {
        return opt->get_default();
    }
 
    return value;
}
 
 
std::string getopt::operator [] (std::string const & name) const
{
    is_parsed();
 
    if(name.empty())
    {
        throw getopt_logic_error("argument name cannot be empty.");
    }
 
    option_info::pointer_t opt(get_option(name));
    if(opt == nullptr)
    {
        return std::string();
    }
 
    if(!opt->is_defined())
    {
        if(opt->has_default())
        {
            return opt->get_default();
        }
        return std::string();
    }
 
    return opt->get_value(0);
}
 
 
option_info_ref getopt::operator [] (std::string const & name)
{
    is_parsed();
 
    if(name.empty())
    {
        throw getopt_logic_error("argument name cannot be empty.");
    }
 
    option_info::pointer_t opt(get_option(name));
    if(opt == nullptr)
    {
        if(name.length() == 1)
        {
            throw getopt_logic_error("argument name cannot be one letter if it does not exist in operator [].");
        }
 
        // The option doesn't exist yet, create it
        //
        opt = std::make_shared<option_info>(name);
        opt->set_variables(f_variables);
        opt->add_flag(GETOPT_FLAG_DYNAMIC_CONFIGURATION);
        f_options_by_name[name] = opt;
    }
 
    return option_info_ref(opt);
}
 
 
flag_t getopt::process_system_options(std::basic_ostream<char> & out)
{
    flag_t result(SYSTEM_OPTION_NONE);
 
    // --version
    if(is_defined("version"))
    {
        if(f_options_environment.f_version == nullptr)
        {
            out << "warning: no version found." << std::endl;
        }
        else
        {
            out << f_options_environment.f_version << std::endl;
        }
        result |= SYSTEM_OPTION_VERSION;
    }
 
    // --has-sanitizer
    if(is_defined("has-sanitizer"))
    {
        out << sanitizer_details() << std::flush;
        result |= SYSTEM_OPTION_HELP;
    }
 
    // --compiler-version
    if(is_defined("compiler-version"))
    {
        out << LIBADVGETOPT_COMPILER_VERSION << std::endl;
        result |= SYSTEM_OPTION_HELP;
    }
 
    // --help
    if(is_defined("help"))
    {
        less(out, usage());
        result |= SYSTEM_OPTION_HELP;
    }
 
    // --long-help
    if(is_defined("long-help"))
    {
        less(out, usage(GETOPT_FLAG_SHOW_ALL));
        result |= SYSTEM_OPTION_HELP;
    }
 
    // --<group-name>-help
    //
    if(f_options_environment.f_groups != nullptr)
    {
        for(group_description const * grp = f_options_environment.f_groups
          ; grp->f_group != GETOPT_FLAG_GROUP_NONE
          ; ++grp)
        {
            // the name is not mandatory, without it you do not get the command
            // line option but still get the group description
            //
            if(grp->f_name != nullptr
            && *grp->f_name != '\0')
            {
                std::string const name(grp->f_name);
                std::string const option_name(name + "-help");
                if(is_defined(option_name))
                {
                    less(out, usage(grp->f_group));
                    result |= SYSTEM_OPTION_HELP;
                }
            }
        }
    }
 
    // --system-help
    if(is_defined("system-help"))
    {
        less(out, usage(GETOPT_FLAG_SHOW_SYSTEM));
        result |= SYSTEM_OPTION_HELP;
    }
 
    // --copyright
    if(is_defined("copyright"))
    {
        if(f_options_environment.f_copyright == nullptr)
        {
            out << "warning: no copyright notice found." << std::endl;
        }
        else
        {
            less(out, f_options_environment.f_copyright);
        }
        result |= SYSTEM_OPTION_COPYRIGHT;
    }
 
    // --license
    if(is_defined("license"))
    {
        if(f_options_environment.f_license == nullptr)
        {
            out << "warning: no license found." << std::endl;
        }
        else
        {
            less(out, f_options_environment.f_license);
        }
        result |= SYSTEM_OPTION_LICENSE;
    }
 
    // --build-date
    if(is_defined("build-date"))
    {
        out << "Built on "
            << (f_options_environment.f_build_date == nullptr
                    ? "<no-build-date>"
                    : f_options_environment.f_build_date)
            << " at "
            << (f_options_environment.f_build_time == nullptr
                    ? "<no-build-time>"
                    : f_options_environment.f_build_time)
            << std::endl;
        result |= SYSTEM_OPTION_BUILD_DATE;
    }
 
    // --environment-variable-name
    if(is_defined("environment-variable-name"))
    {
        if(f_options_environment.f_environment_variable_name == nullptr
        || *f_options_environment.f_environment_variable_name == '\0')
        {
            out << f_options_environment.f_project_name
                << " does not support an environment variable."
                << std::endl;
        }
        else
        {
            out << f_options_environment.f_environment_variable_name << std::endl;
        }
        result |= SYSTEM_OPTION_ENVIRONMENT_VARIABLE_NAME;
    }
 
    // --configuration-filenames
    if(is_defined("configuration-filenames"))
    {
        string_list_t list(get_configuration_filenames(false, false));
        if(list.empty())
        {
            out << f_options_environment.f_project_name
                << " does not support configuration files."
                << std::endl;
        }
        else
        {
            out << "Configuration filenames:" << std::endl;
            for(auto n : list)
            {
                out << " . " << n << std::endl;
            }
        }
        result |= SYSTEM_OPTION_CONFIGURATION_FILENAMES;
    }
 
    // --path-to-option-definitions
    if(is_defined("path-to-option-definitions"))
    {
        out << get_path_to_option_files() << std::endl;
        result |= SYSTEM_OPTION_PATH_TO_OPTION_DEFINITIONS;
    }
 
    // --filenames-of-option-definitions
    if(is_defined("filenames-of-option-definitions"))
    {
        string_list_t const list(getopt::get_filenames_of_option_definitions());
        for(auto const & l : list)
        {
            out << l << std::endl;
        }
        result |= SYSTEM_OPTION_PATH_TO_OPTION_DEFINITIONS;
    }
 
    // --config-dir
    if(is_defined("config-dir"))
    {
        // these are automatically used in the get_configuration_filenames()
        // function, there is nothing for us to do here
        //
        result |= SYSTEM_OPTION_CONFIG_DIR;
    }
 
    // --show-option-sources
    if(is_defined("show-option-sources"))
    {
        show_option_sources(out);
        result |= SYSTEM_OPTION_SHOW_OPTION_SOURCES;
    }
 
    // --print-option
    if(is_defined("print-option"))
    {
        std::string const name(get_string("print-option"));
        if(is_defined(name))
        {
            out << get_string(name) << std::endl;
        }
        else if(has_default(name))
        {
            out << get_default(name) << std::endl;
        }
        result |= SYSTEM_OPTION_SHOW_OPTION_VALUE;
    }
 
    return result;
}
 
 
 
 
 
} // namespace advgetopt
// vim: ts=4 sw=4 et