lib/cc/simple_parser.h

Go to the documentation of this file.

// Copyright (C) 2016-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef SIMPLE_PARSER_H
#define SIMPLE_PARSER_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <cc/dhcp_config_error.h>
#include <util/triplet.h>
#include <map>
#include <vector>
#include <string>
#include <stdint.h>
#include <limits>
 
namespace isc {
namespace data {

struct SimpleDefault {
    SimpleDefault(const char* name, isc::data::Element::types type, const char* value)
        :name_(name), type_(type), value_(value) {}
    std::string name_;
    const isc::data::Element::types type_;
    const char* value_;
};

typedef std::vector<std::string> SimpleRequiredKeywords;

typedef std::map<std::string, isc::data::Element::types> SimpleKeywords;

typedef std::vector<SimpleDefault> SimpleDefaults;

typedef std::vector<std::string> ParamsList;
 

class SimpleParser {
public:

    static void checkRequired(const SimpleRequiredKeywords& required,
                              isc::data::ConstElementPtr scope);

    static void checkKeywords(const SimpleKeywords& keywords,
                              isc::data::ConstElementPtr scope);

    static size_t deriveParams(isc::data::ConstElementPtr parent,
                               isc::data::ElementPtr child,
                               const ParamsList& params);

    static size_t setDefaults(isc::data::ElementPtr scope,
                              const SimpleDefaults& default_values);

    static size_t setListDefaults(isc::data::ConstElementPtr list,
                                  const SimpleDefaults& default_values);

    static const data::Element::Position&
    getPosition(const std::string& name, const data::ConstElementPtr parent);

    static std::string getString(isc::data::ConstElementPtr scope,
                                 const std::string& name);

    static int64_t getInteger(isc::data::ConstElementPtr scope,
                              const std::string& name);

    template<typename T>
    static void rangeCheckedInteger(isc::data::ConstElementPtr scope,
                                    const std::string& name, T& output_value) {
        auto min = std::numeric_limits<T>::min();
        auto max = std::numeric_limits<T>::max();
        int64_t ivalue = getInteger(scope, name);
 
        if (ivalue < min || ivalue > max) {
            isc_throw (isc::dhcp::DhcpConfigError,
                       "'" << name << "' : " << ivalue << " is out of range,"
                       << " must be >= " << min << " and <= " << max);
        }
 
        output_value = static_cast<T>(ivalue);
    }

    static int64_t getInteger(isc::data::ConstElementPtr scope,
                              const std::string& name,
                              int64_t min, int64_t max);

    static bool getBoolean(isc::data::ConstElementPtr scope,
                           const std::string& name);
 

    static isc::asiolink::IOAddress
    getAddress(const ConstElementPtr& scope, const std::string& name);

    static double getDouble(const ConstElementPtr& scope,
                            const std::string& name);
 
protected:

    template <typename int_type> int_type
    getIntType(isc::data::ConstElementPtr scope,
               const std::string& name) {
        int64_t val_int = getInteger(scope, name);
        if ((val_int < std::numeric_limits<int_type>::min()) ||
            (val_int > std::numeric_limits<int_type>::max())) {
          isc_throw(isc::dhcp::DhcpConfigError,
                    "out of range value (" << val_int
                    << ") specified for parameter '" << name
                    << "' (" << getPosition(name, scope) << ")");
        }
        return (static_cast<int_type>(val_int));
    }

    template <typename target_type,
              target_type convert(const std::string&)> target_type
    getAndConvert(isc::data::ConstElementPtr scope,
                  const std::string& name,
                  const std::string& type_name) {
        std::string str = getString(scope, name);
        try {
            return (convert(str));
        } catch (const std::exception&) {
            isc_throw(isc::dhcp::DhcpConfigError,
                      "invalid " << type_name << " (" << str
                      << ") specified for parameter '" << name
                      << "' (" << getPosition(name, scope) << ")");
        }
    }
 
public:
    uint32_t getUint32(isc::data::ConstElementPtr scope,
                       const std::string& name) {
        return (getIntType<uint32_t>(scope, name));
    }

    uint16_t getUint16(isc::data::ConstElementPtr scope,
                       const std::string& name) {
        return (getIntType<uint16_t>(scope, name));
    }

    uint8_t getUint8(ConstElementPtr scope, const std::string& name) {
        return (getIntType<uint8_t>(scope, name));
    }

    const isc::util::Triplet<uint32_t> parseIntTriplet(const data::ConstElementPtr& scope,
                                                       const std::string& name);
};
 
}
}
 
#endif