llvm/lldb/source/Host/common/XML.cpp

//===-- XML.cpp -----------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Host/Config.h"
#include "lldb/Host/XML.h"

#include "llvm/ADT/StringExtras.h"

usingnamespacelldb;
usingnamespacelldb_private;

#pragma mark-- XMLDocument

XMLDocument::XMLDocument() = default;

XMLDocument::~XMLDocument() { … }

void XMLDocument::Clear() { … }

bool XMLDocument::IsValid() const { … }

void XMLDocument::ErrorCallback(void *ctx, const char *format, ...) { … }

bool XMLDocument::ParseFile(const char *path) { … }

bool XMLDocument::ParseMemory(const char *xml, size_t xml_length,
                              const char *url) { … }

XMLNode XMLDocument::GetRootElement(const char *required_name) { … }

llvm::StringRef XMLDocument::GetErrors() const { … }

bool XMLDocument::XMLEnabled() { … }

#pragma mark-- XMLNode

XMLNode::XMLNode() = default;

XMLNode::XMLNode(XMLNodeImpl node) : … { … }

XMLNode::~XMLNode() = default;

void XMLNode::Clear() { … }

XMLNode XMLNode::GetParent() const { … }

XMLNode XMLNode::GetSibling() const { … }

XMLNode XMLNode::GetChild() const { … }

std::string XMLNode::GetAttributeValue(const char *name,
                                       const char *fail_value) const { … }

bool XMLNode::GetAttributeValueAsUnsigned(const char *name, uint64_t &value,
                                          uint64_t fail_value, int base) const { … }

void XMLNode::ForEachChildNode(NodeCallback const &callback) const { … }

void XMLNode::ForEachChildElement(NodeCallback const &callback) const { … }

void XMLNode::ForEachChildElementWithName(const char *name,
                                          NodeCallback const &callback) const { … }

void XMLNode::ForEachAttribute(AttributeCallback const &callback) const { … }

void XMLNode::ForEachSiblingNode(NodeCallback const &callback) const { … }

void XMLNode::ForEachSiblingElement(NodeCallback const &callback) const { … }

void XMLNode::ForEachSiblingElementWithName(
    const char *name, NodeCallback const &callback) const { … }

llvm::StringRef XMLNode::GetName() const { … }

bool XMLNode::GetElementText(std::string &text) const { … }

bool XMLNode::GetElementTextAsUnsigned(uint64_t &value, uint64_t fail_value,
                                       int base) const { … }

bool XMLNode::GetElementTextAsFloat(double &value, double fail_value) const { … }

bool XMLNode::NameIs(const char *name) const { … }

XMLNode XMLNode::FindFirstChildElementWithName(const char *name) const { … }

bool XMLNode::IsValid() const { … }

bool XMLNode::IsElement() const { … }

XMLNode XMLNode::GetElementForPath(const NamePath &path) { … }

#pragma mark-- ApplePropertyList

ApplePropertyList::ApplePropertyList() : … { … }

ApplePropertyList::ApplePropertyList(const char *path)
    : … { … }

ApplePropertyList::~ApplePropertyList() = default;

llvm::StringRef ApplePropertyList::GetErrors() const { … }

bool ApplePropertyList::ParseFile(const char *path) { … }

bool ApplePropertyList::IsValid() const { … }

bool ApplePropertyList::GetValueAsString(const char *key,
                                         std::string &value) const { … }

XMLNode ApplePropertyList::GetValueNode(const char *key) const { … }

bool ApplePropertyList::ExtractStringFromValueNode(const XMLNode &node,
                                                   std::string &value) { … }

#if LLDB_ENABLE_LIBXML2

static StructuredData::ObjectSP CreatePlistValue(XMLNode node) { … }
#endif

StructuredData::ObjectSP ApplePropertyList::GetStructuredData() { … }