ConfigFwd.hpp

// Copyright (c) 2017-2026, University of Cincinnati, developed by Henry Schreiner
// under NSF AWARD 1414736 and by the respective contributors.
// All rights reserved.
//
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
// IWYU pragma: private, include "CLI/CLI.hpp"
 
// [CLI11:public_includes:set]
#include <algorithm>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
// [CLI11:public_includes:end]
#include "Encoding.hpp"
#include "Error.hpp"
#include "StringTools.hpp"
 
namespace CLI {
// [CLI11:config_fwd_hpp:verbatim]
 
class App;
 
enum class ConfigOutputMode : std::uint8_t { Active = 0, AllDefaults, ActiveSubcommandDefaults };
 
struct ConfigItem {
    std::vector<std::string> parents{};
 
    std::string name{};
    std::vector<std::string> inputs{};
    bool multiline{false};
    CLI11_NODISCARD std::string fullname() const {
        std::vector<std::string> tmp = parents;
        tmp.emplace_back(name);
        return detail::join(tmp, ".");
        (void)multiline;  // suppression for cppcheck false positive
    }
};
 
class Config {
  protected:
    std::vector<ConfigItem> items{};
 
  public:
    virtual std::string to_config(const App *, bool, bool, std::string) const = 0;
 
    virtual std::string
    to_config(const App *app, ConfigOutputMode mode, bool write_description, std::string prefix) const {
        return to_config(app, mode != ConfigOutputMode::Active, write_description, std::move(prefix));
    }
 
    virtual std::vector<ConfigItem> from_config(std::istream &) const = 0;
 
    CLI11_NODISCARD virtual std::string to_flag(const ConfigItem &item) const {
        if(item.inputs.size() == 1) {
            return item.inputs.at(0);
        }
        if(item.inputs.empty()) {
            return "{}";
        }
        throw ConversionError::TooManyInputsFlag(item.fullname());  // LCOV_EXCL_LINE
    }
 
    CLI11_NODISCARD std::vector<ConfigItem> from_file(const std::string &name) const {
#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
        std::ifstream input{to_path(name)};
#else
        std::ifstream input{name};
#endif
 
        if(!input.good())
            throw FileError::Missing(name);
 
        return from_config(input);
    }
 
    virtual ~Config() = default;
};
 
class ConfigBase : public Config {
  protected:
    char commentChar = '#';
    char arrayStart = '[';
    char arrayEnd = ']';
    char arraySeparator = ',';
    char valueDelimiter = '=';
    char stringQuote = '"';
    char literalQuote = '\'';
    uint8_t maximumLayers{255};
    char parentSeparatorChar{'.'};
    bool commentDefaultsBool = false;
    bool allowMultipleDuplicateFields{false};
    int16_t configIndex{-1};
    std::string configSection{};
 
  public:
    std::string
    to_config(const App * /*app*/, ConfigOutputMode mode, bool write_description, std::string prefix) const override;
 
    std::string
    to_config(const App * /*app*/, bool default_also, bool write_description, std::string prefix) const override;
 
    std::vector<ConfigItem> from_config(std::istream &input) const override;
    ConfigBase *comment(char cchar) {
        commentChar = cchar;
        return this;
    }
    ConfigBase *arrayBounds(char aStart, char aEnd) {
        arrayStart = aStart;
        arrayEnd = aEnd;
        return this;
    }
    ConfigBase *arrayDelimiter(char aSep) {
        arraySeparator = aSep;
        return this;
    }
    ConfigBase *valueSeparator(char vSep) {
        valueDelimiter = vSep;
        return this;
    }
    ConfigBase *quoteCharacter(char qString, char literalChar) {
        stringQuote = qString;
        literalQuote = literalChar;
        return this;
    }
    ConfigBase *maxLayers(uint8_t layers) {
        maximumLayers = layers;
        return this;
    }
    ConfigBase *parentSeparator(char sep) {
        parentSeparatorChar = sep;
        return this;
    }
    ConfigBase *commentDefaults(bool comDef = true) {
        commentDefaultsBool = comDef;
        return this;
    }
    std::string &sectionRef() { return configSection; }
    CLI11_NODISCARD const std::string &section() const { return configSection; }
    ConfigBase *section(const std::string &sectionName) {
        configSection = sectionName;
        return this;
    }
 
    int16_t &indexRef() { return configIndex; }
    CLI11_NODISCARD int16_t index() const { return configIndex; }
    ConfigBase *index(int16_t sectionIndex) {
        configIndex = sectionIndex;
        return this;
    }
    ConfigBase *allowDuplicateFields(bool value = true) {
        allowMultipleDuplicateFields = value;
        return this;
    }
};
 
using ConfigTOML = ConfigBase;
 
class ConfigINI : public ConfigTOML {
 
  public:
    ConfigINI() {
        commentChar = ';';
        arrayStart = '\0';
        arrayEnd = '\0';
        arraySeparator = ' ';
        valueDelimiter = '=';
    }
};
// [CLI11:config_fwd_hpp:end]
}  // namespace CLI