language_settings_private.cc | Explore in Territory

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

// GENERATED FROM THE API DEFINITION IN
//   chrome/common/extensions/api/language_settings_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/language_settings_private.h"

#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_op.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"
#include <string_view>


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace language_settings_private {
//
// Types
//

const char* ToString(MoveType enum_param) { … }

MoveType ParseMoveType(std::string_view enum_string) { … }

std::u16string GetMoveTypeParseError(std::string_view enum_string) { … }


Language::Language()
 { … }

Language::~Language() = default;
Language::Language(Language&& rhs) noexcept = default;
Language& Language::operator=(Language&& rhs) noexcept = default;
Language Language::Clone() const { … }

// static
bool Language::Populate(
    const base::Value::Dict& dict, Language& out) { … }

// static
bool Language::Populate(
    const base::Value& value, Language& out) { … }

// static
std::optional<Language> Language::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<Language> Language::FromValue(const base::Value& value) { … }

base::Value::Dict Language::ToValue() const { … }


SpellcheckDictionaryStatus::SpellcheckDictionaryStatus()
: … { … }

SpellcheckDictionaryStatus::~SpellcheckDictionaryStatus() = default;
SpellcheckDictionaryStatus::SpellcheckDictionaryStatus(SpellcheckDictionaryStatus&& rhs) noexcept = default;
SpellcheckDictionaryStatus& SpellcheckDictionaryStatus::operator=(SpellcheckDictionaryStatus&& rhs) noexcept = default;
SpellcheckDictionaryStatus SpellcheckDictionaryStatus::Clone() const { … }

// static
bool SpellcheckDictionaryStatus::Populate(
    const base::Value::Dict& dict, SpellcheckDictionaryStatus& out) { … }

// static
bool SpellcheckDictionaryStatus::Populate(
    const base::Value& value, SpellcheckDictionaryStatus& out) { … }

// static
std::optional<SpellcheckDictionaryStatus> SpellcheckDictionaryStatus::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<SpellcheckDictionaryStatus> SpellcheckDictionaryStatus::FromValue(const base::Value& value) { … }

base::Value::Dict SpellcheckDictionaryStatus::ToValue() const { … }


InputMethod::InputMethod()
 { … }

InputMethod::~InputMethod() = default;
InputMethod::InputMethod(InputMethod&& rhs) noexcept = default;
InputMethod& InputMethod::operator=(InputMethod&& rhs) noexcept = default;
InputMethod InputMethod::Clone() const { … }

// static
bool InputMethod::Populate(
    const base::Value::Dict& dict, InputMethod& out) { … }

// static
bool InputMethod::Populate(
    const base::Value& value, InputMethod& out) { … }

// static
std::optional<InputMethod> InputMethod::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<InputMethod> InputMethod::FromValue(const base::Value& value) { … }

base::Value::Dict InputMethod::ToValue() const { … }


InputMethodLists::InputMethodLists()
 { … }

InputMethodLists::~InputMethodLists() = default;
InputMethodLists::InputMethodLists(InputMethodLists&& rhs) noexcept = default;
InputMethodLists& InputMethodLists::operator=(InputMethodLists&& rhs) noexcept = default;
InputMethodLists InputMethodLists::Clone() const { … }

// static
bool InputMethodLists::Populate(
    const base::Value::Dict& dict, InputMethodLists& out) { … }

// static
bool InputMethodLists::Populate(
    const base::Value& value, InputMethodLists& out) { … }

// static
std::optional<InputMethodLists> InputMethodLists::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<InputMethodLists> InputMethodLists::FromValue(const base::Value& value) { … }

base::Value::Dict InputMethodLists::ToValue() const { … }



//
// Functions
//

namespace GetLanguageList {

base::Value::List Results::Create(const std::vector<Language>& languages) { … }
}  // namespace GetLanguageList

namespace EnableLanguage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace EnableLanguage

namespace DisableLanguage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace DisableLanguage

namespace SetEnableTranslationForLanguage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace SetEnableTranslationForLanguage

namespace MoveLanguage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace MoveLanguage

namespace GetAlwaysTranslateLanguages {

base::Value::List Results::Create(const std::vector<std::string>& language_codes) { … }
}  // namespace GetAlwaysTranslateLanguages

namespace SetLanguageAlwaysTranslateState {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace SetLanguageAlwaysTranslateState

namespace GetNeverTranslateLanguages {

base::Value::List Results::Create(const std::vector<std::string>& language_codes) { … }
}  // namespace GetNeverTranslateLanguages

namespace GetSpellcheckDictionaryStatuses {

base::Value::List Results::Create(const std::vector<SpellcheckDictionaryStatus>& status) { … }
}  // namespace GetSpellcheckDictionaryStatuses

namespace GetSpellcheckWords {

base::Value::List Results::Create(const std::vector<std::string>& words) { … }
}  // namespace GetSpellcheckWords

namespace AddSpellcheckWord {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace AddSpellcheckWord

namespace RemoveSpellcheckWord {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RemoveSpellcheckWord

namespace GetTranslateTargetLanguage {

base::Value::List Results::Create(const std::string& language_code) { … }
}  // namespace GetTranslateTargetLanguage

namespace SetTranslateTargetLanguage {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace SetTranslateTargetLanguage

namespace GetInputMethodLists {

base::Value::List Results::Create(const InputMethodLists& lists) { … }
}  // namespace GetInputMethodLists

namespace AddInputMethod {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace AddInputMethod

namespace RemoveInputMethod {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RemoveInputMethod

namespace RetryDownloadDictionary {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RetryDownloadDictionary

//
// Events
//

namespace OnSpellcheckDictionariesChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<SpellcheckDictionaryStatus>& statuses) { … }

}  // namespace OnSpellcheckDictionariesChanged

namespace OnCustomDictionaryChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<std::string>& words_added, const std::vector<std::string>& words_removed) { … }

}  // namespace OnCustomDictionaryChanged

namespace OnInputMethodAdded {

const char kEventName[] = …;

base::Value::List Create(const std::string& input_method_id) { … }

}  // namespace OnInputMethodAdded

namespace OnInputMethodRemoved {

const char kEventName[] = …;

base::Value::List Create(const std::string& input_method_id) { … }

}  // namespace OnInputMethodRemoved

}  // namespace language_settings_private
}  // namespace api
}  // namespace extensions
chromium/out/Default/gen/chrome/common/extensions/api/language_settings_private.cc
