ContentPopularityRate.hh

Go to the documentation of this file.

#ifndef _BBC_PARSE_DASH_MPD_CONTENT_POPULARITY_RATE_HH_
#define _BBC_PARSE_DASH_MPD_CONTENT_POPULARITY_RATE_HH_
/*****************************************************************************
 * DASH MPD parsing library in C++: ContentPopularityRate 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 <list>
#include <optional>
 
#include "macros.hh"

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

class LIBMPDPP_PUBLIC_API ContentPopularityRate {
public:

    class LIBMPDPP_PUBLIC_API PR {
    public:
        PR() = delete;

        PR(const std::optional<unsigned int> &popularity_rate = std::nullopt,
           const std::optional<unsigned long> &start = std::nullopt,
           int r = 0)
            :m_popularityRate(popularity_rate)
            ,m_start(start)
            ,m_r(r)
        {
            if (popularity_rate < 1 || popularity_rate > 100)
                throw std::out_of_range("popularityRate attribute of PR element must be between 1 and 100 inclusive.");
        };

        PR(const PR &other)
            :m_popularityRate(other.m_popularityRate)
            ,m_start(other.m_start)
            ,m_r(other.m_r)
        {};

        PR(PR &&other)
            :m_popularityRate(std::move(other.m_popularityRate))
            ,m_start(std::move(other.m_start))
            ,m_r(other.m_r)
        {};

        virtual ~PR() {};

        PR &operator=(const PR &other) {
            m_popularityRate = other.m_popularityRate;
            m_start = other.m_start;
            m_r = other.m_r;
            return *this;
        };
        PR &operator=(PR &&other) {
            m_popularityRate = std::move(other.m_popularityRate);
            m_start = std::move(other.m_start);
            m_r = other.m_r;
            return *this;
        };


        bool operator==(const PR &other) {
            if (m_r != other.m_r) return false;
            if (m_popularityRate != other.m_popularityRate) return false;
            if (m_start != other.m_start) return false;
            return true;
        }

        bool operator!=(const PR &other) { return !(*this == other); };
 
        // @popularityRate

        bool hasPopularityRate() const { return m_popularityRate.has_value(); };

        const std::optional<unsigned int> &popularityRate() const { return m_popularityRate; };

        PR &popularityRate(const std::nullopt_t&) { m_popularityRate.reset(); return *this; };

        PR &popularityRate(unsigned int val) { m_popularityRate = val; return *this; };
        PR &popularityRate(const std::optional<unsigned int> &val) { m_popularityRate = val; return *this; };
        PR &popularityRate(std::optional<unsigned int> &&val) { m_popularityRate = std::move(val); return *this; };
 
        // @start

        bool hasStart() const { return m_start.has_value(); };

        const std::optional<unsigned long> &start() const { return m_start; };

        PR &start(const std::nullopt_t&) { m_start.reset(); return *this; };

        PR &start(unsigned long val) { m_start = val; return *this; };
        PR &start(const std::optional<unsigned long> &val) { m_start = val; return *this; };
        PR &start(std::optional<unsigned long> &&val) { m_start = std::move(val); return *this; };
 
        // @r

        int r() const { return m_r; };

        PR &r(int val) { m_r = val; return *this; };

    protected:
        friend class ContentPopularityRate;
        PR(xmlpp::Node &node);
        void setXMLElement(xmlpp::Element &elem) const;
 
    private:
        std::optional<unsigned int>  m_popularityRate;
        std::optional<unsigned long> m_start;
        int                          m_r; // default is 0
    };

    ContentPopularityRate();

    ContentPopularityRate(const ContentPopularityRate &to_copy);

    ContentPopularityRate(ContentPopularityRate &&to_move);

    virtual ~ContentPopularityRate() {};

    ContentPopularityRate &operator=(const ContentPopularityRate &to_copy);

    ContentPopularityRate &operator=(ContentPopularityRate &&to_move);

    bool operator==(const ContentPopularityRate &to_compare) const;
 
    // PR children

    const std::list<PR> &prs() const { return m_prs; };

    std::list<PR>::const_iterator cbegin() const { return m_prs.cbegin(); };
    std::list<PR>::const_iterator begin() const { return m_prs.cbegin(); };
    std::list<PR>::iterator begin() { return m_prs.begin(); };
    std::list<PR>::const_iterator prsBegin() const { return m_prs.cbegin(); };
    std::list<PR>::iterator prsBegin() { return m_prs.begin(); };

    std::list<PR>::const_iterator cend() const { return m_prs.cend(); };
    std::list<PR>::const_iterator end() const { return m_prs.cend(); };
    std::list<PR>::iterator end() { return m_prs.end(); };
    std::list<PR>::const_iterator prsEnd() const { return m_prs.cend(); };
    std::list<PR>::iterator prsEnd() { return m_prs.end(); };

    ContentPopularityRate &prs(const std::list<PR> &prs_list) { m_prs = prs_list; return *this; };
    ContentPopularityRate &prs(std::list<PR> &&prs_list) { m_prs = std::move(prs_list); return *this; };

    ContentPopularityRate &prsAdd(const PR &pr) { m_prs.push_back(pr); return *this; };
    ContentPopularityRate &prsAdd(PR &&pr) { m_prs.push_back(std::move(pr)); return *this; };

    ContentPopularityRate &prsRemove(const PR &pr);

    ContentPopularityRate &prsRemove(const std::list<PR>::iterator &it);
    ContentPopularityRate &prsRemove(const std::list<PR>::const_iterator &it);

protected:
    friend class RepresentationBase;

    ContentPopularityRate(xmlpp::Node &node);

    void setXMLElement(xmlpp::Element &element) const;
 
private:
    // ContentPopularityRate child elements (ISO 23009-1:2022 Clause 5.14.3)
    std::list<PR> m_prs;
};
 
LIBMPDPP_NAMESPACE_END
 
/* vim:ts=8:sts=4:sw=4:expandtab:
 */
#endif /*_BBC_PARSE_DASH_MPD_CONTENT_POPULARITY_RATE_HH_*/