lib/options.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIB_OPTIONS_H_
#define LIB_OPTIONS_H_
 
#include <functional>
#include <iostream>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "cstring.h"
#include "error.h"
#include "map.h"
 
namespace P4::Util {
 
// Command-line options processing
class Options {
 public:
    enum OptionFlags {
        Default = 0,

        Hide = 1 << 0,

        OptionalArgument = 1 << 1,
    };
 
    // return true if processing is successful
    using OptionProcessor = std::function<bool(const char *)>;
 
 private:
    void shortUsage();
 
 protected:
    struct Option {
        cstring option;
        const char *argName;  // nullptr if argument is not required
        const char *description;
        OptionProcessor processor;
        OptionFlags flags;
    };
    const char *binaryName;
    cstring message;
    // Build date and compile command required in couple runtime files
    cstring compileCommand;
    cstring buildDate;
    std::ostream *outStream = &std::cerr;
 
    std::map<cstring, std::shared_ptr<const Option>> options;
    std::vector<cstring> optionOrder;
    std::vector<const char *> additionalUsage;
    std::vector<const char *> remainingOptions;  // produced as output
    // if true unknown options are collected in remainingOptions
    bool collectUnknownOptions = false;
 
    void setOutStream(std::ostream *out) { outStream = out; }
    void registerUsage(const char *msg) { additionalUsage.push_back(msg); }
    void registerOption(const char *option,         // option to register, e.g., -c or --version
                        const char *argName,        // name of option argument;
                                                    // nullptr if no argument expected
                        OptionProcessor processor,  // function to execute when option matches
                        const char *description,    // option help message
                        OptionFlags flags = OptionFlags::Default);  // additional flags
 
    explicit Options(std::string_view message)
        : binaryName(nullptr), message(message), compileCommand("") {}
    virtual ~Options() = default;

    [[nodiscard]] virtual bool validateOptions() const;
 
 public:
    virtual std::vector<const char *> *process(int argc, char *const argv[]);

    virtual std::vector<const char *> *process_options(int argc, char *const argv[]);
 
    [[nodiscard]] virtual const char *getIncludePath() const = 0;
    cstring getCompileCommand() { return compileCommand; }
    cstring getBuildDate() { return buildDate; }
    cstring getBinaryName() { return cstring(binaryName); }
    virtual void usage();
};
 
}  // namespace P4::Util
 
#endif /* LIB_OPTIONS_H_ */