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

#include "extensions/common/api/bluetooth_low_energy.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 bluetooth_low_energy {
//
// Types
//

const char* ToString(CharacteristicProperty enum_param) { … }

CharacteristicProperty ParseCharacteristicProperty(std::string_view enum_string) { … }

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


const char* ToString(DescriptorPermission enum_param) { … }

DescriptorPermission ParseDescriptorPermission(std::string_view enum_string) { … }

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


const char* ToString(AdvertisementType enum_param) { … }

AdvertisementType ParseAdvertisementType(std::string_view enum_string) { … }

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


Device::Device()
 { … }

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

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

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

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

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

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


Service::Service()
: … { … }

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

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

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

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

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

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


Characteristic::Characteristic()
 { … }

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

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

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

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

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

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


Descriptor::Descriptor()
 { … }

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

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

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

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

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

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


ConnectProperties::ConnectProperties()
: … { … }

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

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

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

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

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

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


NotificationProperties::NotificationProperties()
: … { … }

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

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

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

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

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

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


ManufacturerData::ManufacturerData()
: … { … }

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

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

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

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

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

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


ServiceData::ServiceData()
 { … }

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

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

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

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

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

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


Advertisement::Advertisement()
: … { … }

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

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

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

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

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

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


Request::Request()
: … { … }

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

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

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

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

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

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


Response::Response()
: … { … }

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

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

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

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

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

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


Notification::Notification()
 { … }

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

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

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

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

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

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



//
// Functions
//

namespace Connect {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace Connect

namespace Disconnect {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace Disconnect

namespace GetService {

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) { … }


base::Value::List Results::Create(const Service& result) { … }
}  // namespace GetService

namespace CreateService {

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) { … }


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

namespace GetServices {

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) { … }


base::Value::List Results::Create(const std::vector<Service>& result) { … }
}  // namespace GetServices

namespace GetCharacteristic {

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) { … }


base::Value::List Results::Create(const Characteristic& result) { … }
}  // namespace GetCharacteristic

namespace CreateCharacteristic {

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) { … }


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

namespace GetCharacteristics {

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) { … }


base::Value::List Results::Create(const std::vector<Characteristic>& result) { … }
}  // namespace GetCharacteristics

namespace GetIncludedServices {

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) { … }


base::Value::List Results::Create(const std::vector<Service>& result) { … }
}  // namespace GetIncludedServices

namespace GetDescriptor {

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) { … }


base::Value::List Results::Create(const Descriptor& result) { … }
}  // namespace GetDescriptor

namespace CreateDescriptor {

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) { … }


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

namespace GetDescriptors {

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) { … }


base::Value::List Results::Create(const std::vector<Descriptor>& result) { … }
}  // namespace GetDescriptors

namespace ReadCharacteristicValue {

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) { … }


base::Value::List Results::Create(const Characteristic& result) { … }
}  // namespace ReadCharacteristicValue

namespace WriteCharacteristicValue {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace WriteCharacteristicValue

namespace StartCharacteristicNotifications {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace StartCharacteristicNotifications

namespace StopCharacteristicNotifications {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace StopCharacteristicNotifications

namespace NotifyCharacteristicValueChanged {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace NotifyCharacteristicValueChanged

namespace ReadDescriptorValue {

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) { … }


base::Value::List Results::Create(const Descriptor& result) { … }
}  // namespace ReadDescriptorValue

namespace WriteDescriptorValue {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace WriteDescriptorValue

namespace RegisterService {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace RegisterService

namespace UnregisterService {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace UnregisterService

namespace RemoveService {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace RemoveService

namespace RegisterAdvertisement {

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) { … }


base::Value::List Results::Create(int advertisement_id) { … }
}  // namespace RegisterAdvertisement

namespace UnregisterAdvertisement {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace UnregisterAdvertisement

namespace ResetAdvertising {

base::Value::List Results::Create() { … }
}  // namespace ResetAdvertising

namespace SetAdvertisingInterval {

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) { … }


base::Value::List Results::Create() { … }
}  // namespace SetAdvertisingInterval

namespace SendRequestResponse {

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 SendRequestResponse

//
// Events
//

namespace OnServiceAdded {

const char kEventName[] = …;

base::Value::List Create(const Service& service) { … }

}  // namespace OnServiceAdded

namespace OnServiceChanged {

const char kEventName[] = …;

base::Value::List Create(const Service& service) { … }

}  // namespace OnServiceChanged

namespace OnServiceRemoved {

const char kEventName[] = …;

base::Value::List Create(const Service& service) { … }

}  // namespace OnServiceRemoved

namespace OnCharacteristicValueChanged {

const char kEventName[] = …;

base::Value::List Create(const Characteristic& characteristic) { … }

}  // namespace OnCharacteristicValueChanged

namespace OnDescriptorValueChanged {

const char kEventName[] = …;

base::Value::List Create(const Descriptor& descriptor) { … }

}  // namespace OnDescriptorValueChanged

namespace OnCharacteristicReadRequest {

const char kEventName[] = …;

base::Value::List Create(const Request& request, const std::string& characteristic_id) { … }

}  // namespace OnCharacteristicReadRequest

namespace OnCharacteristicWriteRequest {

const char kEventName[] = …;

base::Value::List Create(const Request& request, const std::string& characteristic_id) { … }

}  // namespace OnCharacteristicWriteRequest

namespace OnDescriptorReadRequest {

const char kEventName[] = …;

base::Value::List Create(const Request& request, const std::string& descriptor_id) { … }

}  // namespace OnDescriptorReadRequest

namespace OnDescriptorWriteRequest {

const char kEventName[] = …;

base::Value::List Create(const Request& request, const std::string& descriptor_id) { … }

}  // namespace OnDescriptorWriteRequest

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