automation.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/automation.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

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

const char* ToString(EventType enum_param) { … }

EventType ParseEventType(std::string_view enum_string) { … }

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


const char* ToString(RoleType enum_param) { … }

RoleType ParseRoleType(std::string_view enum_string) { … }

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


const char* ToString(StateType enum_param) { … }

StateType ParseStateType(std::string_view enum_string) { … }

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


const char* ToString(ActionType enum_param) { … }

ActionType ParseActionType(std::string_view enum_string) { … }

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


const char* ToString(TreeChangeType enum_param) { … }

TreeChangeType ParseTreeChangeType(std::string_view enum_string) { … }

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


const char* ToString(NameFromType enum_param) { … }

NameFromType ParseNameFromType(std::string_view enum_string) { … }

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


const char* ToString(DescriptionFromType enum_param) { … }

DescriptionFromType ParseDescriptionFromType(std::string_view enum_string) { … }

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


const char* ToString(Restriction enum_param) { … }

Restriction ParseRestriction(std::string_view enum_string) { … }

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


const char* ToString(HasPopup enum_param) { … }

HasPopup ParseHasPopup(std::string_view enum_string) { … }

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


const char* ToString(AriaCurrentState enum_param) { … }

AriaCurrentState ParseAriaCurrentState(std::string_view enum_string) { … }

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


const char* ToString(InvalidState enum_param) { … }

InvalidState ParseInvalidState(std::string_view enum_string) { … }

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


const char* ToString(DefaultActionVerb enum_param) { … }

DefaultActionVerb ParseDefaultActionVerb(std::string_view enum_string) { … }

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


const char* ToString(MarkerType enum_param) { … }

MarkerType ParseMarkerType(std::string_view enum_string) { … }

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


const char* ToString(IntentCommandType enum_param) { … }

IntentCommandType ParseIntentCommandType(std::string_view enum_string) { … }

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


const char* ToString(IntentInputEventType enum_param) { … }

IntentInputEventType ParseIntentInputEventType(std::string_view enum_string) { … }

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


const char* ToString(IntentTextBoundaryType enum_param) { … }

IntentTextBoundaryType ParseIntentTextBoundaryType(std::string_view enum_string) { … }

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


const char* ToString(IntentMoveDirectionType enum_param) { … }

IntentMoveDirectionType ParseIntentMoveDirectionType(std::string_view enum_string) { … }

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


const char* ToString(SortDirectionType enum_param) { … }

SortDirectionType ParseSortDirectionType(std::string_view enum_string) { … }

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


const char* ToString(PositionType enum_param) { … }

PositionType ParsePositionType(std::string_view enum_string) { … }

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


Rect::Rect()
: … { … }

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

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

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

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

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

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


FindParams::FindParams()
 { … }

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

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

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

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

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

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


SetDocumentSelectionParams::SetDocumentSelectionParams()
 { … }

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

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

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

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

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

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


AutomationIntent::AutomationIntent()
 { … }

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

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

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

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

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

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


AutomationEvent::AutomationEvent()
 { … }

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

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

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

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

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

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


TreeChange::TreeChange()
 { … }

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

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

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

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

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

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


const char* ToString(TreeChangeObserverFilter enum_param) { … }

TreeChangeObserverFilter ParseTreeChangeObserverFilter(std::string_view enum_string) { … }

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


CustomAction::CustomAction()
 { … }

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

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

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

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

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

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


Marker::Marker()
 { … }

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

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

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

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

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

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


AutomationPosition::AutomationPosition()
 { … }

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

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

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

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

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

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


AutomationNode::AutomationNode()
 { … }

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

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

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

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

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

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



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