xref: /aosp_15_r20/out/soong/.intermediates/hardware/interfaces/automotive/audiocontrol/aidl/default/loaders/fade/car_fade_audio_configuration_xsd/gen/cpp/android_hardware_automotive_audiocontrol_fade.cpp

#define LOG_TAG "android.hardware.automotive.audiocontrol.fade"
#include "android_hardware_automotive_audiocontrol_fade.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 android {
    namespace hardware {
        namespace automotive {
            namespace audiocontrol {
                namespace fade {
                    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<CarAudioFadeConfigurationType> 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*>("carAudioFadeConfiguration"))) {
                            CarAudioFadeConfigurationType _value = CarAudioFadeConfigurationType::read(_child);
                            return _value;
                        }
                        return std::nullopt;
                    }

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


                    CarAudioFadeConfigurationType::CarAudioFadeConfigurationType(std::vector<FadeConfigurationConfigs> configs) : configs_(std::move(configs)) {
                    }

                    const std::vector<FadeConfigurationConfigs>& CarAudioFadeConfigurationType::getConfigs() const {
                        return configs_;
                    }

                    bool CarAudioFadeConfigurationType::hasConfigs() const {
                        return !(configs_.empty());
                    }

                    const FadeConfigurationConfigs* CarAudioFadeConfigurationType::getFirstConfigs() const {
                        if (configs_.empty()) {
                            return nullptr;
                        }
                        return &configs_[0];
                    }

                    CarAudioFadeConfigurationType CarAudioFadeConfigurationType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<FadeConfigurationConfigs> configs;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("configs"))) {
                                FadeConfigurationConfigs _value = FadeConfigurationConfigs::read(_child);
                                configs.push_back(std::move(_value));
                            }
                        }
                        CarAudioFadeConfigurationType instance(configs);
                        return instance;
                    }

                    FadeConfigurationConfigs::FadeConfigurationConfigs(std::vector<FadeConfigurationConfig> config) : config_(std::move(config)) {
                    }

                    const std::vector<FadeConfigurationConfig>& FadeConfigurationConfigs::getConfig() const {
                        return config_;
                    }

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

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

                    FadeConfigurationConfigs FadeConfigurationConfigs::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<FadeConfigurationConfig> config;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("config"))) {
                                FadeConfigurationConfig _value = FadeConfigurationConfig::read(_child);
                                config.push_back(std::move(_value));
                            }
                        }
                        FadeConfigurationConfigs instance(config);
                        return instance;
                    }

                    FadeConfigurationConfig::FadeConfigurationConfig(std::vector<FadeStateType> fadeState, std::vector<FadeableUsagesType> fadeableUsages, std::vector<UnfadeableContentTypesType> unfadeableContentTypes, std::vector<UnfadeableAudioAttributesType> unfadeableAudioAttributes, std::vector<FadeOutConfigurationsType> fadeOutConfigurations, std::vector<FadeInConfigurationsType> fadeInConfigurations, std::optional<std::string> name, std::optional<std::string> defaultFadeOutDurationInMillis, std::optional<std::string> defaultFadeInDurationInMillis, std::optional<std::string> defaultFadeInDelayForOffenders) : fadeState_(std::move(fadeState)), fadeableUsages_(std::move(fadeableUsages)), unfadeableContentTypes_(std::move(unfadeableContentTypes)), unfadeableAudioAttributes_(std::move(unfadeableAudioAttributes)), fadeOutConfigurations_(std::move(fadeOutConfigurations)), fadeInConfigurations_(std::move(fadeInConfigurations)), name_(std::move(name)), defaultFadeOutDurationInMillis_(std::move(defaultFadeOutDurationInMillis)), defaultFadeInDurationInMillis_(std::move(defaultFadeInDurationInMillis)), defaultFadeInDelayForOffenders_(std::move(defaultFadeInDelayForOffenders)) {
                    }

                    const std::vector<FadeStateType>& FadeConfigurationConfig::getFadeState() const {
                        return fadeState_;
                    }

                    bool FadeConfigurationConfig::hasFadeState() const {
                        return !(fadeState_.empty());
                    }

                    const FadeStateType* FadeConfigurationConfig::getFirstFadeState() const {
                        if (fadeState_.empty()) {
                            return nullptr;
                        }
                        return &fadeState_[0];
                    }

                    const std::vector<FadeableUsagesType>& FadeConfigurationConfig::getFadeableUsages() const {
                        return fadeableUsages_;
                    }

                    bool FadeConfigurationConfig::hasFadeableUsages() const {
                        return !(fadeableUsages_.empty());
                    }

                    const FadeableUsagesType* FadeConfigurationConfig::getFirstFadeableUsages() const {
                        if (fadeableUsages_.empty()) {
                            return nullptr;
                        }
                        return &fadeableUsages_[0];
                    }

                    const std::vector<UnfadeableContentTypesType>& FadeConfigurationConfig::getUnfadeableContentTypes() const {
                        return unfadeableContentTypes_;
                    }

                    bool FadeConfigurationConfig::hasUnfadeableContentTypes() const {
                        return !(unfadeableContentTypes_.empty());
                    }

                    const UnfadeableContentTypesType* FadeConfigurationConfig::getFirstUnfadeableContentTypes() const {
                        if (unfadeableContentTypes_.empty()) {
                            return nullptr;
                        }
                        return &unfadeableContentTypes_[0];
                    }

                    const std::vector<UnfadeableAudioAttributesType>& FadeConfigurationConfig::getUnfadeableAudioAttributes() const {
                        return unfadeableAudioAttributes_;
                    }

                    bool FadeConfigurationConfig::hasUnfadeableAudioAttributes() const {
                        return !(unfadeableAudioAttributes_.empty());
                    }

                    const UnfadeableAudioAttributesType* FadeConfigurationConfig::getFirstUnfadeableAudioAttributes() const {
                        if (unfadeableAudioAttributes_.empty()) {
                            return nullptr;
                        }
                        return &unfadeableAudioAttributes_[0];
                    }

                    const std::vector<FadeOutConfigurationsType>& FadeConfigurationConfig::getFadeOutConfigurations() const {
                        return fadeOutConfigurations_;
                    }

                    bool FadeConfigurationConfig::hasFadeOutConfigurations() const {
                        return !(fadeOutConfigurations_.empty());
                    }

                    const FadeOutConfigurationsType* FadeConfigurationConfig::getFirstFadeOutConfigurations() const {
                        if (fadeOutConfigurations_.empty()) {
                            return nullptr;
                        }
                        return &fadeOutConfigurations_[0];
                    }

                    const std::vector<FadeInConfigurationsType>& FadeConfigurationConfig::getFadeInConfigurations() const {
                        return fadeInConfigurations_;
                    }

                    bool FadeConfigurationConfig::hasFadeInConfigurations() const {
                        return !(fadeInConfigurations_.empty());
                    }

                    const FadeInConfigurationsType* FadeConfigurationConfig::getFirstFadeInConfigurations() const {
                        if (fadeInConfigurations_.empty()) {
                            return nullptr;
                        }
                        return &fadeInConfigurations_[0];
                    }

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

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

                    const std::string& FadeConfigurationConfig::getDefaultFadeOutDurationInMillis() const {
                        _xsdc_assert(hasDefaultFadeOutDurationInMillis());
                        return defaultFadeOutDurationInMillis_.value();
                    }

                    bool FadeConfigurationConfig::hasDefaultFadeOutDurationInMillis() const {
                        return defaultFadeOutDurationInMillis_.has_value();
                    }

                    const std::string& FadeConfigurationConfig::getDefaultFadeInDurationInMillis() const {
                        _xsdc_assert(hasDefaultFadeInDurationInMillis());
                        return defaultFadeInDurationInMillis_.value();
                    }

                    bool FadeConfigurationConfig::hasDefaultFadeInDurationInMillis() const {
                        return defaultFadeInDurationInMillis_.has_value();
                    }

                    const std::string& FadeConfigurationConfig::getDefaultFadeInDelayForOffenders() const {
                        _xsdc_assert(hasDefaultFadeInDelayForOffenders());
                        return defaultFadeInDelayForOffenders_.value();
                    }

                    bool FadeConfigurationConfig::hasDefaultFadeInDelayForOffenders() const {
                        return defaultFadeInDelayForOffenders_.has_value();
                    }

                    FadeConfigurationConfig FadeConfigurationConfig::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, "defaultFadeOutDurationInMillis");
                        std::optional<std::string> defaultFadeOutDurationInMillis = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            defaultFadeOutDurationInMillis = _value;
                        }
                        _raw = getXmlAttribute(root, "defaultFadeInDurationInMillis");
                        std::optional<std::string> defaultFadeInDurationInMillis = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            defaultFadeInDurationInMillis = _value;
                        }
                        _raw = getXmlAttribute(root, "defaultFadeInDelayForOffenders");
                        std::optional<std::string> defaultFadeInDelayForOffenders = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            defaultFadeInDelayForOffenders = _value;
                        }
                        std::vector<FadeStateType> fadeState;
                        std::vector<FadeableUsagesType> fadeableUsages;
                        std::vector<UnfadeableContentTypesType> unfadeableContentTypes;
                        std::vector<UnfadeableAudioAttributesType> unfadeableAudioAttributes;
                        std::vector<FadeOutConfigurationsType> fadeOutConfigurations;
                        std::vector<FadeInConfigurationsType> fadeInConfigurations;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeState"))) {
                                FadeStateType _value = FadeStateType::read(_child);
                                fadeState.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeableUsages"))) {
                                FadeableUsagesType _value = FadeableUsagesType::read(_child);
                                fadeableUsages.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("unfadeableContentTypes"))) {
                                UnfadeableContentTypesType _value = UnfadeableContentTypesType::read(_child);
                                unfadeableContentTypes.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("unfadeableAudioAttributes"))) {
                                UnfadeableAudioAttributesType _value = UnfadeableAudioAttributesType::read(_child);
                                unfadeableAudioAttributes.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeOutConfigurations"))) {
                                FadeOutConfigurationsType _value = FadeOutConfigurationsType::read(_child);
                                fadeOutConfigurations.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeInConfigurations"))) {
                                FadeInConfigurationsType _value = FadeInConfigurationsType::read(_child);
                                fadeInConfigurations.push_back(std::move(_value));
                            }
                        }
                        FadeConfigurationConfig instance(fadeState, fadeableUsages, unfadeableContentTypes, unfadeableAudioAttributes, fadeOutConfigurations, fadeInConfigurations, name, defaultFadeOutDurationInMillis, defaultFadeInDurationInMillis, defaultFadeInDelayForOffenders);
                        return instance;
                    }

                    FadeStateType::FadeStateType(std::optional<FadeStateEnumType> value) : value_(value) {
                    }

                    const FadeStateEnumType& FadeStateType::getValue() const {
                        _xsdc_assert(hasValue());
                        return value_.value();
                    }

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

                    FadeStateType FadeStateType::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "value");
                        std::optional<FadeStateEnumType> value = std::nullopt;
                        if (_raw != "") {
                            FadeStateEnumType _value = stringToFadeStateEnumType(_raw);
                            value = _value;
                        }
                        FadeStateType instance(value);
                        return instance;
                    }

                    FadeableUsagesType::FadeableUsagesType(std::vector<UsageType> usage) : usage_(std::move(usage)) {
                    }

                    const std::vector<UsageType>& FadeableUsagesType::getUsage() const {
                        return usage_;
                    }

                    bool FadeableUsagesType::hasUsage() const {
                        return !(usage_.empty());
                    }

                    const UsageType* FadeableUsagesType::getFirstUsage() const {
                        if (usage_.empty()) {
                            return nullptr;
                        }
                        return &usage_[0];
                    }

                    FadeableUsagesType FadeableUsagesType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<UsageType> usage;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("usage"))) {
                                UsageType _value = UsageType::read(_child);
                                usage.push_back(std::move(_value));
                            }
                        }
                        FadeableUsagesType instance(usage);
                        return instance;
                    }

                    UsageType::UsageType(std::optional<UsageEnumType> value) : value_(value) {
                    }

                    const UsageEnumType& UsageType::getValue() const {
                        _xsdc_assert(hasValue());
                        return value_.value();
                    }

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

                    UsageType UsageType::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "value");
                        std::optional<UsageEnumType> value = std::nullopt;
                        if (_raw != "") {
                            UsageEnumType _value = stringToUsageEnumType(_raw);
                            value = _value;
                        }
                        UsageType instance(value);
                        return instance;
                    }

                    UnfadeableContentTypesType::UnfadeableContentTypesType(std::vector<ContentType> contentType) : contentType_(std::move(contentType)) {
                    }

                    const std::vector<ContentType>& UnfadeableContentTypesType::getContentType() const {
                        return contentType_;
                    }

                    bool UnfadeableContentTypesType::hasContentType() const {
                        return !(contentType_.empty());
                    }

                    const ContentType* UnfadeableContentTypesType::getFirstContentType() const {
                        if (contentType_.empty()) {
                            return nullptr;
                        }
                        return &contentType_[0];
                    }

                    UnfadeableContentTypesType UnfadeableContentTypesType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<ContentType> contentType;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("contentType"))) {
                                ContentType _value = ContentType::read(_child);
                                contentType.push_back(std::move(_value));
                            }
                        }
                        UnfadeableContentTypesType instance(contentType);
                        return instance;
                    }

                    ContentType::ContentType(std::optional<ContentTypeEnum> value) : value_(value) {
                    }

                    const ContentTypeEnum& ContentType::getValue() const {
                        _xsdc_assert(hasValue());
                        return value_.value();
                    }

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

                    ContentType ContentType::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "value");
                        std::optional<ContentTypeEnum> value = std::nullopt;
                        if (_raw != "") {
                            ContentTypeEnum _value = stringToContentTypeEnum(_raw);
                            value = _value;
                        }
                        ContentType instance(value);
                        return instance;
                    }

                    UnfadeableAudioAttributesType::UnfadeableAudioAttributesType(std::vector<AudioAttributesUsagesType> audioAttributes) : audioAttributes_(std::move(audioAttributes)) {
                    }

                    const std::vector<AudioAttributesUsagesType>& UnfadeableAudioAttributesType::getAudioAttributes() const {
                        return audioAttributes_;
                    }

                    bool UnfadeableAudioAttributesType::hasAudioAttributes() const {
                        return !(audioAttributes_.empty());
                    }

                    const AudioAttributesUsagesType* UnfadeableAudioAttributesType::getFirstAudioAttributes() const {
                        if (audioAttributes_.empty()) {
                            return nullptr;
                        }
                        return &audioAttributes_[0];
                    }

                    UnfadeableAudioAttributesType UnfadeableAudioAttributesType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<AudioAttributesUsagesType> audioAttributes;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("audioAttributes"))) {
                                AudioAttributesUsagesType _value = AudioAttributesUsagesType::read(_child);
                                audioAttributes.push_back(std::move(_value));
                            }
                        }
                        UnfadeableAudioAttributesType instance(audioAttributes);
                        return instance;
                    }

                    AudioAttributesUsagesType::AudioAttributesUsagesType(std::vector<AttributesType> audioAttribute_optional, std::vector<UsageType> usage_optional) : audioAttribute_optional_(std::move(audioAttribute_optional)), usage_optional_(std::move(usage_optional)) {
                    }

                    const std::vector<AttributesType>& AudioAttributesUsagesType::getAudioAttribute_optional() const {
                        return audioAttribute_optional_;
                    }

                    bool AudioAttributesUsagesType::hasAudioAttribute_optional() const {
                        return !(audioAttribute_optional_.empty());
                    }

                    const AttributesType* AudioAttributesUsagesType::getFirstAudioAttribute_optional() const {
                        if (audioAttribute_optional_.empty()) {
                            return nullptr;
                        }
                        return &audioAttribute_optional_[0];
                    }

                    const std::vector<UsageType>& AudioAttributesUsagesType::getUsage_optional() const {
                        return usage_optional_;
                    }

                    bool AudioAttributesUsagesType::hasUsage_optional() const {
                        return !(usage_optional_.empty());
                    }

                    const UsageType* AudioAttributesUsagesType::getFirstUsage_optional() const {
                        if (usage_optional_.empty()) {
                            return nullptr;
                        }
                        return &usage_optional_[0];
                    }

                    AudioAttributesUsagesType AudioAttributesUsagesType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<AttributesType> audioAttribute_optional;
                        std::vector<UsageType> usage_optional;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("audioAttribute"))) {
                                AttributesType _value = AttributesType::read(_child);
                                audioAttribute_optional.push_back(std::move(_value));
                            } else if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("usage"))) {
                                UsageType _value = UsageType::read(_child);
                                usage_optional.push_back(std::move(_value));
                            }
                        }
                        AudioAttributesUsagesType instance(audioAttribute_optional, usage_optional);
                        return instance;
                    }

                    AttributesType::AttributesType(std::optional<ContentTypeEnum> contentType, std::optional<UsageEnumType> usage, std::optional<std::string> tags) : contentType_(contentType), usage_(usage), tags_(std::move(tags)) {
                    }

                    const ContentTypeEnum& AttributesType::getContentType() const {
                        _xsdc_assert(hasContentType());
                        return contentType_.value();
                    }

                    bool AttributesType::hasContentType() const {
                        return contentType_.has_value();
                    }

                    const UsageEnumType& AttributesType::getUsage() const {
                        _xsdc_assert(hasUsage());
                        return usage_.value();
                    }

                    bool AttributesType::hasUsage() const {
                        return usage_.has_value();
                    }

                    const std::string& AttributesType::getTags() const {
                        _xsdc_assert(hasTags());
                        return tags_.value();
                    }

                    bool AttributesType::hasTags() const {
                        return tags_.has_value();
                    }

                    AttributesType AttributesType::read(xmlNode *root) {
                        std::string _raw;
                        _raw = getXmlAttribute(root, "contentType");
                        std::optional<ContentTypeEnum> contentType = std::nullopt;
                        if (_raw != "") {
                            ContentTypeEnum _value = stringToContentTypeEnum(_raw);
                            contentType = _value;
                        }
                        _raw = getXmlAttribute(root, "usage");
                        std::optional<UsageEnumType> usage = std::nullopt;
                        if (_raw != "") {
                            UsageEnumType _value = stringToUsageEnumType(_raw);
                            usage = _value;
                        }
                        _raw = getXmlAttribute(root, "tags");
                        std::optional<std::string> tags = std::nullopt;
                        if (_raw != "") {
                            std::string &_value = _raw;
                            tags = _value;
                        }
                        AttributesType instance(contentType, usage, tags);
                        return instance;
                    }

                    FadeOutConfigurationsType::FadeOutConfigurationsType(std::vector<FadeConfigurationType> fadeConfiguration) : fadeConfiguration_(std::move(fadeConfiguration)) {
                    }

                    const std::vector<FadeConfigurationType>& FadeOutConfigurationsType::getFadeConfiguration() const {
                        return fadeConfiguration_;
                    }

                    bool FadeOutConfigurationsType::hasFadeConfiguration() const {
                        return !(fadeConfiguration_.empty());
                    }

                    const FadeConfigurationType* FadeOutConfigurationsType::getFirstFadeConfiguration() const {
                        if (fadeConfiguration_.empty()) {
                            return nullptr;
                        }
                        return &fadeConfiguration_[0];
                    }

                    FadeOutConfigurationsType FadeOutConfigurationsType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<FadeConfigurationType> fadeConfiguration;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeConfiguration"))) {
                                FadeConfigurationType _value = FadeConfigurationType::read(_child);
                                fadeConfiguration.push_back(std::move(_value));
                            }
                        }
                        FadeOutConfigurationsType instance(fadeConfiguration);
                        return instance;
                    }

                    FadeConfigurationType::FadeConfigurationType(std::vector<AudioAttributesUsagesType> audioAttributes, std::optional<std::string> fadeDurationMillis) : audioAttributes_(std::move(audioAttributes)), fadeDurationMillis_(std::move(fadeDurationMillis)) {
                    }

                    const std::vector<AudioAttributesUsagesType>& FadeConfigurationType::getAudioAttributes() const {
                        return audioAttributes_;
                    }

                    bool FadeConfigurationType::hasAudioAttributes() const {
                        return !(audioAttributes_.empty());
                    }

                    const AudioAttributesUsagesType* FadeConfigurationType::getFirstAudioAttributes() const {
                        if (audioAttributes_.empty()) {
                            return nullptr;
                        }
                        return &audioAttributes_[0];
                    }

                    const std::string& FadeConfigurationType::getFadeDurationMillis() const {
                        _xsdc_assert(hasFadeDurationMillis());
                        return fadeDurationMillis_.value();
                    }

                    bool FadeConfigurationType::hasFadeDurationMillis() const {
                        return fadeDurationMillis_.has_value();
                    }

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

                    FadeInConfigurationsType::FadeInConfigurationsType(std::vector<FadeConfigurationType> fadeConfiguration) : fadeConfiguration_(std::move(fadeConfiguration)) {
                    }

                    const std::vector<FadeConfigurationType>& FadeInConfigurationsType::getFadeConfiguration() const {
                        return fadeConfiguration_;
                    }

                    bool FadeInConfigurationsType::hasFadeConfiguration() const {
                        return !(fadeConfiguration_.empty());
                    }

                    const FadeConfigurationType* FadeInConfigurationsType::getFirstFadeConfiguration() const {
                        if (fadeConfiguration_.empty()) {
                            return nullptr;
                        }
                        return &fadeConfiguration_[0];
                    }

                    FadeInConfigurationsType FadeInConfigurationsType::read(xmlNode *root) {
                        std::string _raw;
                        std::vector<FadeConfigurationType> fadeConfiguration;
                        for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                            if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("fadeConfiguration"))) {
                                FadeConfigurationType _value = FadeConfigurationType::read(_child);
                                fadeConfiguration.push_back(std::move(_value));
                            }
                        }
                        FadeInConfigurationsType instance(fadeConfiguration);
                        return instance;
                    }
                } // fade
            } // audiocontrol
        } // automotive
    } // hardware
} // android