abstractcontainer.cpp

Go to the documentation of this file.

#include "./abstractcontainer.h"
#include "./diagnostics.h"
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
 
struct AbstractContainerPrivate {
    std::vector<std::string> muxingApps, writingApps;
};
 
AbstractContainer::AbstractContainer(iostream &stream, std::uint64_t startOffset)
    : m_version(0)
    , m_readVersion(0)
    , m_doctypeVersion(0)
    , m_doctypeReadVersion(0)
    , m_timeScale(0)
    , m_headerParsed(false)
    , m_tagsParsed(false)
    , m_tracksParsed(false)
    , m_tracksAltered(false)
    , m_chaptersParsed(false)
    , m_attachmentsParsed(false)
    , m_startOffset(startOffset)
    , m_stream(&stream)
    , m_reader(BinaryReader(m_stream))
    , m_writer(BinaryWriter(m_stream))
{
}
 
AbstractContainer::~AbstractContainer()
{
}
 
void AbstractContainer::parseHeader(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    if (!isHeaderParsed()) {
        removeAllTags();
        removeAllTracks();
        internalParseHeader(diag, progress);
        m_headerParsed = true;
    }
}
 
void AbstractContainer::parseTags(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    if (!areTagsParsed()) {
        parseHeader(diag, progress);
        internalParseTags(diag, progress);
        m_tagsParsed = true;
    }
}
 
void AbstractContainer::parseTracks(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    if (!areTracksParsed()) {
        parseHeader(diag, progress);
        internalParseTracks(diag, progress);
        m_tracksParsed = true;
        m_tracksAltered = false;
    }
}
 
void AbstractContainer::parseChapters(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    if (!areChaptersParsed()) {
        parseHeader(diag, progress);
        internalParseChapters(diag, progress);
        m_chaptersParsed = true;
    }
}
 
void AbstractContainer::parseAttachments(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    if (!areAttachmentsParsed()) {
        parseHeader(diag, progress);
        internalParseAttachments(diag, progress);
        m_attachmentsParsed = true;
    }
}
 
void AbstractContainer::makeFile(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    internalMakeFile(diag, progress);
}
 
bool AbstractContainer::supportsTrackModifications() const
{
    return false;
}
 
ElementPosition AbstractContainer::determineIndexPosition(Diagnostics &diag) const
{
    CPP_UTILITIES_UNUSED(diag);
    return ElementPosition::Keep;
}
 
void AbstractContainer::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
void AbstractContainer::internalParseTags(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
void AbstractContainer::internalParseTracks(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
void AbstractContainer::internalParseChapters(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
void AbstractContainer::internalParseAttachments(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
void AbstractContainer::internalMakeFile(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    CPP_UTILITIES_UNUSED(diag);
    CPP_UTILITIES_UNUSED(progress);
    throw NotImplementedException();
}
 
Tag *AbstractContainer::createTag(const TagTarget &)
{
    return nullptr;
}
 
Tag *AbstractContainer::tag(size_t index)
{
    CPP_UTILITIES_UNUSED(index);
    return nullptr;
}
 
size_t AbstractContainer::tagCount() const
{
    return 0;
}
 
bool AbstractContainer::removeTag(Tag *tag)
{
    CPP_UTILITIES_UNUSED(tag);
    return false;
}
 
void AbstractContainer::removeAllTags()
{
}
 
ElementPosition AbstractContainer::determineTagPosition(Diagnostics &diag) const
{
    CPP_UTILITIES_UNUSED(diag);
    return ElementPosition::Keep;
}
 
AbstractTrack *AbstractContainer::track(size_t index)
{
    CPP_UTILITIES_UNUSED(index);
    return nullptr;
}
 
size_t AbstractContainer::trackCount() const
{
    return 0;
}
 
bool AbstractContainer::removeTrack(AbstractTrack *track)
{
    CPP_UTILITIES_UNUSED(track);
    return false;
}
 
void AbstractContainer::removeAllTracks()
{
}
 
AbstractChapter *AbstractContainer::chapter(size_t index)
{
    CPP_UTILITIES_UNUSED(index);
    return nullptr;
}
 
size_t AbstractContainer::chapterCount() const
{
    return 0;
}
 
AbstractAttachment *AbstractContainer::createAttachment()
{
    return nullptr;
}
 
AbstractAttachment *AbstractContainer::attachment(size_t index)
{
    CPP_UTILITIES_UNUSED(index);
    return nullptr;
}
 
size_t AbstractContainer::attachmentCount() const
{
    return 0;
}
 
bool AbstractContainer::supportsTitle() const
{
    return false;
}
 
const std::vector<std::string> &AbstractContainer::muxingApplications() const
{
    static const auto empty = std::vector<std::string>();
    return m_p ? m_p->muxingApps : empty;
}
 
std::vector<std::string> &AbstractContainer::muxingApplications()
{
    return p()->muxingApps;
}
 
const std::vector<std::string> &AbstractContainer::writingApplications() const
{
    static const auto empty = std::vector<std::string>();
    return m_p ? m_p->writingApps : empty;
}
 
std::vector<std::string> &AbstractContainer::writingApplications()
{
    return p()->writingApps;
}
 
size_t AbstractContainer::segmentCount() const
{
    return 1;
}
 
void AbstractContainer::reset()
{
    m_headerParsed = false;
    m_tagsParsed = false;
    m_tracksParsed = false;
    m_tracksAltered = false;
    m_chaptersParsed = false;
    m_attachmentsParsed = false;
    m_version = 0;
    m_readVersion = 0;
    m_doctypeVersion = 0;
    m_doctypeReadVersion = 0;
    m_timeScale = 0;
    m_titles.clear();
}
 
std::unique_ptr<AbstractContainerPrivate> &AbstractContainer::p()
{
    if (!m_p) {
        m_p = std::make_unique<AbstractContainerPrivate>();
    }
    return m_p;
}
 
} // namespace TagParser