RepresentationBase.hh

Go to the documentation of this file.

#ifndef _BBC_PARSE_DASH_MPD_REPRESENTATION_BASE_HH_
#define _BBC_PARSE_DASH_MPD_REPRESENTATION_BASE_HH_
/*****************************************************************************
 * DASH MPD parsing library in C++: RepresentationBase class
 *****************************************************************************
 * Copyright: (C) 2025 British Broadcasting Corporation
 * Author(s): David Waring <david.waring2@bbc.co.uk>
 * License: LGPLv3
 *
 * For full license terms please see the LICENSE file distributed with this
 * library or refer to: https://www.gnu.org/licenses/lgpl-3.0.txt.
 */
#include <chrono>
#include <list>
#include <memory>
#include <optional>
#include <string>
 
#include "macros.hh"
#include "Codecs.hh"
#include "ContentPopularityRate.hh"
#include "ContentProtection.hh"
#include "Descriptor.hh"
#include "EventStream.hh"
#include "FrameRate.hh"
#include "Label.hh"
#include "ProducerReferenceTime.hh"
#include "RandomAccess.hh"
#include "Ratio.hh"
#include "Resync.hh"
#include "SAP.hh"
#include "Switching.hh"
#include "URI.hh"

// Forward declarations for types only used by pointer or reference
namespace xmlpp {
    class Element;
    class Node;
}
 
LIBMPDPP_NAMESPACE_BEGIN

class LIBMPDPP_PUBLIC_API RepresentationBase {
public:
    enum VideoScan {
        VIDEO_SCAN_PROGRESSIVE, 
        VIDEO_SCAN_INTERLACED,  
        VIDEO_SCAN_UNKNOWN      
    };

    RepresentationBase();

    RepresentationBase(const RepresentationBase &to_copy);

    RepresentationBase(RepresentationBase &&to_move);

    virtual ~RepresentationBase() {};

    RepresentationBase &operator=(const RepresentationBase &to_copy);

    RepresentationBase &operator=(RepresentationBase &&to_move);

    bool operator==(const RepresentationBase &to_compare) const;
 
    // @profiles

    const std::list<URI> &profiles() const { return m_profiles; };

    std::list<URI>::const_iterator profilesBegin() const { return m_profiles.cbegin(); };
    std::list<URI>::iterator profilesBegin() { return m_profiles.begin(); };

    std::list<URI>::const_iterator profilesEnd() const { return m_profiles.cend(); };
    std::list<URI>::iterator profilesEnd() { return m_profiles.end(); };

    RepresentationBase &profiles(const std::list<URI> &_profiles) { m_profiles = _profiles; return *this; };
    RepresentationBase &profiles(std::list<URI> &&_profiles) { m_profiles = std::move(_profiles); return *this; };

    const URI &profile(std::list<URI>::size_type idx) const;

    RepresentationBase &profilesAdd(const URI &val) { m_profiles.push_back(val); return *this; };
    RepresentationBase &profilesAdd(URI &&val) { m_profiles.push_back(std::move(val)); return *this; };

    RepresentationBase &profilesRemove(const URI &val);

    RepresentationBase &profilesRemove(const std::list<URI>::const_iterator &it);
    RepresentationBase &profilesRemove(const std::list<URI>::iterator &it);
 
    // @width

    bool hasWidth() const { return m_width.has_value(); };

    const std::optional<unsigned int> &width() const { return m_width; };

    RepresentationBase &width(const std::nullopt_t&) { m_width.reset(); return *this; };

    RepresentationBase &width(unsigned int val) { m_width = val; return *this; };
 
    // @height

    bool hasHeight() const { return m_height.has_value(); };

    const std::optional<unsigned int> &height() const { return m_height; };

    RepresentationBase &height(const std::nullopt_t&) { m_height.reset(); return *this; };

    RepresentationBase &height(unsigned int val) { m_height = val; return *this; };
    RepresentationBase &height(const std::optional<unsigned int> &val) { m_height = val; return *this; };
    RepresentationBase &height(std::optional<unsigned int> &&val) { m_height = std::move(val); return *this; };
 
    // @sar

    bool hasSar() const { return m_sar.has_value(); };

    const std::optional<Ratio> &sar() const { return m_sar; };

    RepresentationBase &sar(const std::nullopt_t&) { m_sar.reset(); return *this; };

    RepresentationBase &sar(const Ratio &val) { m_sar = val; return *this; };
    RepresentationBase &sar(Ratio &&val) { m_sar = std::move(val); return *this; };
    RepresentationBase &sar(const std::optional<Ratio> &val) { m_sar = val; return *this; };
    RepresentationBase &sar(std::optional<Ratio> &&val) { m_sar = std::move(val); return *this; };
 
    // @frameRate

    bool hasFrameRate() const { return m_frameRate.has_value(); };

    const std::optional<FrameRate> &frameRate() const { return m_frameRate; };

    RepresentationBase &frameRate(const std::nullopt_t&) { m_frameRate.reset(); return *this; };

    RepresentationBase &frameRate(const FrameRate &val) { m_frameRate = val; return *this; };
    RepresentationBase &frameRate(FrameRate &&val) { m_frameRate = std::move(val); return *this; };
    RepresentationBase &frameRate(const std::optional<FrameRate> &val) { m_frameRate = val; return *this; };
    RepresentationBase &frameRate(std::optional<FrameRate> &&val) { m_frameRate = std::move(val); return *this; };

    RepresentationBase &frameRate(FrameRate::size_type numerator, FrameRate::size_type denominator = 1) {
        m_frameRate = FrameRate(numerator, denominator);
        return *this;
    };
 
    // @pudioSamplingRate

    const std::list<unsigned int> &audioSamplingRates() const { return m_audioSamplingRates; };

    std::list<unsigned int>::const_iterator audioSamplingRatesBegin() const { return m_audioSamplingRates.cbegin(); };
    std::list<unsigned int>::iterator audioSamplingRatesBegin() { return m_audioSamplingRates.begin(); };

    std::list<unsigned int>::const_iterator audioSamplingRatesEnd() const { return m_audioSamplingRates.cend(); };
    std::list<unsigned int>::iterator audioSamplingRatesEnd() { return m_audioSamplingRates.end(); };

    RepresentationBase &audioSamplingRates(const std::list<unsigned int> &rates) { m_audioSamplingRates = rates; return *this; };
    RepresentationBase &audioSamplingRates(std::list<unsigned int> &&rates) { m_audioSamplingRates = std::move(rates); return *this; };

    unsigned int audioSamplingRate(std::list<unsigned int>::size_type idx) const;

    RepresentationBase &audioSamplingRatesAdd(unsigned int val) { m_audioSamplingRates.push_back(val); return *this; };

    RepresentationBase &audioSamplingRatesRemove(unsigned int val);

    RepresentationBase &audioSamplingRatesRemove(const std::list<unsigned int>::const_iterator &it);
    RepresentationBase &audioSamplingRatesRemove(const std::list<unsigned int>::iterator &it);
 
    // @mimeType

    bool hasMimeType() const { return m_mimeType.has_value(); };

    const std::optional<std::string> &mimeType() const { return m_mimeType; };

    RepresentationBase &mimeType(const std::nullopt_t&) { m_mimeType.reset(); return *this; };

    RepresentationBase &mimeType(const std::string &val) { m_mimeType = val; return *this; };
    RepresentationBase &mimeType(std::string &&val) { m_mimeType = std::move(val); return *this; };
    RepresentationBase &mimeType(const std::optional<std::string> &val) { m_mimeType = val; return *this; };
    RepresentationBase &mimeType(std::optional<std::string> &&val) { m_mimeType = std::move(val); return *this; };
 
    // @segmentProfiles

    const std::list<std::string> &segmentProfiles() const { return m_segmentProfiles; };

    RepresentationBase &segmentProfiles(const std::list<std::string> &profiles) { m_segmentProfiles = profiles; return *this; };
    RepresentationBase &segmentProfiles(std::list<std::string> &&profiles) { m_segmentProfiles = std::move(profiles); return *this; };

    std::list<std::string>::const_iterator segmentProfilesBegin() const { return m_segmentProfiles.cbegin(); };
    std::list<std::string>::iterator segmentProfilesBegin() { return m_segmentProfiles.begin(); };

    std::list<std::string>::const_iterator segmentProfilesEnd() const { return m_segmentProfiles.cend(); };
    std::list<std::string>::iterator segmentProfilesEnd() { return m_segmentProfiles.end(); };

    const std::string &segmentProfile(std::list<std::string>::size_type idx) const;

    RepresentationBase &segmentProfilesAdd(const std::string &val) { m_segmentProfiles.push_back(val); return *this; };
    RepresentationBase &segmentProfilesAdd(std::string &&val) { m_segmentProfiles.push_back(std::move(val)); return *this; };

    RepresentationBase &segmentProfilesRemove(const std::string &val);

    RepresentationBase &segmentProfilesRemove(const std::list<std::string>::const_iterator &it);
    RepresentationBase &segmentProfilesRemove(const std::list<std::string>::iterator &it);
 
    // @codecs
    
    bool hasCodecs() const { return m_codecs.has_value(); };

    const std::optional<Codecs> &codecs() const { return m_codecs; };

    RepresentationBase &codecs(const std::nullopt_t&) { m_codecs.reset(); return *this; };

    RepresentationBase &codecs(const Codecs &val) { m_codecs = val; return *this; };
    RepresentationBase &codecs(Codecs &&val) { m_codecs = std::move(val); return *this; };
    RepresentationBase &codecs(const std::optional<Codecs> &val) { m_codecs = val; return *this; };
    RepresentationBase &codecs(std::optional<Codecs> &&val) { m_codecs = std::move(val); return *this; };
 
    // @containerProfiles

    const std::list<std::string> &containerProfiles() const { return m_containerProfiles; };

    RepresentationBase &containerProfiles(const std::list<std::string> &profiles) { m_containerProfiles = profiles; return *this; };
    RepresentationBase &containerProfiles(std::list<std::string> &&profiles) { m_containerProfiles = std::move(profiles); return *this; };

    std::list<std::string>::const_iterator containerProfilesBegin() const { return m_containerProfiles.cbegin(); };
    std::list<std::string>::iterator containerProfilesBegin() { return m_containerProfiles.begin(); };

    std::list<std::string>::const_iterator containerProfilesEnd() const { return m_containerProfiles.cend(); };
    std::list<std::string>::iterator containerProfilesEnd() { return m_containerProfiles.end(); };

    const std::string &containerProfile(std::list<std::string>::size_type idx) const;

    RepresentationBase &containerProfilesAdd(const std::string &val) { m_containerProfiles.push_back(val); return *this; };
    RepresentationBase &containerProfilesAdd(std::string &&val) { m_containerProfiles.push_back(std::move(val)); return *this; };

    RepresentationBase &containerProfilesRemove(const std::string &val);

    RepresentationBase &containerProfilesRemove(const std::list<std::string>::const_iterator &it);
    RepresentationBase &containerProfilesRemove(const std::list<std::string>::iterator &it);
 
    // @maximumSAPPeriod

    bool hasMaximumSAPPeriod() const { return m_maximumSAPPeriod.has_value(); };

    const std::optional<double> &maximumSAPPeriod() const { return m_maximumSAPPeriod; };

    RepresentationBase &maximumSAPPeriod(const std::nullopt_t&) { m_maximumSAPPeriod.reset(); return *this; };

    RepresentationBase &maximumSAPPeriod(double val) { m_maximumSAPPeriod = val; return *this; };
    RepresentationBase &maximumSAPPeriod(const std::optional<double> &val) { m_maximumSAPPeriod = val; return *this; };
    RepresentationBase &maximumSAPPeriod(std::optional<double> &&val) { m_maximumSAPPeriod = std::move(val); return *this; };
 
    // @startWithSAP

    bool hasStartWithSAP() const { return m_startWithSAP.has_value(); };

    const std::optional<SAP> &startWithSAP() const { return m_startWithSAP; };

    RepresentationBase &startWithSAP(const std::nullopt_t&) { m_startWithSAP.reset(); return *this; };

    RepresentationBase &startWithSAP(const SAP &val) { m_startWithSAP = val; return *this; };
    RepresentationBase &startWithSAP(SAP &&val) { m_startWithSAP = std::move(val); return *this; };
    RepresentationBase &startWithSAP(const std::optional<SAP> &val) { m_startWithSAP = val; return *this; };
    RepresentationBase &startWithSAP(std::optional<SAP> &&val) { m_startWithSAP = std::move(val); return *this; };
 
    // @maxPlayoutRate

    bool hasMaxPlayoutRate() const { return m_maxPlayoutRate.has_value(); };

    const std::optional<double> &maxPlayoutRate() const { return m_maxPlayoutRate; };

    RepresentationBase &maxPlayoutRate(const std::nullopt_t&) { m_maxPlayoutRate.reset(); return *this; };

    RepresentationBase &maxPlayoutRate(double val) { m_maxPlayoutRate = val; return *this; };
    RepresentationBase &maxPlayoutRate(const std::optional<double> &val) { m_maxPlayoutRate = val; return *this; };
    RepresentationBase &maxPlayoutRate(std::optional<double> &&val) { m_maxPlayoutRate = std::move(val); return *this; };
 
    // @codingDependency

    bool hasCodingDependency() const { return m_codingDependency.has_value(); };

    const std::optional<bool> &codingDependency() const { return m_codingDependency; };

    RepresentationBase &codingDependency(const std::nullopt_t&) { m_codingDependency.reset(); return *this; };

    RepresentationBase &codingDependency(bool val) { m_codingDependency = val; return *this; };
    RepresentationBase &codingDependency(const std::optional<bool> &val) { m_codingDependency = val; return *this; };
    RepresentationBase &codingDependency(std::optional<bool> &&val) { m_codingDependency = std::move(val); return *this; };
 
    // @scanType

    bool hasScanType() const { return m_scanType.has_value(); };

    const std::optional<VideoScan> &scanType() const { return m_scanType; };

    RepresentationBase &scanType(const std::nullopt_t&) { m_scanType.reset(); return *this; };

    RepresentationBase &scanType(const VideoScan &val) { m_scanType = val; return *this; };
    RepresentationBase &scanType(VideoScan &&val) { m_scanType = std::move(val); return *this; };
    RepresentationBase &scanType(const std::optional<VideoScan> &val) { m_scanType = val; return *this; };
    RepresentationBase &scanType(std::optional<VideoScan> &&val) { m_scanType = std::move(val); return *this; };
 
    // @selectionPriority

    unsigned int selectionPriority() const { return m_selectionPriority; };

    RepresentationBase &selectionPriority(unsigned int val) { m_selectionPriority = val; return *this; };
 
    // @tag

    bool hasTag() const { return m_tag.has_value(); };

    const std::optional<std::string> &tag() const { return m_tag; };

    RepresentationBase &tag(const std::nullopt_t&) { m_tag.reset(); return *this; };

    RepresentationBase &tag(const std::string &val) { m_tag = val; return *this; };
    RepresentationBase &tag(std::string &&val) { m_tag = std::move(val); return *this; };
    RepresentationBase &tag(const std::optional<std::string> &val) { m_tag = val; return *this; };
    RepresentationBase &tag(std::optional<std::string> &&val) { m_tag = std::move(val); return *this; };
 
    // FramePacking children

    const std::list<Descriptor> &framePackings() const { return m_framePackings; };

    RepresentationBase &framePackings(const std::list<Descriptor> &packings) { m_framePackings = packings; return *this; };
    RepresentationBase &framePackings(std::list<Descriptor> &&packings) { m_framePackings = std::move(packings); return *this; };

    std::list<Descriptor>::const_iterator framePackingsBegin() const { return m_framePackings.cbegin(); };
    std::list<Descriptor>::iterator framePackingsBegin() { return m_framePackings.begin(); };

    std::list<Descriptor>::const_iterator framePackingsEnd() const { return m_framePackings.cend(); };
    std::list<Descriptor>::iterator framePackingsEnd() { return m_framePackings.end(); };

    const Descriptor &framePacking(std::list<Descriptor>::size_type idx) const;

    RepresentationBase &framePackingsAdd(const Descriptor &val) { m_framePackings.push_back(val); return *this; };
    RepresentationBase &framePackingsAdd(Descriptor &&val) { m_framePackings.push_back(std::move(val)); return *this; };

    RepresentationBase &framePackingsRemove(const Descriptor &val);

    RepresentationBase &framePackingsRemove(const std::list<Descriptor>::const_iterator &it);
    RepresentationBase &framePackingsRemove(const std::list<Descriptor>::iterator &it);
 
    // AudioChannelConfiguration children

    const std::list<Descriptor> &audioChannelConfigurations() const { return m_audioChannelConfigurations; };

    RepresentationBase &audioChannelConfigurations(const std::list<Descriptor> &packings) { m_audioChannelConfigurations = packings; return *this; };
    RepresentationBase &audioChannelConfigurations(std::list<Descriptor> &&packings) { m_audioChannelConfigurations = std::move(packings); return *this; };

    std::list<Descriptor>::const_iterator audioChannelConfigurationsBegin() const { return m_audioChannelConfigurations.cbegin(); };
    std::list<Descriptor>::iterator audioChannelConfigurationsBegin() { return m_audioChannelConfigurations.begin(); };

    std::list<Descriptor>::const_iterator audioChannelConfigurationsEnd() const { return m_audioChannelConfigurations.cend(); };
    std::list<Descriptor>::iterator audioChannelConfigurationsEnd() { return m_audioChannelConfigurations.end(); };

    const Descriptor &audioChannelConfiguration(std::list<Descriptor>::size_type idx) const;

    RepresentationBase &audioChannelConfigurationsAdd(const Descriptor &val) {
        m_audioChannelConfigurations.push_back(val); return *this;
    };
    RepresentationBase &audioChannelConfigurationsAdd(Descriptor &&val) {
        m_audioChannelConfigurations.push_back(std::move(val)); return *this;
    };


    RepresentationBase &audioChannelConfigurationsRemove(const Descriptor &val);

    RepresentationBase &audioChannelConfigurationsRemove(const std::list<Descriptor>::const_iterator &it);
    RepresentationBase &audioChannelConfigurationsRemove(const std::list<Descriptor>::iterator &it);
 
    // ContentProtection children

    const std::list<ContentProtection> &contentProtections() const { return m_contentProtections; };

    RepresentationBase &contentProtections(const std::list<ContentProtection> &protections) {
        m_contentProtections = protections; return *this;
    };
    RepresentationBase &contentProtections(std::list<ContentProtection> &&protections) {
        m_contentProtections = std::move(protections); return *this;
    };


    std::list<ContentProtection>::const_iterator contentProtectionsBegin() const { return m_contentProtections.cbegin(); };
    std::list<ContentProtection>::iterator contentProtectionsBegin() { return m_contentProtections.begin(); };

    std::list<ContentProtection>::const_iterator contentProtectionsEnd() const { return m_contentProtections.cend(); };
    std::list<ContentProtection>::iterator contentProtectionsEnd() { return m_contentProtections.end(); };

    const ContentProtection &contentProtection(std::list<ContentProtection>::size_type idx) const;

    RepresentationBase &contentProtectionsAdd(const ContentProtection &val) {
        m_contentProtections.push_back(val); return *this;
    };
    RepresentationBase &contentProtectionsAdd(ContentProtection &&val) {
        m_contentProtections.push_back(std::move(val)); return *this;
    };


    RepresentationBase &contentProtectionsRemove(const ContentProtection &val);

    RepresentationBase &contentProtectionsRemove(const std::list<ContentProtection>::const_iterator &it);
    RepresentationBase &contentProtectionsRemove(const std::list<ContentProtection>::iterator &it);
 
    // OutputProtection child

    bool hasOutputProtection() const { return m_outputProtection.has_value(); };

    const std::optional<Descriptor> &outputProtection() const { return m_outputProtection; };

    RepresentationBase &outputProtection(const std::nullopt_t&) { m_outputProtection.reset(); return *this; };

    RepresentationBase &outputProtection(const Descriptor &val) { m_outputProtection = val; return *this; };
    RepresentationBase &outputProtection(Descriptor &&val) { m_outputProtection = std::move(val); return *this; };
    RepresentationBase &outputProtection(const std::optional<Descriptor> &val) { m_outputProtection = val; return *this; };
    RepresentationBase &outputProtection(std::optional<Descriptor> &&val) { m_outputProtection = std::move(val); return *this; };
 
    // EssentialProperty children

    const std::list<Descriptor> &essentialProperties() const { return m_essentialProperties; };

    RepresentationBase &essentialProperties(const std::list<Descriptor> &properties) {
        m_essentialProperties = properties; return *this;
    };
    RepresentationBase &essentialProperties(std::list<Descriptor> &&properties) {
        m_essentialProperties = std::move(properties); return *this;
    };


    std::list<Descriptor>::const_iterator essentialPropertiesBegin() const { return m_essentialProperties.cbegin(); };
    std::list<Descriptor>::iterator essentialPropertiesBegin() { return m_essentialProperties.begin(); };

    std::list<Descriptor>::const_iterator essentialPropertiesEnd() const { return m_essentialProperties.cend(); };
    std::list<Descriptor>::iterator essentialPropertiesEnd() { return m_essentialProperties.end(); };

    const Descriptor &essentialProperty(std::list<Descriptor>::size_type idx) const;

    RepresentationBase &essentialPropertiesAdd(const Descriptor &val) { m_essentialProperties.push_back(val); return *this; };
    RepresentationBase &essentialPropertiesAdd(Descriptor &&val) { m_essentialProperties.push_back(std::move(val)); return *this; };

    RepresentationBase &essentialPropertiesRemove(const Descriptor &val);

    RepresentationBase &essentialPropertiesRemove(const std::list<Descriptor>::const_iterator &it);
    RepresentationBase &essentialPropertiesRemove(const std::list<Descriptor>::iterator &it);
 
    // SupplementalProperty children

    const std::list<Descriptor> &supplementalProperties() const { return m_supplementalProperties; };

    RepresentationBase &supplementalProperties(const std::list<Descriptor> &properties) {
        m_supplementalProperties = properties; return *this;
    };
    RepresentationBase &supplementalProperties(std::list<Descriptor> &&properties) {
        m_supplementalProperties = std::move(properties); return *this;
    };


    std::list<Descriptor>::const_iterator supplementalPropertiesBegin() const { return m_supplementalProperties.cbegin(); };
    std::list<Descriptor>::iterator supplementalPropertiesBegin() { return m_supplementalProperties.begin(); };

    std::list<Descriptor>::const_iterator supplementalPropertiesEnd() const { return m_supplementalProperties.cend(); };
    std::list<Descriptor>::iterator supplementalPropertiesEnd() { return m_supplementalProperties.end(); };

    const Descriptor &supplementalProperty(std::list<Descriptor>::size_type idx) const;

    RepresentationBase &supplementalPropertiesAdd(const Descriptor &val) { m_supplementalProperties.push_back(val); return *this; };
    RepresentationBase &supplementalPropertiesAdd(Descriptor &&val) { m_supplementalProperties.push_back(std::move(val)); return *this; };

    RepresentationBase &supplementalPropertiesRemove(const Descriptor &val);

    RepresentationBase &supplementalPropertiesRemove(const std::list<Descriptor>::const_iterator &it);
    RepresentationBase &supplementalPropertiesRemove(const std::list<Descriptor>::iterator &it);
 
    // InbandEventStream children

    const std::list<EventStream> &inbandEventStreams() const { return m_inbandEventStreams; };

    RepresentationBase &inbandEventStreams(const std::list<EventStream> &streams) {
        m_inbandEventStreams = streams; return *this;
    };
    RepresentationBase &inbandEventStreams(std::list<EventStream> &&streams) {
        m_inbandEventStreams = std::move(streams); return *this;
    };


    std::list<EventStream>::const_iterator inbandEventStreamsBegin() const { return m_inbandEventStreams.cbegin(); };
    std::list<EventStream>::iterator inbandEventStreamsBegin() { return m_inbandEventStreams.begin(); };

    std::list<EventStream>::const_iterator inbandEventStreamsEnd() const { return m_inbandEventStreams.cend(); };
    std::list<EventStream>::iterator inbandEventStreamsEnd() { return m_inbandEventStreams.end(); };

    const EventStream &inbandEventStream(std::list<EventStream>::size_type idx) const;

    RepresentationBase &inbandEventStreamsAdd(const EventStream &val) {
        m_inbandEventStreams.push_back(val); return *this;
    };
    RepresentationBase &inbandEventStreamsAdd(EventStream &&val) {
        m_inbandEventStreams.push_back(std::move(val)); return *this;
    };


    RepresentationBase &inbandEventStreamsRemove(const EventStream &val);

    RepresentationBase &inbandEventStreamsRemove(const std::list<EventStream>::const_iterator &it);
    RepresentationBase &inbandEventStreamsRemove(const std::list<EventStream>::iterator &it);
 
    // Switching children

    const std::list<Switching> &switchings() const { return m_switchings; };

    RepresentationBase &switchings(const std::list<Switching> &_switchings) {
        m_switchings = _switchings; return *this;
    };
    RepresentationBase &switchings(std::list<Switching> &&_switchings) {
        m_switchings = std::move(_switchings); return *this;
    };


    std::list<Switching>::const_iterator switchingsBegin() const { return m_switchings.cbegin(); };
    std::list<Switching>::iterator switchingsBegin() { return m_switchings.begin(); };

    std::list<Switching>::const_iterator switchingsEnd() const { return m_switchings.cend(); };
    std::list<Switching>::iterator switchingsEnd() { return m_switchings.end(); };

    const Switching &switching(std::list<Switching>::size_type idx) const;

    RepresentationBase &switchingsAdd(const Switching &val) {
        m_switchings.push_back(val); return *this;
    };
    RepresentationBase &switchingsAdd(Switching &&val) {
        m_switchings.push_back(std::move(val)); return *this;
    };


    RepresentationBase &switchingsRemove(const Switching &val);

    RepresentationBase &switchingsRemove(const std::list<Switching>::const_iterator &it);
    RepresentationBase &switchingsRemove(const std::list<Switching>::iterator &it);
 
    // RandomAccess children

    const std::list<RandomAccess> &randomAccesses() const { return m_randomAccesses; };

    RepresentationBase &randomAccesses(const std::list<RandomAccess> &accesses) {
        m_randomAccesses = accesses; return *this;
    };
    RepresentationBase &randomAccesses(std::list<RandomAccess> &&accesses) {
        m_randomAccesses = std::move(accesses); return *this;
    };


    std::list<RandomAccess>::const_iterator randomAccessesBegin() const { return m_randomAccesses.cbegin(); };
    std::list<RandomAccess>::iterator randomAccessesBegin() { return m_randomAccesses.begin(); };

    std::list<RandomAccess>::const_iterator randomAccessesEnd() const { return m_randomAccesses.cend(); };
    std::list<RandomAccess>::iterator randomAccessesEnd() { return m_randomAccesses.end(); };

    const RandomAccess &randomAccess(std::list<RandomAccess>::size_type idx) const;

    RepresentationBase &randomAccessesAdd(const RandomAccess &val) {
        m_randomAccesses.push_back(val); return *this;
    };
    RepresentationBase &randomAccessesAdd(RandomAccess &&val) {
        m_randomAccesses.push_back(std::move(val)); return *this;
    };


    RepresentationBase &randomAccessesRemove(const RandomAccess &val);

    RepresentationBase &randomAccessesRemove(const std::list<RandomAccess>::const_iterator &it);
    RepresentationBase &randomAccessesRemove(const std::list<RandomAccess>::iterator &it);
 
    // GroupLabel children

    const std::list<Label> &groupLabels() const { return m_groupLabels; };

    RepresentationBase &groupLabels(const std::list<Label> &labels) {
        m_groupLabels = labels; return *this;
    };
    RepresentationBase &groupLabels(std::list<Label> &&labels) {
        m_groupLabels = std::move(labels); return *this;
    };


    std::list<Label>::const_iterator groupLabelsBegin() const { return m_groupLabels.cbegin(); };
    std::list<Label>::iterator groupLabelsBegin() { return m_groupLabels.begin(); };

    std::list<Label>::const_iterator groupLabelsEnd() const { return m_groupLabels.cend(); };
    std::list<Label>::iterator groupLabelsEnd() { return m_groupLabels.end(); };

    const Label &groupLabel(std::list<Label>::size_type idx) const;

    RepresentationBase &groupLabelsAdd(const Label &val) {
        m_groupLabels.push_back(val); return *this;
    };
    RepresentationBase &groupLabelsAdd(Label &&val) {
        m_groupLabels.push_back(std::move(val)); return *this;
    };


    RepresentationBase &groupLabelsRemove(const Label &val);

    RepresentationBase &groupLabelsRemove(const std::list<Label>::const_iterator &it);
    RepresentationBase &groupLabelsRemove(const std::list<Label>::iterator &it);
 
    // Label children

    const std::list<Label> &labels() const { return m_labels; };

    RepresentationBase &labels(const std::list<Label> &_labels) {
        m_labels = _labels; return *this;
    };
    RepresentationBase &labels(std::list<Label> &&_labels) {
        m_labels = std::move(_labels); return *this;
    };


    std::list<Label>::const_iterator labelsBegin() const { return m_labels.cbegin(); };
    std::list<Label>::iterator labelsBegin() { return m_labels.begin(); };

    std::list<Label>::const_iterator labelsEnd() const { return m_labels.cend(); };
    std::list<Label>::iterator labelsEnd() { return m_labels.end(); };

    const Label &label(std::list<Label>::size_type idx) const;

    RepresentationBase &labelsAdd(const Label &val) {
        m_labels.push_back(val); return *this;
    };
    RepresentationBase &labelsAdd(Label &&val) {
        m_labels.push_back(std::move(val)); return *this;
    };


    RepresentationBase &labelsRemove(const Label &val);

    RepresentationBase &labelsRemove(const std::list<Label>::const_iterator &it);
    RepresentationBase &labelsRemove(const std::list<Label>::iterator &it);
 
    // ProducerReferenceTime children

    const std::list<ProducerReferenceTime> &producerReferenceTimes() const { return m_producerReferenceTimes; };

    RepresentationBase &producerReferenceTimes(const std::list<ProducerReferenceTime> &times) {
        m_producerReferenceTimes = times; return *this;
    };
    RepresentationBase &producerReferenceTimes(std::list<ProducerReferenceTime> &&times) {
        m_producerReferenceTimes = std::move(times); return *this;
    };


    std::list<ProducerReferenceTime>::const_iterator producerReferenceTimesBegin() const { return m_producerReferenceTimes.cbegin(); };
    std::list<ProducerReferenceTime>::iterator producerReferenceTimesBegin() { return m_producerReferenceTimes.begin(); };

    std::list<ProducerReferenceTime>::const_iterator producerReferenceTimesEnd() const { return m_producerReferenceTimes.cend(); };
    std::list<ProducerReferenceTime>::iterator producerReferenceTimesEnd() { return m_producerReferenceTimes.end(); };

    const ProducerReferenceTime &producerReferenceTime(std::list<ProducerReferenceTime>::size_type idx) const;

    RepresentationBase &producerReferenceTimesAdd(const ProducerReferenceTime &val) {
        m_producerReferenceTimes.push_back(val); return *this;
    };
    RepresentationBase &producerReferenceTimesAdd(ProducerReferenceTime &&val) {
        m_producerReferenceTimes.push_back(std::move(val)); return *this;
    };


    RepresentationBase &producerReferenceTimesRemove(const ProducerReferenceTime &val);

    RepresentationBase &producerReferenceTimesRemove(const std::list<ProducerReferenceTime>::const_iterator &it);
    RepresentationBase &producerReferenceTimesRemove(const std::list<ProducerReferenceTime>::iterator &it);
 
    // ContentPopularityRate children

    const std::list<ContentPopularityRate> &contentPopularityRates() const { return m_contentPopularityRates; };

    RepresentationBase &contentPopularityRates(const std::list<ContentPopularityRate> &rates) {
        m_contentPopularityRates = rates; return *this;
    };
    RepresentationBase &contentPopularityRates(std::list<ContentPopularityRate> &&rates) {
        m_contentPopularityRates = std::move(rates); return *this;
    };


    std::list<ContentPopularityRate>::const_iterator contentPopularityRatesBegin() const { return m_contentPopularityRates.cbegin(); };
    std::list<ContentPopularityRate>::iterator contentPopularityRatesBegin() { return m_contentPopularityRates.begin(); };

    std::list<ContentPopularityRate>::const_iterator contentPopularityRatesEnd() const { return m_contentPopularityRates.cend(); };
    std::list<ContentPopularityRate>::iterator contentPopularityRatesEnd() { return m_contentPopularityRates.end(); };

    const ContentPopularityRate &contentPopularityRate(std::list<ContentPopularityRate>::size_type idx) const;

    RepresentationBase &contentPopularityRatesAdd(const ContentPopularityRate &val) {
        m_contentPopularityRates.push_back(val); return *this;
    };
    RepresentationBase &contentPopularityRatesAdd(ContentPopularityRate &&val) {
        m_contentPopularityRates.push_back(std::move(val)); return *this;
    };


    RepresentationBase &contentPopularityRatesRemove(const ContentPopularityRate &val);

    RepresentationBase &contentPopularityRatesRemove(const std::list<ContentPopularityRate>::const_iterator &it);
    RepresentationBase &contentPopularityRatesRemove(const std::list<ContentPopularityRate>::iterator &it);
 
    // Resync children

    const std::list<Resync> &resyncs() const { return m_resyncs; };

    RepresentationBase &resyncs(const std::list<Resync> &_resyncs) {
        m_resyncs = _resyncs; return *this;
    };
    RepresentationBase &resyncs(std::list<Resync> &&_resyncs) {
        m_resyncs = std::move(_resyncs); return *this;
    };


    std::list<Resync>::const_iterator resyncsBegin() const { return m_resyncs.cbegin(); };
    std::list<Resync>::iterator resyncsBegin() { return m_resyncs.begin(); };

    std::list<Resync>::const_iterator resyncsEnd() const { return m_resyncs.cend(); };
    std::list<Resync>::iterator resyncsEnd() { return m_resyncs.end(); };

    const Resync &resync(std::list<Resync>::size_type idx) const;

    RepresentationBase &resyncsAdd(const Resync &val) {
        m_resyncs.push_back(val); return *this;
    };
    RepresentationBase &resyncsAdd(Resync &&val) {
        m_resyncs.push_back(std::move(val)); return *this;
    };


    RepresentationBase &resyncsRemove(const Resync &val);

    RepresentationBase &resyncsRemove(const std::list<Resync>::const_iterator &it);
    RepresentationBase &resyncsRemove(const std::list<Resync>::iterator &it);

protected:
    RepresentationBase(xmlpp::Node &node);

    void setXMLElement(xmlpp::Element &elem) const;

 
private:
    // RepresentationBase attributes (ISO 23009-1:2022 Clause 5.3.7.3)
    std::list<URI>              m_profiles;
    std::optional<unsigned int> m_width;
    std::optional<unsigned int> m_height;
    std::optional<Ratio>        m_sar;
    std::optional<FrameRate>    m_frameRate;
    std::list<unsigned int>     m_audioSamplingRates; // if present must contain 1 or 2 entries
    std::optional<std::string>  m_mimeType;
    std::list<std::string>      m_segmentProfiles;
    std::optional<Codecs>       m_codecs;
    std::list<std::string>      m_containerProfiles;
    std::optional<double>       m_maximumSAPPeriod;
    std::optional<SAP>          m_startWithSAP;
    std::optional<double>       m_maxPlayoutRate;
    std::optional<bool>         m_codingDependency;
    std::optional<VideoScan>    m_scanType;
    unsigned int                m_selectionPriority; // default = 1
    std::optional<std::string>  m_tag;
 
    // RepresentationBase child elements (ISO 23009-1:2022 Clause 5.3.7.3)
    std::list<Descriptor>            m_framePackings;
    std::list<Descriptor>            m_audioChannelConfigurations;
    std::list<ContentProtection>     m_contentProtections;
    std::optional<Descriptor>        m_outputProtection;
    std::list<Descriptor>            m_essentialProperties;
    std::list<Descriptor>            m_supplementalProperties;
    std::list<EventStream>           m_inbandEventStreams;
    std::list<Switching>             m_switchings;
    std::list<RandomAccess>          m_randomAccesses;
    std::list<Label>                 m_groupLabels;
    std::list<Label>                 m_labels;
    std::list<ProducerReferenceTime> m_producerReferenceTimes;
    std::list<ContentPopularityRate> m_contentPopularityRates;
    std::list<Resync>                m_resyncs;
};
 
LIBMPDPP_NAMESPACE_END
 
/* vim:ts=8:sts=4:sw=4:expandtab:
 */
#endif /*_BBC_PARSE_DASH_MPD_REPRESENTATION_BASE_HH_*/