chromium/out/Default/gen/extensions/common/api/extensions_manifest_types.cc

// 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
//   extensions/common/api/extensions_manifest_types.json
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "extensions/common/api/extensions_manifest_types.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 "base/types/expected.h"


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace extensions_manifest_types {
//
// Types
//

Automation::Object::Object()
 { … }

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

// static
bool Automation::Object::Populate(
    const base::Value::Dict& dict, Object& out, std::u16string& error) { … }

// static
bool Automation::Object::Populate(
    const base::Value& value, Object& out, std::u16string& error) { … }

// static
base::expected<Automation::Object, std::u16string> Automation::Object::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Automation::Object, std::u16string> Automation::Object::FromValue(const base::Value& value) { … }

base::Value::Dict Automation::Object::ToValue() const { … }



Automation::Automation()
 { … }

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

// static
bool Automation::Populate(
    const base::Value& value, Automation& out, std::u16string& error) { … }

// static
base::expected<Automation, std::u16string> Automation::FromValue(const base::Value& value) { … }

base::Value Automation::ToValue() const { … }


ContentCapabilities::ContentCapabilities()
 { … }

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

// static
bool ContentCapabilities::Populate(
    const base::Value::Dict& dict, ContentCapabilities& out, std::u16string& error) { … }

// static
bool ContentCapabilities::Populate(
    const base::Value& value, ContentCapabilities& out, std::u16string& error) { … }

// static
base::expected<ContentCapabilities, std::u16string> ContentCapabilities::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<ContentCapabilities, std::u16string> ContentCapabilities::FromValue(const base::Value& value) { … }

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


ExternallyConnectable::ExternallyConnectable()
 { … }

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

// static
bool ExternallyConnectable::Populate(
    const base::Value::Dict& dict, ExternallyConnectable& out, std::u16string& error) { … }

// static
bool ExternallyConnectable::Populate(
    const base::Value& value, ExternallyConnectable& out, std::u16string& error) { … }

// static
base::expected<ExternallyConnectable, std::u16string> ExternallyConnectable::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<ExternallyConnectable, std::u16string> ExternallyConnectable::FromValue(const base::Value& value) { … }

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


OptionsUI::OptionsUI()
 { … }

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

// static
bool OptionsUI::Populate(
    const base::Value::Dict& dict, OptionsUI& out, std::u16string& error) { … }

// static
bool OptionsUI::Populate(
    const base::Value& value, OptionsUI& out, std::u16string& error) { … }

// static
base::expected<OptionsUI, std::u16string> OptionsUI::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<OptionsUI, std::u16string> OptionsUI::FromValue(const base::Value& value) { … }

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


SocketHostPatterns::SocketHostPatterns()
 { … }

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

// static
bool SocketHostPatterns::Populate(
    const base::Value& value, SocketHostPatterns& out, std::u16string& error) { … }

// static
base::expected<SocketHostPatterns, std::u16string> SocketHostPatterns::FromValue(const base::Value& value) { … }

base::Value SocketHostPatterns::ToValue() const { … }


Sockets::Udp::Udp()
 { … }

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

// static
bool Sockets::Udp::Populate(
    const base::Value::Dict& dict, Udp& out, std::u16string& error) { … }

// static
bool Sockets::Udp::Populate(
    const base::Value& value, Udp& out, std::u16string& error) { … }

// static
base::expected<Sockets::Udp, std::u16string> Sockets::Udp::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Sockets::Udp, std::u16string> Sockets::Udp::FromValue(const base::Value& value) { … }

base::Value::Dict Sockets::Udp::ToValue() const { … }


Sockets::Tcp::Tcp()
 { … }

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

// static
bool Sockets::Tcp::Populate(
    const base::Value::Dict& dict, Tcp& out, std::u16string& error) { … }

// static
bool Sockets::Tcp::Populate(
    const base::Value& value, Tcp& out, std::u16string& error) { … }

// static
base::expected<Sockets::Tcp, std::u16string> Sockets::Tcp::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Sockets::Tcp, std::u16string> Sockets::Tcp::FromValue(const base::Value& value) { … }

base::Value::Dict Sockets::Tcp::ToValue() const { … }


Sockets::TcpServer::TcpServer()
 { … }

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

// static
bool Sockets::TcpServer::Populate(
    const base::Value::Dict& dict, TcpServer& out, std::u16string& error) { … }

// static
bool Sockets::TcpServer::Populate(
    const base::Value& value, TcpServer& out, std::u16string& error) { … }

// static
base::expected<Sockets::TcpServer, std::u16string> Sockets::TcpServer::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Sockets::TcpServer, std::u16string> Sockets::TcpServer::FromValue(const base::Value& value) { … }

base::Value::Dict Sockets::TcpServer::ToValue() const { … }



Sockets::Sockets()
 { … }

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

// static
bool Sockets::Populate(
    const base::Value::Dict& dict, Sockets& out, std::u16string& error) { … }

// static
bool Sockets::Populate(
    const base::Value& value, Sockets& out, std::u16string& error) { … }

// static
base::expected<Sockets, std::u16string> Sockets::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Sockets, std::u16string> Sockets::FromValue(const base::Value& value) { … }

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


Bluetooth::Bluetooth()
 { … }

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

// static
bool Bluetooth::Populate(
    const base::Value::Dict& dict, Bluetooth& out, std::u16string& error) { … }

// static
bool Bluetooth::Populate(
    const base::Value& value, Bluetooth& out, std::u16string& error) { … }

// static
base::expected<Bluetooth, std::u16string> Bluetooth::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Bluetooth, std::u16string> Bluetooth::FromValue(const base::Value& value) { … }

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


UsbPrinters::FiltersType::FiltersType()
: … { … }

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

// static
bool UsbPrinters::FiltersType::Populate(
    const base::Value::Dict& dict, FiltersType& out, std::u16string& error) { … }

// static
bool UsbPrinters::FiltersType::Populate(
    const base::Value& value, FiltersType& out, std::u16string& error) { … }

// static
base::expected<UsbPrinters::FiltersType, std::u16string> UsbPrinters::FiltersType::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<UsbPrinters::FiltersType, std::u16string> UsbPrinters::FiltersType::FromValue(const base::Value& value) { … }

base::Value::Dict UsbPrinters::FiltersType::ToValue() const { … }




UsbPrinters::UsbPrinters()
 { … }

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

// static
bool UsbPrinters::Populate(
    const base::Value::Dict& dict, UsbPrinters& out, std::u16string& error) { … }

// static
bool UsbPrinters::Populate(
    const base::Value& value, UsbPrinters& out, std::u16string& error) { … }

// static
base::expected<UsbPrinters, std::u16string> UsbPrinters::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<UsbPrinters, std::u16string> UsbPrinters::FromValue(const base::Value& value) { … }

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


KioskSecondaryAppsType::KioskSecondaryAppsType()
 { … }

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

// static
bool KioskSecondaryAppsType::Populate(
    const base::Value::Dict& dict, KioskSecondaryAppsType& out, std::u16string& error) { … }

// static
bool KioskSecondaryAppsType::Populate(
    const base::Value& value, KioskSecondaryAppsType& out, std::u16string& error) { … }

// static
base::expected<KioskSecondaryAppsType, std::u16string> KioskSecondaryAppsType::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<KioskSecondaryAppsType, std::u16string> KioskSecondaryAppsType::FromValue(const base::Value& value) { … }

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




}  // namespace extensions_manifest_types
}  // namespace api
}  // namespace extensions