genericcontainer.h

Go to the documentation of this file.

#ifndef TAG_PARSER_GENERICCONTAINER_H
#define TAG_PARSER_GENERICCONTAINER_H
 
#include "./abstractcontainer.h"
 
#include <algorithm>
#include <memory>
#include <vector>
 
namespace TagParser {

template <class FileInfoType, class TagType, class TrackType, class ElementType> class TAG_PARSER_EXPORT GenericContainer : public AbstractContainer {
    friend FileInfoType;
 
public:
    GenericContainer(FileInfoType &fileInfo, std::uint64_t startOffset);
    ~GenericContainer() override;
 
    void validateElementStructure(Diagnostics &diag, AbortableProgressFeedback &progress, std::uint64_t *paddingSize = nullptr);
    FileInfoType &fileInfo() const;
    ElementType *firstElement() const;
    const std::vector<std::unique_ptr<ElementType>> &additionalElements() const;
    std::vector<std::unique_ptr<ElementType>> &additionalElements();
    TagType *tag(std::size_t index) override;
    std::size_t tagCount() const override;
    TrackType *track(std::size_t index) override;
    TrackType *trackById(std::uint64_t id);
    std::size_t trackCount() const override;
    const std::vector<std::unique_ptr<TagType>> &tags() const;
    std::vector<std::unique_ptr<TagType>> &tags();
    const std::vector<std::unique_ptr<TrackType>> &tracks() const;
    std::vector<std::unique_ptr<TrackType>> &tracks();
 
    TagType *createTag(const TagTarget &target = TagTarget()) override;
    bool removeTag(Tag *tag) override;
    void removeAllTags() override;
    bool addTrack(TrackType *track);
    bool removeTrack(AbstractTrack *track) override;
    void removeAllTracks() override;
    void reset() override;
 
    using ContainerFileInfoType = FileInfoType;
    using ContainerTagType = TagType;
    using ContainerTrackType = TrackType;
    using ContainerElementType = ElementType;
 
protected:
    std::unique_ptr<ElementType> m_firstElement;
    std::vector<std::unique_ptr<ElementType>> m_additionalElements;
    std::vector<std::unique_ptr<TagType>> m_tags;
    std::vector<std::unique_ptr<TrackType>> m_tracks;
 
private:
    FileInfoType *m_fileInfo;
};

template <class FileInfoType, class TagType, class TrackType, class ElementType>
GenericContainer<FileInfoType, TagType, TrackType, ElementType>::GenericContainer(FileInfoType &fileInfo, std::uint64_t startOffset)
    : AbstractContainer(fileInfo.stream(), startOffset)
    , m_fileInfo(&fileInfo)
{
}
GenericContainer<FileInfoType, TagType, TrackType, ElementType>::GenericContainer(FileInfoType &fileInfo, std::uint64_t startOffset) {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
GenericContainer<FileInfoType, TagType, TrackType, ElementType>::~GenericContainer()
{
}
GenericContainer<FileInfoType, TagType, TrackType, ElementType>::~GenericContainer() {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::validateElementStructure(
    Diagnostics &diag, AbortableProgressFeedback &progress, std::uint64_t *paddingSize)
{
    parseHeader(diag, progress);
    if (m_firstElement) {
        m_firstElement->validateSubsequentElementStructure(diag, paddingSize, &progress);
    }
}
inline void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::validateElementStructure( {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline FileInfoType &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::fileInfo() const
{
    return *m_fileInfo;
}
inline FileInfoType &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::fileInfo() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline ElementType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::firstElement() const
{
    return m_firstElement.get();
}
inline ElementType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::firstElement() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline const std::vector<std::unique_ptr<ElementType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::additionalElements() const
{
    return m_additionalElements;
}
inline const std::vector<std::unique_ptr<ElementType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::additionalElements() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline std::vector<std::unique_ptr<ElementType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::additionalElements()
{
    return m_additionalElements;
}
inline std::vector<std::unique_ptr<ElementType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::additionalElements() {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline TagType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tag(std::size_t index)
{
    return m_tags[index].get();
}
inline TagType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tag(std::size_t index) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline std::size_t GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tagCount() const
{
    return m_tags.size();
}
inline std::size_t GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tagCount() const {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline TrackType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::track(std::size_t index)
{
    return m_tracks[index].get();
}
inline TrackType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::track(std::size_t index) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline TrackType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::trackById(std::uint64_t id)
{
    for (auto &track : m_tracks) {
        if (track->id() == id) {
            return track.get();
        }
    }
    return nullptr;
}
inline TrackType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::trackById(std::uint64_t id) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline std::size_t GenericContainer<FileInfoType, TagType, TrackType, ElementType>::trackCount() const
{
    return m_tracks.size();
}
inline std::size_t GenericContainer<FileInfoType, TagType, TrackType, ElementType>::trackCount() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline const std::vector<std::unique_ptr<TagType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tags() const
{
    return m_tags;
}
inline const std::vector<std::unique_ptr<TagType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tags() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline std::vector<std::unique_ptr<TagType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tags()
{
    return m_tags;
}
inline std::vector<std::unique_ptr<TagType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tags() {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline const std::vector<std::unique_ptr<TrackType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tracks() const
{
    return m_tracks;
}
inline const std::vector<std::unique_ptr<TrackType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tracks() const {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline std::vector<std::unique_ptr<TrackType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tracks()
{
    return m_tracks;
}
inline std::vector<std::unique_ptr<TrackType>> &GenericContainer<FileInfoType, TagType, TrackType, ElementType>::tracks() {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
TagType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::createTag(const TagTarget &target)
{
    // check whether a tag matching the specified target is already assigned
    if (!m_tags.empty()) {
        if (!target.isEmpty() && m_tags.front()->supportsTarget()) {
            for (auto &tag : m_tags) {
                if (tag->target() == target) {
                    return tag.get();
                }
            }
        } else {
            return m_tags.front().get();
        }
    }
 
    // a new tag must be created
    const auto &tag = m_tags.emplace_back(std::make_unique<TagType>());
    tag->setTarget(target);
    return tag.get();
}
TagType *GenericContainer<FileInfoType, TagType, TrackType, ElementType>::createTag(const TagTarget &target) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeTag(Tag *tag)
{
    if (const auto size = m_tags.size()) {
        m_tags.erase(std::remove_if(m_tags.begin(), m_tags.end(),
                         [tag](const std::unique_ptr<TagType> &existingTag) -> bool { return static_cast<Tag *>(existingTag.get()) == tag; }),
            m_tags.end());
        return size != m_tags.size();
    }
    return false;
}
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeTag(Tag *tag) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
inline void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeAllTags()
{
    m_tags.clear();
}
inline void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeAllTags() {…}

template <class FileInfoType, class TagType, class TrackType, class ElementType>
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::addTrack(TrackType *track)
{
    if (!areTracksParsed() || !supportsTrackModifications()) {
        return false;
    }
    // ensure ID is unique
    auto id = track->id();
ensureIdIsUnique:
    for (const auto &existingTrack : m_tracks) {
        if (existingTrack->id() == id) {
            ++id;
            goto ensureIdIsUnique;
        }
    }
    track->setId(id);
 
    m_tracks.emplace_back(track);
    return m_tracksAltered = true;
}
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::addTrack(TrackType *track) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeTrack(AbstractTrack *track)
{
    if (!areTracksParsed() || !supportsTrackModifications() || m_tracks.empty()) {
        return false;
    }
    auto removed = false;
    for (auto i = m_tracks.end() - 1, begin = m_tracks.begin();; --i) {
        if (static_cast<AbstractTrack *>(i->get()) == track) {
            i->release();
            m_tracks.erase(i);
            removed = true;
        }
        if (i == begin) {
            break;
        }
    }
    if (removed) {
        m_tracksAltered = true;
    }
    return removed;
}
bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeTrack(AbstractTrack *track) {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeAllTracks()
{
    if (areTracksParsed() && supportsTrackModifications() && m_tracks.size()) {
        m_tracks.clear();
        m_tracksAltered = true;
    }
}
void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::removeAllTracks() {…}
 
template <class FileInfoType, class TagType, class TrackType, class ElementType>
void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::reset()
{
    AbstractContainer::reset();
    m_firstElement.reset();
    m_additionalElements.clear();
    m_tracks.clear();
    m_tags.clear();
}
void GenericContainer<FileInfoType, TagType, TrackType, ElementType>::reset() {…}
    void reset() override; {…}
 
} // namespace TagParser
 
#endif // TAG_PARSER_GENERICCONTAINER_H
    void removeAllTracks() override; {…}
    bool removeTrack(AbstractTrack *track) override; {…}
    bool addTrack(TrackType *track); {…}
    void removeAllTags() override; {…}
    bool removeTag(Tag *tag) override; {…}
    TagType *createTag(const TagTarget &target = TagTarget()) override; {…}
    std::vector<std::unique_ptr<TrackType>> &tracks(); {…}
    const std::vector<std::unique_ptr<TrackType>> &tracks() const; {…}
    std::vector<std::unique_ptr<TagType>> &tags(); {…}
    const std::vector<std::unique_ptr<TagType>> &tags() const; {…}
    std::size_t trackCount() const override; {…}
    TrackType *trackById(std::uint64_t id); {…}
    TrackType *track(std::size_t index) override; {…}
    std::size_t tagCount() const override; {…}
    TagType *tag(std::size_t index) override; {…}
    std::vector<std::unique_ptr<ElementType>> &additionalElements(); {…}
    const std::vector<std::unique_ptr<ElementType>> &additionalElements() const; {…}
    ElementType *firstElement() const; {…}
    FileInfoType &fileInfo() const; {…}
    void validateElementStructure(Diagnostics &diag, AbortableProgressFeedback &progress, std::uint64_t *paddingSize = nullptr); {…}
    ~GenericContainer() override; {…}
    GenericContainer(FileInfoType &fileInfo, std::uint64_t startOffset); {…}
template <class FileInfoType, class TagType, class TrackType, class ElementType> class TAG_PARSER_EXPORT GenericContainer : public AbstractContainer {…};