xref: /aosp_15_r20/out/soong/.intermediates/frameworks/base/core/xsd/permission/gen/cpp/com_android_xml_permission_configfile.cpp

#define LOG_TAG "com.android.xml.permission.configfile"
#include "com_android_xml_permission_configfile.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 com {
    namespace android {
        namespace xml {
            namespace permission {
                namespace configfile {
                    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<Permissions> 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*>("permissions"))) {
                            Permissions _value = Permissions::read(_child);
                            return _value;
                        }
                        return std::nullopt;
                    }

                    std::optional<Permissions> 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*>("permissions"))) {
                            Permissions _value = Permissions::read(_child);
                            return _value;
                        }
                        return std::nullopt;
                    }


                    Group::Group(std::optional<int> gid) : gid_(gid) {
                    }

                    const int& Group::getGid() const {
                        _xsdc_assert(hasGid());
                        return gid_.value();
                    }

                    bool Group::hasGid() const {
                        return gid_.has_value();
                    }

                    Group Group::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "gid");
                        std::optional<int> gid = std::nullopt;
                        if (_raw != "") {
                            int _value = std::stoi(_raw);
                            gid = _value;
                        }
                        Group instance(gid);
                        return instance;
                    }

                    Permission::Permission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    Permission Permission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        Permission instance(name);
                        return instance;
                    }

                    AssignPermission::AssignPermission(std::optional<std::string> name, std::optional<int> uid) : name_(std::move(name)), uid_(uid) {
                    }

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

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

                    const int& AssignPermission::getUid() const {
                        _xsdc_assert(hasUid());
                        return uid_.value();
                    }

                    bool AssignPermission::hasUid() const {
                        return uid_.has_value();
                    }

                    AssignPermission AssignPermission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        _raw = getXmlAttribute(root, "uid");
                        std::optional<int> uid = std::nullopt;
                        if (_raw != "") {
                            int _value = std::stoi(_raw);
                            uid = _value;
                        }
                        AssignPermission instance(name, uid);
                        return instance;
                    }

                    SplitPermission::Library::Library(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    SplitPermission::Library SplitPermission::Library::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        SplitPermission::Library instance(name);
                        return instance;
                    }

                    SplitPermission::SplitPermission(std::vector<Library> library, std::optional<std::string> name, std::optional<int> targetSdk) : library_(std::move(library)), name_(std::move(name)), targetSdk_(targetSdk) {
                    }

                    const std::vector<SplitPermission::Library>& SplitPermission::getLibrary() const {
                        return library_;
                    }

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

                    const SplitPermission::Library* SplitPermission::getFirstLibrary() const {
                        if (library_.empty()) {
                            return nullptr;
                        }
                        return &library_[0];
                    }

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

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

                    const int& SplitPermission::getTargetSdk() const {
                        _xsdc_assert(hasTargetSdk());
                        return targetSdk_.value();
                    }

                    bool SplitPermission::hasTargetSdk() const {
                        return targetSdk_.has_value();
                    }

                    SplitPermission SplitPermission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        _raw = getXmlAttribute(root, "targetSdk");
                        std::optional<int> targetSdk = std::nullopt;
                        if (_raw != "") {
                            int _value = std::stoi(_raw);
                            targetSdk = _value;
                        }
                        std::vector<Library> library;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("library"))) {
                                Library _value = Library::read(_child);
                                library.push_back(std::move(_value));
                            }
                        }
                        SplitPermission instance(library, name, targetSdk);
                        return instance;
                    }

                    Library::Library(std::optional<std::string> name, std::optional<std::string> file, std::optional<std::string> dependency) : name_(std::move(name)), file_(std::move(file)), dependency_(std::move(dependency)) {
                    }

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

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

                    const std::string& Library::getFile() const {
                        _xsdc_assert(hasFile());
                        return file_.value();
                    }

                    bool Library::hasFile() const {
                        return file_.has_value();
                    }

                    const std::string& Library::getDependency() const {
                        _xsdc_assert(hasDependency());
                        return dependency_.value();
                    }

                    bool Library::hasDependency() const {
                        return dependency_.has_value();
                    }

                    Library Library::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        _raw = getXmlAttribute(root, "file");
                        std::optional<std::string> file = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            file = _value;
                        }
                        _raw = getXmlAttribute(root, "dependency");
                        std::optional<std::string> dependency = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            dependency = _value;
                        }
                        Library instance(name, file, dependency);
                        return instance;
                    }

                    Feature::Feature(std::optional<std::string> name, std::optional<std::string> notLowRam, std::optional<int> version) : name_(std::move(name)), notLowRam_(std::move(notLowRam)), version_(version) {
                    }

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

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

                    const std::string& Feature::getNotLowRam() const {
                        _xsdc_assert(hasNotLowRam());
                        return notLowRam_.value();
                    }

                    bool Feature::hasNotLowRam() const {
                        return notLowRam_.has_value();
                    }

                    const int& Feature::getVersion() const {
                        _xsdc_assert(hasVersion());
                        return version_.value();
                    }

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

                    Feature Feature::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        _raw = getXmlAttribute(root, "notLowRam");
                        std::optional<std::string> notLowRam = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            notLowRam = _value;
                        }
                        _raw = getXmlAttribute(root, "version");
                        std::optional<int> version = std::nullopt;
                        if (_raw != "") {
                            int _value = std::stoi(_raw);
                            version = _value;
                        }
                        Feature instance(name, notLowRam, version);
                        return instance;
                    }

                    UnavailableFeature::UnavailableFeature(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    UnavailableFeature UnavailableFeature::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        UnavailableFeature instance(name);
                        return instance;
                    }

                    AllowInPowerSaveExceptIdle::AllowInPowerSaveExceptIdle(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AllowInPowerSaveExceptIdle::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AllowInPowerSaveExceptIdle::hasPackage() const {
                        return package_.has_value();
                    }

                    AllowInPowerSaveExceptIdle AllowInPowerSaveExceptIdle::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AllowInPowerSaveExceptIdle instance(package);
                        return instance;
                    }

                    AllowInPowerSave::AllowInPowerSave(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AllowInPowerSave::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AllowInPowerSave::hasPackage() const {
                        return package_.has_value();
                    }

                    AllowInPowerSave AllowInPowerSave::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AllowInPowerSave instance(package);
                        return instance;
                    }

                    AllowInDataUsageSave::AllowInDataUsageSave(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AllowInDataUsageSave::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AllowInDataUsageSave::hasPackage() const {
                        return package_.has_value();
                    }

                    AllowInDataUsageSave AllowInDataUsageSave::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AllowInDataUsageSave instance(package);
                        return instance;
                    }

                    AllowUnthrottledLocation::AllowUnthrottledLocation(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AllowUnthrottledLocation::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AllowUnthrottledLocation::hasPackage() const {
                        return package_.has_value();
                    }

                    AllowUnthrottledLocation AllowUnthrottledLocation::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AllowUnthrottledLocation instance(package);
                        return instance;
                    }

                    AllowIgnoreLocationSettings::AllowIgnoreLocationSettings(std::optional<std::string> package, std::optional<std::string> attributionTag) : package_(std::move(package)), attributionTag_(std::move(attributionTag)) {
                    }

                    const std::string& AllowIgnoreLocationSettings::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AllowIgnoreLocationSettings::hasPackage() const {
                        return package_.has_value();
                    }

                    const std::string& AllowIgnoreLocationSettings::getAttributionTag() const {
                        _xsdc_assert(hasAttributionTag());
                        return attributionTag_.value();
                    }

                    bool AllowIgnoreLocationSettings::hasAttributionTag() const {
                        return attributionTag_.has_value();
                    }

                    AllowIgnoreLocationSettings AllowIgnoreLocationSettings::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        _raw = getXmlAttribute(root, "attributionTag");
                        std::optional<std::string> attributionTag = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            attributionTag = _value;
                        }
                        AllowIgnoreLocationSettings instance(package, attributionTag);
                        return instance;
                    }

                    AllowImplicitBroadcast::AllowImplicitBroadcast(std::optional<std::string> action) : action_(std::move(action)) {
                    }

                    const std::string& AllowImplicitBroadcast::getAction() const {
                        _xsdc_assert(hasAction());
                        return action_.value();
                    }

                    bool AllowImplicitBroadcast::hasAction() const {
                        return action_.has_value();
                    }

                    AllowImplicitBroadcast AllowImplicitBroadcast::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "action");
                        std::optional<std::string> action = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            action = _value;
                        }
                        AllowImplicitBroadcast instance(action);
                        return instance;
                    }

                    AppLink::AppLink(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AppLink::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AppLink::hasPackage() const {
                        return package_.has_value();
                    }

                    AppLink AppLink::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AppLink instance(package);
                        return instance;
                    }

                    SystemUserWhitelistedApp::SystemUserWhitelistedApp(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& SystemUserWhitelistedApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool SystemUserWhitelistedApp::hasPackage() const {
                        return package_.has_value();
                    }

                    SystemUserWhitelistedApp SystemUserWhitelistedApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        SystemUserWhitelistedApp instance(package);
                        return instance;
                    }

                    SystemUserBlacklistedApp::SystemUserBlacklistedApp(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& SystemUserBlacklistedApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool SystemUserBlacklistedApp::hasPackage() const {
                        return package_.has_value();
                    }

                    SystemUserBlacklistedApp SystemUserBlacklistedApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        SystemUserBlacklistedApp instance(package);
                        return instance;
                    }

                    DefaultEnabledVrApp::DefaultEnabledVrApp(std::optional<std::string> package, std::optional<std::string> _class) : package_(std::move(package)), _class_(std::move(_class)) {
                    }

                    const std::string& DefaultEnabledVrApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool DefaultEnabledVrApp::hasPackage() const {
                        return package_.has_value();
                    }

                    const std::string& DefaultEnabledVrApp::get_class() const {
                        _xsdc_assert(has_class());
                        return _class_.value();
                    }

                    bool DefaultEnabledVrApp::has_class() const {
                        return _class_.has_value();
                    }

                    DefaultEnabledVrApp DefaultEnabledVrApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        _raw = getXmlAttribute(root, "class");
                        std::optional<std::string> _class = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            _class = _value;
                        }
                        DefaultEnabledVrApp instance(package, _class);
                        return instance;
                    }

                    BackupTransportWhitelistedService::BackupTransportWhitelistedService(std::optional<std::string> service) : service_(std::move(service)) {
                    }

                    const std::string& BackupTransportWhitelistedService::getService() const {
                        _xsdc_assert(hasService());
                        return service_.value();
                    }

                    bool BackupTransportWhitelistedService::hasService() const {
                        return service_.has_value();
                    }

                    BackupTransportWhitelistedService BackupTransportWhitelistedService::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "service");
                        std::optional<std::string> service = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            service = _value;
                        }
                        BackupTransportWhitelistedService instance(service);
                        return instance;
                    }

                    DisabledUntilUsedPreinstalledCarrierAssociatedApp::DisabledUntilUsedPreinstalledCarrierAssociatedApp(std::optional<std::string> package, std::optional<std::string> carrierAppPackage) : package_(std::move(package)), carrierAppPackage_(std::move(carrierAppPackage)) {
                    }

                    const std::string& DisabledUntilUsedPreinstalledCarrierAssociatedApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool DisabledUntilUsedPreinstalledCarrierAssociatedApp::hasPackage() const {
                        return package_.has_value();
                    }

                    const std::string& DisabledUntilUsedPreinstalledCarrierAssociatedApp::getCarrierAppPackage() const {
                        _xsdc_assert(hasCarrierAppPackage());
                        return carrierAppPackage_.value();
                    }

                    bool DisabledUntilUsedPreinstalledCarrierAssociatedApp::hasCarrierAppPackage() const {
                        return carrierAppPackage_.has_value();
                    }

                    DisabledUntilUsedPreinstalledCarrierAssociatedApp DisabledUntilUsedPreinstalledCarrierAssociatedApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        _raw = getXmlAttribute(root, "carrierAppPackage");
                        std::optional<std::string> carrierAppPackage = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            carrierAppPackage = _value;
                        }
                        DisabledUntilUsedPreinstalledCarrierAssociatedApp instance(package, carrierAppPackage);
                        return instance;
                    }

                    DisabledUntilUsedPreinstalledCarrierApp::DisabledUntilUsedPreinstalledCarrierApp(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& DisabledUntilUsedPreinstalledCarrierApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool DisabledUntilUsedPreinstalledCarrierApp::hasPackage() const {
                        return package_.has_value();
                    }

                    DisabledUntilUsedPreinstalledCarrierApp DisabledUntilUsedPreinstalledCarrierApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        DisabledUntilUsedPreinstalledCarrierApp instance(package);
                        return instance;
                    }

                    PrivappPermissions::Permission::Permission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    PrivappPermissions::Permission PrivappPermissions::Permission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        PrivappPermissions::Permission instance(name);
                        return instance;
                    }

                    PrivappPermissions::DenyPermission::DenyPermission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    PrivappPermissions::DenyPermission PrivappPermissions::DenyPermission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        PrivappPermissions::DenyPermission instance(name);
                        return instance;
                    }

                    PrivappPermissions::PrivappPermissions(std::vector<Permission> permission, std::vector<DenyPermission> denyPermission, std::optional<std::string> package) : permission_(std::move(permission)), denyPermission_(std::move(denyPermission)), package_(std::move(package)) {
                    }

                    const std::vector<PrivappPermissions::Permission>& PrivappPermissions::getPermission() const {
                        return permission_;
                    }

                    bool PrivappPermissions::hasPermission() const {
                        return !(permission_.empty());
                    }

                    const PrivappPermissions::Permission* PrivappPermissions::getFirstPermission() const {
                        if (permission_.empty()) {
                            return nullptr;
                        }
                        return &permission_[0];
                    }

                    const std::vector<PrivappPermissions::DenyPermission>& PrivappPermissions::getDenyPermission() const {
                        return denyPermission_;
                    }

                    bool PrivappPermissions::hasDenyPermission() const {
                        return !(denyPermission_.empty());
                    }

                    const PrivappPermissions::DenyPermission* PrivappPermissions::getFirstDenyPermission() const {
                        if (denyPermission_.empty()) {
                            return nullptr;
                        }
                        return &denyPermission_[0];
                    }

                    const std::string& PrivappPermissions::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool PrivappPermissions::hasPackage() const {
                        return package_.has_value();
                    }

                    PrivappPermissions PrivappPermissions::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        std::vector<Permission> permission;
                        std::vector<DenyPermission> denyPermission;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("permission"))) {
                                Permission _value = Permission::read(_child);
                                permission.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("deny-permission"))) {
                                DenyPermission _value = DenyPermission::read(_child);
                                denyPermission.push_back(std::move(_value));
                            }
                        }
                        PrivappPermissions instance(permission, denyPermission, package);
                        return instance;
                    }

                    OemPermissions::Permission::Permission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    OemPermissions::Permission OemPermissions::Permission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        OemPermissions::Permission instance(name);
                        return instance;
                    }

                    OemPermissions::DenyPermission::DenyPermission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    OemPermissions::DenyPermission OemPermissions::DenyPermission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        OemPermissions::DenyPermission instance(name);
                        return instance;
                    }

                    OemPermissions::OemPermissions(std::vector<Permission> permission, std::vector<DenyPermission> denyPermission, std::optional<std::string> package) : permission_(std::move(permission)), denyPermission_(std::move(denyPermission)), package_(std::move(package)) {
                    }

                    const std::vector<OemPermissions::Permission>& OemPermissions::getPermission() const {
                        return permission_;
                    }

                    bool OemPermissions::hasPermission() const {
                        return !(permission_.empty());
                    }

                    const OemPermissions::Permission* OemPermissions::getFirstPermission() const {
                        if (permission_.empty()) {
                            return nullptr;
                        }
                        return &permission_[0];
                    }

                    const std::vector<OemPermissions::DenyPermission>& OemPermissions::getDenyPermission() const {
                        return denyPermission_;
                    }

                    bool OemPermissions::hasDenyPermission() const {
                        return !(denyPermission_.empty());
                    }

                    const OemPermissions::DenyPermission* OemPermissions::getFirstDenyPermission() const {
                        if (denyPermission_.empty()) {
                            return nullptr;
                        }
                        return &denyPermission_[0];
                    }

                    const std::string& OemPermissions::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool OemPermissions::hasPackage() const {
                        return package_.has_value();
                    }

                    OemPermissions OemPermissions::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        std::vector<Permission> permission;
                        std::vector<DenyPermission> denyPermission;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("permission"))) {
                                Permission _value = Permission::read(_child);
                                permission.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("deny-permission"))) {
                                DenyPermission _value = DenyPermission::read(_child);
                                denyPermission.push_back(std::move(_value));
                            }
                        }
                        OemPermissions instance(permission, denyPermission, package);
                        return instance;
                    }

                    SignaturePermissions::Permission::Permission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    SignaturePermissions::Permission SignaturePermissions::Permission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        SignaturePermissions::Permission instance(name);
                        return instance;
                    }

                    SignaturePermissions::DenyPermission::DenyPermission(std::optional<std::string> name) : name_(std::move(name)) {
                    }

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

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

                    SignaturePermissions::DenyPermission SignaturePermissions::DenyPermission::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "name");
                        std::optional<std::string> name = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            name = _value;
                        }
                        SignaturePermissions::DenyPermission instance(name);
                        return instance;
                    }

                    SignaturePermissions::SignaturePermissions(std::vector<Permission> permission, std::vector<DenyPermission> denyPermission, std::optional<std::string> package) : permission_(std::move(permission)), denyPermission_(std::move(denyPermission)), package_(std::move(package)) {
                    }

                    const std::vector<SignaturePermissions::Permission>& SignaturePermissions::getPermission() const {
                        return permission_;
                    }

                    bool SignaturePermissions::hasPermission() const {
                        return !(permission_.empty());
                    }

                    const SignaturePermissions::Permission* SignaturePermissions::getFirstPermission() const {
                        if (permission_.empty()) {
                            return nullptr;
                        }
                        return &permission_[0];
                    }

                    const std::vector<SignaturePermissions::DenyPermission>& SignaturePermissions::getDenyPermission() const {
                        return denyPermission_;
                    }

                    bool SignaturePermissions::hasDenyPermission() const {
                        return !(denyPermission_.empty());
                    }

                    const SignaturePermissions::DenyPermission* SignaturePermissions::getFirstDenyPermission() const {
                        if (denyPermission_.empty()) {
                            return nullptr;
                        }
                        return &denyPermission_[0];
                    }

                    const std::string& SignaturePermissions::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool SignaturePermissions::hasPackage() const {
                        return package_.has_value();
                    }

                    SignaturePermissions SignaturePermissions::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        std::vector<Permission> permission;
                        std::vector<DenyPermission> denyPermission;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("permission"))) {
                                Permission _value = Permission::read(_child);
                                permission.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("deny-permission"))) {
                                DenyPermission _value = DenyPermission::read(_child);
                                denyPermission.push_back(std::move(_value));
                            }
                        }
                        SignaturePermissions instance(permission, denyPermission, package);
                        return instance;
                    }

                    HiddenApiWhitelistedApp::HiddenApiWhitelistedApp(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& HiddenApiWhitelistedApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool HiddenApiWhitelistedApp::hasPackage() const {
                        return package_.has_value();
                    }

                    HiddenApiWhitelistedApp HiddenApiWhitelistedApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        HiddenApiWhitelistedApp instance(package);
                        return instance;
                    }

                    AllowAssociation::AllowAssociation(std::optional<std::string> target, std::optional<std::string> allowed) : target_(std::move(target)), allowed_(std::move(allowed)) {
                    }

                    const std::string& AllowAssociation::getTarget() const {
                        _xsdc_assert(hasTarget());
                        return target_.value();
                    }

                    bool AllowAssociation::hasTarget() const {
                        return target_.has_value();
                    }

                    const std::string& AllowAssociation::getAllowed() const {
                        _xsdc_assert(hasAllowed());
                        return allowed_.value();
                    }

                    bool AllowAssociation::hasAllowed() const {
                        return allowed_.has_value();
                    }

                    AllowAssociation AllowAssociation::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "target");
                        std::optional<std::string> target = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            target = _value;
                        }
                        _raw = getXmlAttribute(root, "allowed");
                        std::optional<std::string> allowed = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            allowed = _value;
                        }
                        AllowAssociation instance(target, allowed);
                        return instance;
                    }

                    AppDataIsolationWhitelistedApp::AppDataIsolationWhitelistedApp(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& AppDataIsolationWhitelistedApp::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool AppDataIsolationWhitelistedApp::hasPackage() const {
                        return package_.has_value();
                    }

                    AppDataIsolationWhitelistedApp AppDataIsolationWhitelistedApp::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        AppDataIsolationWhitelistedApp instance(package);
                        return instance;
                    }

                    BugreportWhitelisted::BugreportWhitelisted(std::optional<std::string> package) : package_(std::move(package)) {
                    }

                    const std::string& BugreportWhitelisted::getPackage() const {
                        _xsdc_assert(hasPackage());
                        return package_.value();
                    }

                    bool BugreportWhitelisted::hasPackage() const {
                        return package_.has_value();
                    }

                    BugreportWhitelisted BugreportWhitelisted::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "package");
                        std::optional<std::string> package = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            package = _value;
                        }
                        BugreportWhitelisted instance(package);
                        return instance;
                    }

                    Permissions::Permissions(std::vector<Group> group_optional, std::vector<Permission> permission_optional, std::vector<AssignPermission> assignPermission_optional, std::vector<SplitPermission> splitPermission_optional, std::vector<Library> library_optional, std::vector<Feature> feature_optional, std::vector<UnavailableFeature> unavailableFeature_optional, std::vector<AllowInPowerSaveExceptIdle> allowInPowerSaveExceptIdle_optional, std::vector<AllowInPowerSave> allowInPowerSave_optional, std::vector<AllowInDataUsageSave> allowInDataUsageSave_optional, std::vector<AllowUnthrottledLocation> allowUnthrottledLocation_optional, std::vector<AllowIgnoreLocationSettings> allowIgnoreLocationSettings_optional, std::vector<AllowImplicitBroadcast> allowImplicitBroadcast_optional, std::vector<AppLink> appLink_optional, std::vector<SystemUserWhitelistedApp> systemUserWhitelistedApp_optional, std::vector<SystemUserBlacklistedApp> systemUserBlacklistedApp_optional, std::vector<DefaultEnabledVrApp> defaultEnabledVrApp_optional, std::vector<BackupTransportWhitelistedService> backupTransportWhitelistedService_optional, std::vector<DisabledUntilUsedPreinstalledCarrierAssociatedApp> disabledUntilUsedPreinstalledCarrierAssociatedApp_optional, std::vector<DisabledUntilUsedPreinstalledCarrierApp> disabledUntilUsedPreinstalledCarrierApp_optional, std::vector<PrivappPermissions> privappPermissions_optional, std::vector<OemPermissions> oemPermissions_optional, std::vector<SignaturePermissions> signaturePermissions_optional, std::vector<HiddenApiWhitelistedApp> hiddenApiWhitelistedApp_optional, std::vector<AllowAssociation> allowAssociation_optional, std::vector<BugreportWhitelisted> bugreportWhitelisted_optional, std::vector<AppDataIsolationWhitelistedApp> appDataIsolationWhitelistedApp_optional) : group_optional_(std::move(group_optional)), permission_optional_(std::move(permission_optional)), assignPermission_optional_(std::move(assignPermission_optional)), splitPermission_optional_(std::move(splitPermission_optional)), library_optional_(std::move(library_optional)), feature_optional_(std::move(feature_optional)), unavailableFeature_optional_(std::move(unavailableFeature_optional)), allowInPowerSaveExceptIdle_optional_(std::move(allowInPowerSaveExceptIdle_optional)), allowInPowerSave_optional_(std::move(allowInPowerSave_optional)), allowInDataUsageSave_optional_(std::move(allowInDataUsageSave_optional)), allowUnthrottledLocation_optional_(std::move(allowUnthrottledLocation_optional)), allowIgnoreLocationSettings_optional_(std::move(allowIgnoreLocationSettings_optional)), allowImplicitBroadcast_optional_(std::move(allowImplicitBroadcast_optional)), appLink_optional_(std::move(appLink_optional)), systemUserWhitelistedApp_optional_(std::move(systemUserWhitelistedApp_optional)), systemUserBlacklistedApp_optional_(std::move(systemUserBlacklistedApp_optional)), defaultEnabledVrApp_optional_(std::move(defaultEnabledVrApp_optional)), backupTransportWhitelistedService_optional_(std::move(backupTransportWhitelistedService_optional)), disabledUntilUsedPreinstalledCarrierAssociatedApp_optional_(std::move(disabledUntilUsedPreinstalledCarrierAssociatedApp_optional)), disabledUntilUsedPreinstalledCarrierApp_optional_(std::move(disabledUntilUsedPreinstalledCarrierApp_optional)), privappPermissions_optional_(std::move(privappPermissions_optional)), oemPermissions_optional_(std::move(oemPermissions_optional)), signaturePermissions_optional_(std::move(signaturePermissions_optional)), hiddenApiWhitelistedApp_optional_(std::move(hiddenApiWhitelistedApp_optional)), allowAssociation_optional_(std::move(allowAssociation_optional)), bugreportWhitelisted_optional_(std::move(bugreportWhitelisted_optional)), appDataIsolationWhitelistedApp_optional_(std::move(appDataIsolationWhitelistedApp_optional)) {
                    }

                    const std::vector<Group>& Permissions::getGroup_optional() const {
                        return group_optional_;
                    }

                    bool Permissions::hasGroup_optional() const {
                        return !(group_optional_.empty());
                    }

                    const Group* Permissions::getFirstGroup_optional() const {
                        if (group_optional_.empty()) {
                            return nullptr;
                        }
                        return &group_optional_[0];
                    }

                    const std::vector<Permission>& Permissions::getPermission_optional() const {
                        return permission_optional_;
                    }

                    bool Permissions::hasPermission_optional() const {
                        return !(permission_optional_.empty());
                    }

                    const Permission* Permissions::getFirstPermission_optional() const {
                        if (permission_optional_.empty()) {
                            return nullptr;
                        }
                        return &permission_optional_[0];
                    }

                    const std::vector<AssignPermission>& Permissions::getAssignPermission_optional() const {
                        return assignPermission_optional_;
                    }

                    bool Permissions::hasAssignPermission_optional() const {
                        return !(assignPermission_optional_.empty());
                    }

                    const AssignPermission* Permissions::getFirstAssignPermission_optional() const {
                        if (assignPermission_optional_.empty()) {
                            return nullptr;
                        }
                        return &assignPermission_optional_[0];
                    }

                    const std::vector<SplitPermission>& Permissions::getSplitPermission_optional() const {
                        return splitPermission_optional_;
                    }

                    bool Permissions::hasSplitPermission_optional() const {
                        return !(splitPermission_optional_.empty());
                    }

                    const SplitPermission* Permissions::getFirstSplitPermission_optional() const {
                        if (splitPermission_optional_.empty()) {
                            return nullptr;
                        }
                        return &splitPermission_optional_[0];
                    }

                    const std::vector<Library>& Permissions::getLibrary_optional() const {
                        return library_optional_;
                    }

                    bool Permissions::hasLibrary_optional() const {
                        return !(library_optional_.empty());
                    }

                    const Library* Permissions::getFirstLibrary_optional() const {
                        if (library_optional_.empty()) {
                            return nullptr;
                        }
                        return &library_optional_[0];
                    }

                    const std::vector<Feature>& Permissions::getFeature_optional() const {
                        return feature_optional_;
                    }

                    bool Permissions::hasFeature_optional() const {
                        return !(feature_optional_.empty());
                    }

                    const Feature* Permissions::getFirstFeature_optional() const {
                        if (feature_optional_.empty()) {
                            return nullptr;
                        }
                        return &feature_optional_[0];
                    }

                    const std::vector<UnavailableFeature>& Permissions::getUnavailableFeature_optional() const {
                        return unavailableFeature_optional_;
                    }

                    bool Permissions::hasUnavailableFeature_optional() const {
                        return !(unavailableFeature_optional_.empty());
                    }

                    const UnavailableFeature* Permissions::getFirstUnavailableFeature_optional() const {
                        if (unavailableFeature_optional_.empty()) {
                            return nullptr;
                        }
                        return &unavailableFeature_optional_[0];
                    }

                    const std::vector<AllowInPowerSaveExceptIdle>& Permissions::getAllowInPowerSaveExceptIdle_optional() const {
                        return allowInPowerSaveExceptIdle_optional_;
                    }

                    bool Permissions::hasAllowInPowerSaveExceptIdle_optional() const {
                        return !(allowInPowerSaveExceptIdle_optional_.empty());
                    }

                    const AllowInPowerSaveExceptIdle* Permissions::getFirstAllowInPowerSaveExceptIdle_optional() const {
                        if (allowInPowerSaveExceptIdle_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowInPowerSaveExceptIdle_optional_[0];
                    }

                    const std::vector<AllowInPowerSave>& Permissions::getAllowInPowerSave_optional() const {
                        return allowInPowerSave_optional_;
                    }

                    bool Permissions::hasAllowInPowerSave_optional() const {
                        return !(allowInPowerSave_optional_.empty());
                    }

                    const AllowInPowerSave* Permissions::getFirstAllowInPowerSave_optional() const {
                        if (allowInPowerSave_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowInPowerSave_optional_[0];
                    }

                    const std::vector<AllowInDataUsageSave>& Permissions::getAllowInDataUsageSave_optional() const {
                        return allowInDataUsageSave_optional_;
                    }

                    bool Permissions::hasAllowInDataUsageSave_optional() const {
                        return !(allowInDataUsageSave_optional_.empty());
                    }

                    const AllowInDataUsageSave* Permissions::getFirstAllowInDataUsageSave_optional() const {
                        if (allowInDataUsageSave_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowInDataUsageSave_optional_[0];
                    }

                    const std::vector<AllowUnthrottledLocation>& Permissions::getAllowUnthrottledLocation_optional() const {
                        return allowUnthrottledLocation_optional_;
                    }

                    bool Permissions::hasAllowUnthrottledLocation_optional() const {
                        return !(allowUnthrottledLocation_optional_.empty());
                    }

                    const AllowUnthrottledLocation* Permissions::getFirstAllowUnthrottledLocation_optional() const {
                        if (allowUnthrottledLocation_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowUnthrottledLocation_optional_[0];
                    }

                    const std::vector<AllowIgnoreLocationSettings>& Permissions::getAllowIgnoreLocationSettings_optional() const {
                        return allowIgnoreLocationSettings_optional_;
                    }

                    bool Permissions::hasAllowIgnoreLocationSettings_optional() const {
                        return !(allowIgnoreLocationSettings_optional_.empty());
                    }

                    const AllowIgnoreLocationSettings* Permissions::getFirstAllowIgnoreLocationSettings_optional() const {
                        if (allowIgnoreLocationSettings_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowIgnoreLocationSettings_optional_[0];
                    }

                    const std::vector<AllowImplicitBroadcast>& Permissions::getAllowImplicitBroadcast_optional() const {
                        return allowImplicitBroadcast_optional_;
                    }

                    bool Permissions::hasAllowImplicitBroadcast_optional() const {
                        return !(allowImplicitBroadcast_optional_.empty());
                    }

                    const AllowImplicitBroadcast* Permissions::getFirstAllowImplicitBroadcast_optional() const {
                        if (allowImplicitBroadcast_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowImplicitBroadcast_optional_[0];
                    }

                    const std::vector<AppLink>& Permissions::getAppLink_optional() const {
                        return appLink_optional_;
                    }

                    bool Permissions::hasAppLink_optional() const {
                        return !(appLink_optional_.empty());
                    }

                    const AppLink* Permissions::getFirstAppLink_optional() const {
                        if (appLink_optional_.empty()) {
                            return nullptr;
                        }
                        return &appLink_optional_[0];
                    }

                    const std::vector<SystemUserWhitelistedApp>& Permissions::getSystemUserWhitelistedApp_optional() const {
                        return systemUserWhitelistedApp_optional_;
                    }

                    bool Permissions::hasSystemUserWhitelistedApp_optional() const {
                        return !(systemUserWhitelistedApp_optional_.empty());
                    }

                    const SystemUserWhitelistedApp* Permissions::getFirstSystemUserWhitelistedApp_optional() const {
                        if (systemUserWhitelistedApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &systemUserWhitelistedApp_optional_[0];
                    }

                    const std::vector<SystemUserBlacklistedApp>& Permissions::getSystemUserBlacklistedApp_optional() const {
                        return systemUserBlacklistedApp_optional_;
                    }

                    bool Permissions::hasSystemUserBlacklistedApp_optional() const {
                        return !(systemUserBlacklistedApp_optional_.empty());
                    }

                    const SystemUserBlacklistedApp* Permissions::getFirstSystemUserBlacklistedApp_optional() const {
                        if (systemUserBlacklistedApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &systemUserBlacklistedApp_optional_[0];
                    }

                    const std::vector<DefaultEnabledVrApp>& Permissions::getDefaultEnabledVrApp_optional() const {
                        return defaultEnabledVrApp_optional_;
                    }

                    bool Permissions::hasDefaultEnabledVrApp_optional() const {
                        return !(defaultEnabledVrApp_optional_.empty());
                    }

                    const DefaultEnabledVrApp* Permissions::getFirstDefaultEnabledVrApp_optional() const {
                        if (defaultEnabledVrApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &defaultEnabledVrApp_optional_[0];
                    }

                    const std::vector<BackupTransportWhitelistedService>& Permissions::getBackupTransportWhitelistedService_optional() const {
                        return backupTransportWhitelistedService_optional_;
                    }

                    bool Permissions::hasBackupTransportWhitelistedService_optional() const {
                        return !(backupTransportWhitelistedService_optional_.empty());
                    }

                    const BackupTransportWhitelistedService* Permissions::getFirstBackupTransportWhitelistedService_optional() const {
                        if (backupTransportWhitelistedService_optional_.empty()) {
                            return nullptr;
                        }
                        return &backupTransportWhitelistedService_optional_[0];
                    }

                    const std::vector<DisabledUntilUsedPreinstalledCarrierAssociatedApp>& Permissions::getDisabledUntilUsedPreinstalledCarrierAssociatedApp_optional() const {
                        return disabledUntilUsedPreinstalledCarrierAssociatedApp_optional_;
                    }

                    bool Permissions::hasDisabledUntilUsedPreinstalledCarrierAssociatedApp_optional() const {
                        return !(disabledUntilUsedPreinstalledCarrierAssociatedApp_optional_.empty());
                    }

                    const DisabledUntilUsedPreinstalledCarrierAssociatedApp* Permissions::getFirstDisabledUntilUsedPreinstalledCarrierAssociatedApp_optional() const {
                        if (disabledUntilUsedPreinstalledCarrierAssociatedApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &disabledUntilUsedPreinstalledCarrierAssociatedApp_optional_[0];
                    }

                    const std::vector<DisabledUntilUsedPreinstalledCarrierApp>& Permissions::getDisabledUntilUsedPreinstalledCarrierApp_optional() const {
                        return disabledUntilUsedPreinstalledCarrierApp_optional_;
                    }

                    bool Permissions::hasDisabledUntilUsedPreinstalledCarrierApp_optional() const {
                        return !(disabledUntilUsedPreinstalledCarrierApp_optional_.empty());
                    }

                    const DisabledUntilUsedPreinstalledCarrierApp* Permissions::getFirstDisabledUntilUsedPreinstalledCarrierApp_optional() const {
                        if (disabledUntilUsedPreinstalledCarrierApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &disabledUntilUsedPreinstalledCarrierApp_optional_[0];
                    }

                    const std::vector<PrivappPermissions>& Permissions::getPrivappPermissions_optional() const {
                        return privappPermissions_optional_;
                    }

                    bool Permissions::hasPrivappPermissions_optional() const {
                        return !(privappPermissions_optional_.empty());
                    }

                    const PrivappPermissions* Permissions::getFirstPrivappPermissions_optional() const {
                        if (privappPermissions_optional_.empty()) {
                            return nullptr;
                        }
                        return &privappPermissions_optional_[0];
                    }

                    const std::vector<OemPermissions>& Permissions::getOemPermissions_optional() const {
                        return oemPermissions_optional_;
                    }

                    bool Permissions::hasOemPermissions_optional() const {
                        return !(oemPermissions_optional_.empty());
                    }

                    const OemPermissions* Permissions::getFirstOemPermissions_optional() const {
                        if (oemPermissions_optional_.empty()) {
                            return nullptr;
                        }
                        return &oemPermissions_optional_[0];
                    }

                    const std::vector<SignaturePermissions>& Permissions::getSignaturePermissions_optional() const {
                        return signaturePermissions_optional_;
                    }

                    bool Permissions::hasSignaturePermissions_optional() const {
                        return !(signaturePermissions_optional_.empty());
                    }

                    const SignaturePermissions* Permissions::getFirstSignaturePermissions_optional() const {
                        if (signaturePermissions_optional_.empty()) {
                            return nullptr;
                        }
                        return &signaturePermissions_optional_[0];
                    }

                    const std::vector<HiddenApiWhitelistedApp>& Permissions::getHiddenApiWhitelistedApp_optional() const {
                        return hiddenApiWhitelistedApp_optional_;
                    }

                    bool Permissions::hasHiddenApiWhitelistedApp_optional() const {
                        return !(hiddenApiWhitelistedApp_optional_.empty());
                    }

                    const HiddenApiWhitelistedApp* Permissions::getFirstHiddenApiWhitelistedApp_optional() const {
                        if (hiddenApiWhitelistedApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &hiddenApiWhitelistedApp_optional_[0];
                    }

                    const std::vector<AllowAssociation>& Permissions::getAllowAssociation_optional() const {
                        return allowAssociation_optional_;
                    }

                    bool Permissions::hasAllowAssociation_optional() const {
                        return !(allowAssociation_optional_.empty());
                    }

                    const AllowAssociation* Permissions::getFirstAllowAssociation_optional() const {
                        if (allowAssociation_optional_.empty()) {
                            return nullptr;
                        }
                        return &allowAssociation_optional_[0];
                    }

                    const std::vector<BugreportWhitelisted>& Permissions::getBugreportWhitelisted_optional() const {
                        return bugreportWhitelisted_optional_;
                    }

                    bool Permissions::hasBugreportWhitelisted_optional() const {
                        return !(bugreportWhitelisted_optional_.empty());
                    }

                    const BugreportWhitelisted* Permissions::getFirstBugreportWhitelisted_optional() const {
                        if (bugreportWhitelisted_optional_.empty()) {
                            return nullptr;
                        }
                        return &bugreportWhitelisted_optional_[0];
                    }

                    const std::vector<AppDataIsolationWhitelistedApp>& Permissions::getAppDataIsolationWhitelistedApp_optional() const {
                        return appDataIsolationWhitelistedApp_optional_;
                    }

                    bool Permissions::hasAppDataIsolationWhitelistedApp_optional() const {
                        return !(appDataIsolationWhitelistedApp_optional_.empty());
                    }

                    const AppDataIsolationWhitelistedApp* Permissions::getFirstAppDataIsolationWhitelistedApp_optional() const {
                        if (appDataIsolationWhitelistedApp_optional_.empty()) {
                            return nullptr;
                        }
                        return &appDataIsolationWhitelistedApp_optional_[0];
                    }

                    Permissions Permissions::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<Group> group_optional;
                        std::vector<Permission> permission_optional;
                        std::vector<AssignPermission> assignPermission_optional;
                        std::vector<SplitPermission> splitPermission_optional;
                        std::vector<Library> library_optional;
                        std::vector<Feature> feature_optional;
                        std::vector<UnavailableFeature> unavailableFeature_optional;
                        std::vector<AllowInPowerSaveExceptIdle> allowInPowerSaveExceptIdle_optional;
                        std::vector<AllowInPowerSave> allowInPowerSave_optional;
                        std::vector<AllowInDataUsageSave> allowInDataUsageSave_optional;
                        std::vector<AllowUnthrottledLocation> allowUnthrottledLocation_optional;
                        std::vector<AllowIgnoreLocationSettings> allowIgnoreLocationSettings_optional;
                        std::vector<AllowImplicitBroadcast> allowImplicitBroadcast_optional;
                        std::vector<AppLink> appLink_optional;
                        std::vector<SystemUserWhitelistedApp> systemUserWhitelistedApp_optional;
                        std::vector<SystemUserBlacklistedApp> systemUserBlacklistedApp_optional;
                        std::vector<DefaultEnabledVrApp> defaultEnabledVrApp_optional;
                        std::vector<BackupTransportWhitelistedService> backupTransportWhitelistedService_optional;
                        std::vector<DisabledUntilUsedPreinstalledCarrierAssociatedApp> disabledUntilUsedPreinstalledCarrierAssociatedApp_optional;
                        std::vector<DisabledUntilUsedPreinstalledCarrierApp> disabledUntilUsedPreinstalledCarrierApp_optional;
                        std::vector<PrivappPermissions> privappPermissions_optional;
                        std::vector<OemPermissions> oemPermissions_optional;
                        std::vector<SignaturePermissions> signaturePermissions_optional;
                        std::vector<HiddenApiWhitelistedApp> hiddenApiWhitelistedApp_optional;
                        std::vector<AllowAssociation> allowAssociation_optional;
                        std::vector<BugreportWhitelisted> bugreportWhitelisted_optional;
                        std::vector<AppDataIsolationWhitelistedApp> appDataIsolationWhitelistedApp_optional;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("group"))) {
                                Group _value = Group::read(_child);
                                group_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("permission"))) {
                                Permission _value = Permission::read(_child);
                                permission_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("assign-permission"))) {
                                AssignPermission _value = AssignPermission::read(_child);
                                assignPermission_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("split-permission"))) {
                                SplitPermission _value = SplitPermission::read(_child);
                                splitPermission_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("library"))) {
                                Library _value = Library::read(_child);
                                library_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("feature"))) {
                                Feature _value = Feature::read(_child);
                                feature_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("unavailable-feature"))) {
                                UnavailableFeature _value = UnavailableFeature::read(_child);
                                unavailableFeature_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-in-power-save-except-idle"))) {
                                AllowInPowerSaveExceptIdle _value = AllowInPowerSaveExceptIdle::read(_child);
                                allowInPowerSaveExceptIdle_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-in-power-save"))) {
                                AllowInPowerSave _value = AllowInPowerSave::read(_child);
                                allowInPowerSave_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-in-data-usage-save"))) {
                                AllowInDataUsageSave _value = AllowInDataUsageSave::read(_child);
                                allowInDataUsageSave_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-unthrottled-location"))) {
                                AllowUnthrottledLocation _value = AllowUnthrottledLocation::read(_child);
                                allowUnthrottledLocation_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-ignore-location-settings"))) {
                                AllowIgnoreLocationSettings _value = AllowIgnoreLocationSettings::read(_child);
                                allowIgnoreLocationSettings_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-implicit-broadcast"))) {
                                AllowImplicitBroadcast _value = AllowImplicitBroadcast::read(_child);
                                allowImplicitBroadcast_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("app-link"))) {
                                AppLink _value = AppLink::read(_child);
                                appLink_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("system-user-whitelisted-app"))) {
                                SystemUserWhitelistedApp _value = SystemUserWhitelistedApp::read(_child);
                                systemUserWhitelistedApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("system-user-blacklisted-app"))) {
                                SystemUserBlacklistedApp _value = SystemUserBlacklistedApp::read(_child);
                                systemUserBlacklistedApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("default-enabled-vr-app"))) {
                                DefaultEnabledVrApp _value = DefaultEnabledVrApp::read(_child);
                                defaultEnabledVrApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("backup-transport-whitelisted-service"))) {
                                BackupTransportWhitelistedService _value = BackupTransportWhitelistedService::read(_child);
                                backupTransportWhitelistedService_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("disabled-until-used-preinstalled-carrier-associated-app"))) {
                                DisabledUntilUsedPreinstalledCarrierAssociatedApp _value = DisabledUntilUsedPreinstalledCarrierAssociatedApp::read(_child);
                                disabledUntilUsedPreinstalledCarrierAssociatedApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("disabled-until-used-preinstalled-carrier-app"))) {
                                DisabledUntilUsedPreinstalledCarrierApp _value = DisabledUntilUsedPreinstalledCarrierApp::read(_child);
                                disabledUntilUsedPreinstalledCarrierApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("privapp-permissions"))) {
                                PrivappPermissions _value = PrivappPermissions::read(_child);
                                privappPermissions_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("oem-permissions"))) {
                                OemPermissions _value = OemPermissions::read(_child);
                                oemPermissions_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("signature-permissions"))) {
                                SignaturePermissions _value = SignaturePermissions::read(_child);
                                signaturePermissions_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("hidden-api-whitelisted-app"))) {
                                HiddenApiWhitelistedApp _value = HiddenApiWhitelistedApp::read(_child);
                                hiddenApiWhitelistedApp_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("allow-association"))) {
                                AllowAssociation _value = AllowAssociation::read(_child);
                                allowAssociation_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("bugreport-whitelisted"))) {
                                BugreportWhitelisted _value = BugreportWhitelisted::read(_child);
                                bugreportWhitelisted_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("app-data-isolation-whitelisted-app"))) {
                                AppDataIsolationWhitelistedApp _value = AppDataIsolationWhitelistedApp::read(_child);
                                appDataIsolationWhitelistedApp_optional.push_back(std::move(_value));
                            }
                        }
                        Permissions instance(group_optional, permission_optional, assignPermission_optional, splitPermission_optional, library_optional, feature_optional, unavailableFeature_optional, allowInPowerSaveExceptIdle_optional, allowInPowerSave_optional, allowInDataUsageSave_optional, allowUnthrottledLocation_optional, allowIgnoreLocationSettings_optional, allowImplicitBroadcast_optional, appLink_optional, systemUserWhitelistedApp_optional, systemUserBlacklistedApp_optional, defaultEnabledVrApp_optional, backupTransportWhitelistedService_optional, disabledUntilUsedPreinstalledCarrierAssociatedApp_optional, disabledUntilUsedPreinstalledCarrierApp_optional, privappPermissions_optional, oemPermissions_optional, signaturePermissions_optional, hiddenApiWhitelistedApp_optional, allowAssociation_optional, bugreportWhitelisted_optional, appDataIsolationWhitelistedApp_optional);
                        return instance;
                    }
                } // configfile
            } // permission
        } // xml
    } // android
} // com