manifest_parse_util.h | Explore in Territory

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef TOOLS_JSON_SCHEMA_COMPILER_MANIFEST_PARSE_UTIL_H_
#define TOOLS_JSON_SCHEMA_COMPILER_MANIFEST_PARSE_UTIL_H_

#include <string>
#include <string_view>
#include <vector>

#include "base/check.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"

namespace json_schema_compiler {
namespace manifest_parse_util {

// This file contains helpers used by auto-generated manifest parsing code.

// Populates |error| and |error_path_reversed| denoting the given invalid enum
// |value| at the given |key|.
void PopulateInvalidEnumValueError(
    std::string_view key,
    std::string_view value,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed);

// Populates `error` and `error_path_reversed` indicating a provided value was
// invalid for a set of type choices.
void PopulateInvalidChoiceValueError(
    std::string_view key,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed);

// Populates `error` and `error_path_reversed` indicating a certain key is
// required.
void PopulateKeyIsRequiredError(
    std::string_view key,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed);

// Returns array parse error for `item_error` at index `error_index`
std::u16string GetArrayParseError(size_t error_index,
                                  const std::u16string& item_error);

// Populates manifest parse |error| for the given path in |error_path_reversed|.
void PopulateFinalError(std::u16string& error,
                        std::vector<std::string_view>& error_path_reversed);

// Returns the value at the given |key| in |dict|, ensuring that it's of the
// |expected_type|. On failure, returns false and populates |error| and
// |error_path_reversed|.
const base::Value* FindKeyOfType(
    const base::Value::Dict& dict,
    std::string_view key,
    base::Value::Type expected_type,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed);

// Parses |out| from |dict| at the given |key|. On failure, returns false and
// populates |error| and |error_path_reversed|.
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         int& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         bool& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         double& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::string& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);

// This overload is used for lists/arrays.
template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::vector<T>& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);

// This overload is used for optional types wrapped as unique_ptr<T>.
template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::unique_ptr<T>& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);

// This overload is used for optional types wrapped as std::optional<T>.
template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::optional<T>& out_opt,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed);

// This overload is used for generated types.
template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         T& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed) { … }

template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::vector<T>& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed) { … }

template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::unique_ptr<T>& out,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed) { … }

template <typename T>
bool ParseFromDictionary(const base::Value::Dict& dict,
                         std::string_view key,
                         std::optional<T>& out_opt,
                         std::u16string& error,
                         std::vector<std::string_view>& error_path_reversed) { … }

// Alias for pointer to a function which converts a string to an enum of type T.
StringToEnumConverter;

// Parses enum |out| from |dict| at the given |key|. On failure, returns false
// and populates |error| and |error_path_reversed|.
template <typename T>
bool ParseEnumFromDictionary(
    const base::Value::Dict& dict,
    std::string_view key,
    StringToEnumConverter<T> converter,
    bool is_optional_property,
    T none_value,
    T& out,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed) { … }

// Parses non-optional enum array `out` from `dict` at the given `key`. On
// failure, returns false and populates `error` and `error_path_reversed`.
template <typename T>
bool ParseEnumArrayFromDictionary(
    const base::Value::Dict& dict,
    std::string_view key,
    StringToEnumConverter<T> converter,
    T none_value,
    std::vector<T>& out,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed) { … }

// Overload for optional enum arrays.
template <typename T>
bool ParseEnumArrayFromDictionary(
    const base::Value::Dict& dict,
    std::string_view key,
    StringToEnumConverter<T> converter,
    T none_value,
    std::optional<std::vector<T>>& out,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed) { … }

// Specialization for type "CHOICES" from ManifestKeys.
template <typename T>
bool ParseChoicesFromDictionary(
    const base::Value::Dict& dict,
    std::string_view key,
    T& out,
    std::u16string& error,
    std::vector<std::string_view>& error_path_reversed) { … }

}  // namespace manifest_parse_util
}  // namespace json_schema_compiler

#endif  // TOOLS_JSON_SCHEMA_COMPILER_MANIFEST_PARSE_UTIL_H_
chromium/tools/json_schema_compiler/manifest_parse_util.h
