xref: /aosp_15_r20/out/soong/.intermediates/system/libvintf/xsd/halManifest/hal_manifest/gen/cpp/hal_manifest.cpp

#define LOG_TAG "hal.manifest"
#include "hal_manifest.h"

#include <assert.h>
#ifndef __BIONIC__
#define __assert2(f,n,fun,e) do { fprintf(stderr, "%s:%d: %s: Assertion `%s' failed", (f), (n), (fun), (e)); abort(); } while (false)
#endif
#define _xsdc_assert(e) do if (!(e)) __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, #e); while (false)

namespace hal {
    namespace manifest {
        template <class T>
        constexpr void (*xmlDeleter)(T* t);
        template <>
        constexpr auto xmlDeleter<xmlDoc> = xmlFreeDoc;
        template <>
        auto xmlDeleter<xmlChar> = [](xmlChar *s) { xmlFree(s); };

        template <class T>
        constexpr auto make_xmlUnique(T *t) {
            auto deleter = [](T *t) { xmlDeleter<T>(t); };
            return std::unique_ptr<T, decltype(deleter)>{t, deleter};
        }

        static std::string getXmlAttribute(const xmlNode *cur, const char *attribute) {
            auto xmlValue = make_xmlUnique(xmlGetProp(cur, reinterpret_cast<const xmlChar*>(attribute)));
            if (xmlValue == nullptr) {
                return "";
            }
            std::string value(reinterpret_cast<const char*>(xmlValue.get()));
            return value;
        }

        std::optional<Manifest> read(const char* configFile) {
            auto doc = make_xmlUnique(xmlParseFile(configFile));
            if (doc == nullptr) {
                return std::nullopt;
            }
            xmlNodePtr _child = xmlDocGetRootElement(doc.get());
            if (_child == nullptr) {
                return std::nullopt;
            }
            if (xmlXIncludeProcess(doc.get()) < 0) {
                return std::nullopt;
            }

            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("manifest"))) {
                Manifest _value = Manifest::read(_child);
                return _value;
            }
            return std::nullopt;
        }

        std::optional<Manifest> parse(const char* xml) {
            auto doc = make_xmlUnique(xmlParseDoc(reinterpret_cast<const xmlChar*>(xml)));
            if (doc == nullptr) {
                return std::nullopt;
            }
            xmlNodePtr _child = xmlDocGetRootElement(doc.get());
            if (_child == nullptr) {
                return std::nullopt;
            }
            if (xmlXIncludeProcess(doc.get()) < 0) {
                return std::nullopt;
            }

            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("manifest"))) {
                Manifest _value = Manifest::read(_child);
                return _value;
            }
            return std::nullopt;
        }


        Hal::Transport::Transport(std::optional<std::string> arch, std::optional<std::string> ip, std::optional<std::string> port, std::string value) : arch_(std::move(arch)), ip_(std::move(ip)), port_(std::move(port)), value_(value) {
        }

        const std::string& Hal::Transport::getArch() const {
            _xsdc_assert(hasArch());
            return arch_.value();
        }

        bool Hal::Transport::hasArch() const {
            return arch_.has_value();
        }

        const std::string& Hal::Transport::getIp() const {
            _xsdc_assert(hasIp());
            return ip_.value();
        }

        bool Hal::Transport::hasIp() const {
            return ip_.has_value();
        }

        const std::string& Hal::Transport::getPort() const {
            _xsdc_assert(hasPort());
            return port_.value();
        }

        bool Hal::Transport::hasPort() const {
            return port_.has_value();
        }

        const std::string& Hal::Transport::getValue() const {
            _xsdc_assert(hasValue());
            return value_.value();
        }

        bool Hal::Transport::hasValue() const {
            return value_.has_value();
        }

        Hal::Transport Hal::Transport::read(xmlNode *root) {
            std::string _raw;
            _raw = getXmlAttribute(root, "arch");
            std::optional<std::string> arch = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                arch = _value;
            }
            _raw = getXmlAttribute(root, "ip");
            std::optional<std::string> ip = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                ip = _value;
            }
            _raw = getXmlAttribute(root, "port");
            std::optional<std::string> port = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                port = _value;
            }
            auto xmlValue = make_xmlUnique(xmlNodeListGetString(root->doc, root->xmlChildrenNode, 1));
            if (xmlValue == nullptr) {
                _raw = "";
            } else {
                _raw = reinterpret_cast<const char*>(xmlValue.get());
            }
            std::string &_value = _raw;
            Hal::Transport instance(arch, ip, port, _value);
            return instance;
        }

        Hal::Hal(std::optional<std::string> name, std::vector<Transport> transport, std::vector<std::string> version, std::vector<Interface> interface, std::vector<std::string> fqname, std::vector<std::string> accessor, std::optional<std::string> format, std::optional<std::string> exclusiveTo, std::optional<std::string> override, std::optional<std::string> updatableViaApex, std::optional<std::string> updatableViaSystem, std::optional<std::string> maxLevel, std::optional<std::string> minLevel) : name_(std::move(name)), transport_(std::move(transport)), version_(std::move(version)), interface_(std::move(interface)), fqname_(std::move(fqname)), accessor_(std::move(accessor)), format_(std::move(format)), exclusiveTo_(std::move(exclusiveTo)), override_(std::move(override)), updatableViaApex_(std::move(updatableViaApex)), updatableViaSystem_(std::move(updatableViaSystem)), maxLevel_(std::move(maxLevel)), minLevel_(std::move(minLevel)) {
        }

        const std::string& Hal::getName() const {
            _xsdc_assert(hasName());
            return name_.value();
        }

        bool Hal::hasName() const {
            return name_.has_value();
        }

        const std::vector<Hal::Transport>& Hal::getTransport() const {
            return transport_;
        }

        bool Hal::hasTransport() const {
            return !(transport_.empty());
        }

        const Hal::Transport* Hal::getFirstTransport() const {
            if (transport_.empty()) {
                return nullptr;
            }
            return &transport_[0];
        }

        const std::vector<std::string>& Hal::getVersion() const {
            return version_;
        }

        bool Hal::hasVersion() const {
            return !(version_.empty());
        }

        const std::string* Hal::getFirstVersion() const {
            if (version_.empty()) {
                return nullptr;
            }
            return &version_[0];
        }

        const std::vector<Interface>& Hal::getInterface() const {
            return interface_;
        }

        bool Hal::hasInterface() const {
            return !(interface_.empty());
        }

        const Interface* Hal::getFirstInterface() const {
            if (interface_.empty()) {
                return nullptr;
            }
            return &interface_[0];
        }

        const std::vector<std::string>& Hal::getFqname() const {
            return fqname_;
        }

        bool Hal::hasFqname() const {
            return !(fqname_.empty());
        }

        const std::string* Hal::getFirstFqname() const {
            if (fqname_.empty()) {
                return nullptr;
            }
            return &fqname_[0];
        }

        const std::vector<std::string>& Hal::getAccessor() const {
            return accessor_;
        }

        bool Hal::hasAccessor() const {
            return !(accessor_.empty());
        }

        const std::string* Hal::getFirstAccessor() const {
            if (accessor_.empty()) {
                return nullptr;
            }
            return &accessor_[0];
        }

        const std::string& Hal::getFormat() const {
            _xsdc_assert(hasFormat());
            return format_.value();
        }

        bool Hal::hasFormat() const {
            return format_.has_value();
        }

        const std::string& Hal::getExclusiveTo() const {
            _xsdc_assert(hasExclusiveTo());
            return exclusiveTo_.value();
        }

        bool Hal::hasExclusiveTo() const {
            return exclusiveTo_.has_value();
        }

        const std::string& Hal::getOverride() const {
            _xsdc_assert(hasOverride());
            return override_.value();
        }

        bool Hal::hasOverride() const {
            return override_.has_value();
        }

        const std::string& Hal::getUpdatableViaApex() const {
            _xsdc_assert(hasUpdatableViaApex());
            return updatableViaApex_.value();
        }

        bool Hal::hasUpdatableViaApex() const {
            return updatableViaApex_.has_value();
        }

        const std::string& Hal::getUpdatableViaSystem() const {
            _xsdc_assert(hasUpdatableViaSystem());
            return updatableViaSystem_.value();
        }

        bool Hal::hasUpdatableViaSystem() const {
            return updatableViaSystem_.has_value();
        }

        const std::string& Hal::getMaxLevel() const {
            _xsdc_assert(hasMaxLevel());
            return maxLevel_.value();
        }

        bool Hal::hasMaxLevel() const {
            return maxLevel_.has_value();
        }

        const std::string& Hal::getMinLevel() const {
            _xsdc_assert(hasMinLevel());
            return minLevel_.value();
        }

        bool Hal::hasMinLevel() const {
            return minLevel_.has_value();
        }

        Hal Hal::read(xmlNode *root) {
            std::string _raw;
            _raw = getXmlAttribute(root, "format");
            std::optional<std::string> format = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                format = _value;
            }
            _raw = getXmlAttribute(root, "exclusive-to");
            std::optional<std::string> exclusiveTo = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                exclusiveTo = _value;
            }
            _raw = getXmlAttribute(root, "override");
            std::optional<std::string> override = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                override = _value;
            }
            _raw = getXmlAttribute(root, "updatable-via-apex");
            std::optional<std::string> updatableViaApex = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                updatableViaApex = _value;
            }
            _raw = getXmlAttribute(root, "updatable-via-system");
            std::optional<std::string> updatableViaSystem = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                updatableViaSystem = _value;
            }
            _raw = getXmlAttribute(root, "max-level");
            std::optional<std::string> maxLevel = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                maxLevel = _value;
            }
            _raw = getXmlAttribute(root, "min-level");
            std::optional<std::string> minLevel = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                minLevel = _value;
            }
            std::optional<std::string> name;
            std::vector<Transport> transport;
            std::vector<std::string> version;
            std::vector<Interface> interface;
            std::vector<std::string> fqname;
            std::vector<std::string> accessor;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("name"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    name = std::move(_value);
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("transport"))) {
                    Transport _value = Transport::read(_child);
                    transport.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("version"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    version.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("interface"))) {
                    Interface _value = Interface::read(_child);
                    interface.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fqname"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    fqname.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("accessor"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    accessor.push_back(std::move(_value));
                }
            }
            Hal instance(name, transport, version, interface, fqname, accessor, format, exclusiveTo, override, updatableViaApex, updatableViaSystem, maxLevel, minLevel);
            return instance;
        }

        Interface::Interface(std::optional<std::string> name, std::vector<std::string> instance) : name_(std::move(name)), instance_(std::move(instance)) {
        }

        const std::string& Interface::getName() const {
            _xsdc_assert(hasName());
            return name_.value();
        }

        bool Interface::hasName() const {
            return name_.has_value();
        }

        const std::vector<std::string>& Interface::getInstance() const {
            return instance_;
        }

        bool Interface::hasInstance() const {
            return !(instance_.empty());
        }

        const std::string* Interface::getFirstInstance() const {
            if (instance_.empty()) {
                return nullptr;
            }
            return &instance_[0];
        }

        Interface Interface::read(xmlNode *root) {
            std::string _raw;
            std::optional<std::string> name;
            std::vector<std::string> instance;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("name"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    name = std::move(_value);
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("instance"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    instance.push_back(std::move(_value));
                }
            }
            Interface instance(name, instance);
            return instance;
        }

        Sepolicy::Sepolicy(std::optional<std::string> version) : version_(std::move(version)) {
        }

        const std::string& Sepolicy::getVersion() const {
            _xsdc_assert(hasVersion());
            return version_.value();
        }

        bool Sepolicy::hasVersion() const {
            return version_.has_value();
        }

        Sepolicy Sepolicy::read(xmlNode *root) {
            std::string _raw;
            std::optional<std::string> version;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("version"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    version = std::move(_value);
                }
            }
            Sepolicy instance(version);
            return instance;
        }

        Vndk::Vndk(std::optional<std::string> version, std::vector<std::string> library) : version_(std::move(version)), library_(std::move(library)) {
        }

        const std::string& Vndk::getVersion() const {
            _xsdc_assert(hasVersion());
            return version_.value();
        }

        bool Vndk::hasVersion() const {
            return version_.has_value();
        }

        const std::vector<std::string>& Vndk::getLibrary() const {
            return library_;
        }

        bool Vndk::hasLibrary() const {
            return !(library_.empty());
        }

        const std::string* Vndk::getFirstLibrary() const {
            if (library_.empty()) {
                return nullptr;
            }
            return &library_[0];
        }

        Vndk Vndk::read(xmlNode *root) {
            std::string _raw;
            std::optional<std::string> version;
            std::vector<std::string> library;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("version"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    version = std::move(_value);
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("library"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    library.push_back(std::move(_value));
                }
            }
            Vndk instance(version, library);
            return instance;
        }

        VendorNdk::VendorNdk(std::optional<std::string> version, std::vector<std::string> library) : version_(std::move(version)), library_(std::move(library)) {
        }

        const std::string& VendorNdk::getVersion() const {
            _xsdc_assert(hasVersion());
            return version_.value();
        }

        bool VendorNdk::hasVersion() const {
            return version_.has_value();
        }

        const std::vector<std::string>& VendorNdk::getLibrary() const {
            return library_;
        }

        bool VendorNdk::hasLibrary() const {
            return !(library_.empty());
        }

        const std::string* VendorNdk::getFirstLibrary() const {
            if (library_.empty()) {
                return nullptr;
            }
            return &library_[0];
        }

        VendorNdk VendorNdk::read(xmlNode *root) {
            std::string _raw;
            std::optional<std::string> version;
            std::vector<std::string> library;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("version"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    version = std::move(_value);
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("library"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    library.push_back(std::move(_value));
                }
            }
            VendorNdk instance(version, library);
            return instance;
        }

        SystemSdk::SystemSdk(std::vector<std::string> version) : version_(std::move(version)) {
        }

        const std::vector<std::string>& SystemSdk::getVersion() const {
            return version_;
        }

        bool SystemSdk::hasVersion() const {
            return !(version_.empty());
        }

        const std::string* SystemSdk::getFirstVersion() const {
            if (version_.empty()) {
                return nullptr;
            }
            return &version_[0];
        }

        SystemSdk SystemSdk::read(xmlNode *root) {
            std::string _raw;
            std::vector<std::string> version;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("version"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    version.push_back(std::move(_value));
                }
            }
            SystemSdk instance(version);
            return instance;
        }

        Kernel::Config::Config(std::optional<std::string> key, std::optional<std::string> value) : key_(std::move(key)), value_(std::move(value)) {
        }

        const std::string& Kernel::Config::getKey() const {
            _xsdc_assert(hasKey());
            return key_.value();
        }

        bool Kernel::Config::hasKey() const {
            return key_.has_value();
        }

        const std::string& Kernel::Config::getValue() const {
            _xsdc_assert(hasValue());
            return value_.value();
        }

        bool Kernel::Config::hasValue() const {
            return value_.has_value();
        }

        Kernel::Config Kernel::Config::read(xmlNode *root) {
            std::string _raw;
            std::optional<std::string> key;
            std::optional<std::string> value;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("key"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    key = std::move(_value);
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("value"))) {
                    auto xmlValue = make_xmlUnique(xmlNodeListGetString(_child->doc, _child->xmlChildrenNode, 1));
                    if (xmlValue == nullptr) {
                        _raw = "";
                    } else {
                        _raw = reinterpret_cast<const char*>(xmlValue.get());
                    }
                    std::string &_value = _raw;
                    value = std::move(_value);
                }
            }
            Kernel::Config instance(key, value);
            return instance;
        }

        Kernel::Kernel(std::vector<Config> config, std::optional<std::string> version, std::optional<std::string> targetLevel) : config_(std::move(config)), version_(std::move(version)), targetLevel_(std::move(targetLevel)) {
        }

        const std::vector<Kernel::Config>& Kernel::getConfig() const {
            return config_;
        }

        bool Kernel::hasConfig() const {
            return !(config_.empty());
        }

        const Kernel::Config* Kernel::getFirstConfig() const {
            if (config_.empty()) {
                return nullptr;
            }
            return &config_[0];
        }

        const std::string& Kernel::getVersion() const {
            _xsdc_assert(hasVersion());
            return version_.value();
        }

        bool Kernel::hasVersion() const {
            return version_.has_value();
        }

        const std::string& Kernel::getTargetLevel() const {
            _xsdc_assert(hasTargetLevel());
            return targetLevel_.value();
        }

        bool Kernel::hasTargetLevel() const {
            return targetLevel_.has_value();
        }

        Kernel Kernel::read(xmlNode *root) {
            std::string _raw;
            _raw = getXmlAttribute(root, "version");
            std::optional<std::string> version = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                version = _value;
            }
            _raw = getXmlAttribute(root, "target-level");
            std::optional<std::string> targetLevel = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                targetLevel = _value;
            }
            std::vector<Config> config;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("config"))) {
                    Config _value = Config::read(_child);
                    config.push_back(std::move(_value));
                }
            }
            Kernel instance(config, version, targetLevel);
            return instance;
        }

        Manifest::Manifest(std::vector<Hal> hal, std::vector<Sepolicy> sepolicy, std::vector<Kernel> kernel, std::vector<Vndk> vndk, std::vector<VendorNdk> vendorNdk, std::vector<SystemSdk> systemSdk, std::string version, std::string type, std::optional<std::string> targetLevel) : hal_(std::move(hal)), sepolicy_(std::move(sepolicy)), kernel_(std::move(kernel)), vndk_(std::move(vndk)), vendorNdk_(std::move(vendorNdk)), systemSdk_(std::move(systemSdk)), version_(std::move(version)), type_(std::move(type)), targetLevel_(std::move(targetLevel)) {
        }

        const std::vector<Hal>& Manifest::getHal() const {
            return hal_;
        }

        bool Manifest::hasHal() const {
            return !(hal_.empty());
        }

        const Hal* Manifest::getFirstHal() const {
            if (hal_.empty()) {
                return nullptr;
            }
            return &hal_[0];
        }

        const std::vector<Sepolicy>& Manifest::getSepolicy() const {
            return sepolicy_;
        }

        bool Manifest::hasSepolicy() const {
            return !(sepolicy_.empty());
        }

        const Sepolicy* Manifest::getFirstSepolicy() const {
            if (sepolicy_.empty()) {
                return nullptr;
            }
            return &sepolicy_[0];
        }

        const std::vector<Kernel>& Manifest::getKernel() const {
            return kernel_;
        }

        bool Manifest::hasKernel() const {
            return !(kernel_.empty());
        }

        const Kernel* Manifest::getFirstKernel() const {
            if (kernel_.empty()) {
                return nullptr;
            }
            return &kernel_[0];
        }

        const std::vector<Vndk>& Manifest::getVndk() const {
            return vndk_;
        }

        bool Manifest::hasVndk() const {
            return !(vndk_.empty());
        }

        const Vndk* Manifest::getFirstVndk() const {
            if (vndk_.empty()) {
                return nullptr;
            }
            return &vndk_[0];
        }

        const std::vector<VendorNdk>& Manifest::getVendorNdk() const {
            return vendorNdk_;
        }

        bool Manifest::hasVendorNdk() const {
            return !(vendorNdk_.empty());
        }

        const VendorNdk* Manifest::getFirstVendorNdk() const {
            if (vendorNdk_.empty()) {
                return nullptr;
            }
            return &vendorNdk_[0];
        }

        const std::vector<SystemSdk>& Manifest::getSystemSdk() const {
            return systemSdk_;
        }

        bool Manifest::hasSystemSdk() const {
            return !(systemSdk_.empty());
        }

        const SystemSdk* Manifest::getFirstSystemSdk() const {
            if (systemSdk_.empty()) {
                return nullptr;
            }
            return &systemSdk_[0];
        }

        const std::string& Manifest::getVersion() const {
            return version_;
        }

        bool Manifest::hasVersion() const {
            return true;
        }

        const std::string& Manifest::getType() const {
            return type_;
        }

        bool Manifest::hasType() const {
            return true;
        }

        const std::string& Manifest::getTargetLevel() const {
            _xsdc_assert(hasTargetLevel());
            return targetLevel_.value();
        }

        bool Manifest::hasTargetLevel() const {
            return targetLevel_.has_value();
        }

        Manifest Manifest::read(xmlNode *root) {
            std::string _raw;
            _raw = getXmlAttribute(root, "version");
            std::string version{};
            if (_raw != "") {
                std::string &_value = _raw;
                version = _value;
            }
            _raw = getXmlAttribute(root, "type");
            std::string type{};
            if (_raw != "") {
                std::string &_value = _raw;
                type = _value;
            }
            _raw = getXmlAttribute(root, "target-level");
            std::optional<std::string> targetLevel = std::nullopt;
            if (_raw != "") {
                std::string &_value = _raw;
                targetLevel = _value;
            }
            std::vector<Hal> hal;
            std::vector<Sepolicy> sepolicy;
            std::vector<Kernel> kernel;
            std::vector<Vndk> vndk;
            std::vector<VendorNdk> vendorNdk;
            std::vector<SystemSdk> systemSdk;
            for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("hal"))) {
                    Hal _value = Hal::read(_child);
                    hal.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("sepolicy"))) {
                    Sepolicy _value = Sepolicy::read(_child);
                    sepolicy.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("kernel"))) {
                    Kernel _value = Kernel::read(_child);
                    kernel.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("vndk"))) {
                    Vndk _value = Vndk::read(_child);
                    vndk.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("vendor-ndk"))) {
                    VendorNdk _value = VendorNdk::read(_child);
                    vendorNdk.push_back(std::move(_value));
                } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("system-sdk"))) {
                    SystemSdk _value = SystemSdk::read(_child);
                    systemSdk.push_back(std::move(_value));
                }
            }
            Manifest instance(hal, sepolicy, kernel, vndk, vendorNdk, systemSdk, version, type, targetLevel);
            return instance;
        }
    } // manifest
} // hal