genericfileelement.h

Go to the documentation of this file.

#ifndef TAG_PARSER_GENERICFILEELEMENT_H
#define TAG_PARSER_GENERICFILEELEMENT_H
 
#include "./exceptions.h"
#include "./progressfeedback.h"
 
#include <c++utilities/io/copy.h>
 
#include <cstdint>
#include <initializer_list>
#include <iostream>
#include <list>
#include <memory>
#include <string>
 
namespace CppUtilities {
class BinaryReader;
class BinaryWriter;
} // namespace CppUtilities
 
namespace TagParser {
 
class Diagnostics;
 
template <typename ImplementationType> class FileElementTraits {};
 
template <class ImplementationType> class TAG_PARSER_EXPORT GenericFileElement {
    friend class FileElementTraits<ImplementationType>;
 
public:
    using ContainerType = typename FileElementTraits<ImplementationType>::ContainerType;
 
    using IdentifierType = typename FileElementTraits<ImplementationType>::IdentifierType;
 
    using DataSizeType = typename FileElementTraits<ImplementationType>::DataSizeType;
 
    GenericFileElement(ContainerType &container, std::uint64_t startOffset);
    GenericFileElement(ImplementationType &parent, std::uint64_t startOffset);
    GenericFileElement(ContainerType &container, std::uint64_t startOffset, std::uint64_t maxSize);
    GenericFileElement(const GenericFileElement &other) = delete;
    GenericFileElement(GenericFileElement &other) = delete;
    GenericFileElement &operator=(const GenericFileElement &other) = delete;
 
    ContainerType &container();
    const ContainerType &container() const;
    std::iostream &stream();
    CppUtilities::BinaryReader &reader();
    CppUtilities::BinaryWriter &writer();
    std::uint64_t startOffset() const;
    std::uint64_t relativeStartOffset() const;
    const IdentifierType &id() const;
    std::string idToString() const;
    std::uint32_t idLength() const;
    std::uint32_t headerSize() const;
    DataSizeType dataSize() const;
    std::uint32_t sizeLength() const;
    std::uint64_t dataOffset() const;
    std::uint64_t totalSize() const;
    std::uint64_t endOffset() const;
    std::uint64_t maxTotalSize() const;
    std::uint8_t level() const;
    ImplementationType *parent();
    const ImplementationType *parent() const;
    ImplementationType *parent(std::uint8_t n);
    const ImplementationType *parent(std::uint8_t n) const;
    ImplementationType *nextSibling();
    const ImplementationType *nextSibling() const;
    ImplementationType *firstChild();
    const ImplementationType *firstChild() const;
    ImplementationType *lastChild();
    const ImplementationType *lastChild() const;
    ImplementationType *subelementByPath(Diagnostics &diag, IdentifierType item);
    ImplementationType *subelementByPath(Diagnostics &diag, IdentifierType item, IdentifierType remainingPath...);
    const ImplementationType *subelementByPath(Diagnostics &diag, IdentifierType item) const;
    const ImplementationType *subelementByPath(Diagnostics &diag, IdentifierType item, IdentifierType remainingPath...) const;
    ImplementationType *childById(const IdentifierType &id, Diagnostics &diag);
    const ImplementationType *childById(const IdentifierType &id, Diagnostics &diag) const;
    ImplementationType *siblingById(const IdentifierType &id, Diagnostics &diag);
    const ImplementationType *siblingById(const IdentifierType &id, Diagnostics &diag) const;
    ImplementationType *siblingByIdIncludingThis(const IdentifierType &id, Diagnostics &diag);
    const ImplementationType *siblingByIdIncludingThis(const IdentifierType &id, Diagnostics &diag) const;
    bool isParent() const;
    bool isPadding() const;
    std::uint64_t firstChildOffset() const;
    bool isParsed() const;
    void clear();
    void parse(Diagnostics &diag);
    void reparse(Diagnostics &diag);
    void validateSubsequentElementStructure(Diagnostics &diag, std::uint64_t *paddingSize = nullptr, AbortableProgressFeedback *progress = nullptr);
    static constexpr std::uint32_t maximumIdLengthSupported();
    static constexpr std::uint32_t maximumSizeLengthSupported();
    static constexpr std::uint8_t minimumElementSize();
    template <typename TargetStream = std::ostream>
    void copyHeader(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress);
    template <typename TargetStream = std::ostream>
    void copyWithoutChilds(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress);
    template <typename TargetStream = std::ostream>
    void copyEntirely(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress);
    void makeBuffer();
    void discardBuffer();
    template <typename TargetStream = std::ostream> void copyBuffer(TargetStream &targetStream);
    template <typename TargetStream = std::ostream>
    void copyPreferablyFromBuffer(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress);
    const std::unique_ptr<char[]> &buffer();
    ImplementationType *denoteFirstChild(std::uint32_t offset);
 
protected:
    IdentifierType m_id;
    std::uint64_t m_startOffset;
    std::uint64_t m_maxSize;
    DataSizeType m_dataSize;
    std::uint32_t m_idLength;
    std::uint32_t m_sizeLength;
    ImplementationType *m_parent;
    std::unique_ptr<ImplementationType> m_nextSibling;
    std::unique_ptr<ImplementationType> m_firstChild;
    std::unique_ptr<char[]> m_buffer;
 
private:
    template <typename TargetStream = std::ostream>
    void copyInternal(
        TargetStream &targetStream, std::uint64_t startOffset, std::uint64_t bytesToCopy, Diagnostics &diag, AbortableProgressFeedback *progress);
 
    ContainerType *m_container;
    bool m_parsed;
 
protected:
    bool m_sizeUnknown;
};
 
template <class ImplementationType>
GenericFileElement<ImplementationType>::GenericFileElement(
    GenericFileElement<ImplementationType>::ContainerType &container, std::uint64_t startOffset)
    : m_id(IdentifierType())
    , m_startOffset(startOffset)
    , m_dataSize(0)
    , m_idLength(0)
    , m_sizeLength(0)
    , m_parent(nullptr)
    , m_container(&container)
    , m_parsed(false)
    , m_sizeUnknown(false)
{
    m_maxSize = container.fileInfo().size();
    if (m_maxSize > startOffset) {
        m_maxSize -= startOffset;
        stream().seekg(static_cast<std::streamoff>(startOffset), std::ios_base::beg);
    } else {
        m_maxSize = 0;
    }
}
 
template <class ImplementationType>
GenericFileElement<ImplementationType>::GenericFileElement(ImplementationType &parent, std::uint64_t startOffset)
    : m_id(IdentifierType())
    , m_startOffset(startOffset)
    , m_maxSize(parent.startOffset() + parent.totalSize() - startOffset)
    , m_dataSize(0)
    , m_idLength(0)
    , m_sizeLength(0)
    , m_parent(&parent)
    , m_container(&parent.container())
    , m_parsed(false)
    , m_sizeUnknown(false)
{
}
 
template <class ImplementationType>
GenericFileElement<ImplementationType>::GenericFileElement(
    GenericFileElement<ImplementationType>::ContainerType &container, std::uint64_t startOffset, std::uint64_t maxSize)
    : m_id(IdentifierType())
    , m_startOffset(startOffset)
    , m_maxSize(maxSize)
    , m_dataSize(0)
    , m_idLength(0)
    , m_sizeLength(0)
    , m_parent(nullptr)
    , m_container(&container)
    , m_parsed(false)
    , m_sizeUnknown(false)
{
}
 
template <class ImplementationType>
inline typename GenericFileElement<ImplementationType>::ContainerType &GenericFileElement<ImplementationType>::container()
{
    return *m_container;
}
 
template <class ImplementationType>
inline const typename GenericFileElement<ImplementationType>::ContainerType &GenericFileElement<ImplementationType>::container() const
{
    return *m_container;
}
 
template <class ImplementationType> inline std::iostream &GenericFileElement<ImplementationType>::stream()
{
    return m_container->stream();
}
 
template <class ImplementationType> inline CppUtilities::BinaryReader &GenericFileElement<ImplementationType>::reader()
{
    return m_container->reader();
}
 
template <class ImplementationType> inline CppUtilities::BinaryWriter &GenericFileElement<ImplementationType>::writer()
{
    return m_container->writer();
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::startOffset() const
{
    return m_startOffset;
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::relativeStartOffset() const
{
    return parent() ? startOffset() - parent()->startOffset() : startOffset();
}
 
template <class ImplementationType>
inline const typename GenericFileElement<ImplementationType>::IdentifierType &GenericFileElement<ImplementationType>::id() const
{
    return m_id;
}
 
template <class ImplementationType> inline std::string GenericFileElement<ImplementationType>::idToString() const
{
    return static_cast<ImplementationType *>(this)->idToString();
}
 
template <class ImplementationType> inline std::uint32_t GenericFileElement<ImplementationType>::idLength() const
{
    return m_idLength;
}
 
template <class ImplementationType> inline std::uint32_t GenericFileElement<ImplementationType>::headerSize() const
{
    return m_idLength + m_sizeLength;
}
 
template <class ImplementationType>
inline typename GenericFileElement<ImplementationType>::DataSizeType GenericFileElement<ImplementationType>::dataSize() const
{
    return m_dataSize;
}
 
template <class ImplementationType> inline std::uint32_t GenericFileElement<ImplementationType>::sizeLength() const
{
    return m_sizeLength;
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::dataOffset() const
{
    return startOffset() + headerSize();
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::totalSize() const
{
    return headerSize() + dataSize();
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::endOffset() const
{
    return startOffset() + totalSize();
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::maxTotalSize() const
{
    return m_maxSize;
}
 
template <class ImplementationType> std::uint8_t GenericFileElement<ImplementationType>::level() const
{
    std::uint8_t level = 0;
    for (const ImplementationType *parent = m_parent; parent; ++level, parent = parent->m_parent)
        ;
    return level;
}
 
template <class ImplementationType> inline ImplementationType *GenericFileElement<ImplementationType>::parent()
{
    return m_parent;
}
 
template <class ImplementationType> inline const ImplementationType *GenericFileElement<ImplementationType>::parent() const
{
    return m_parent;
}
 
template <class ImplementationType> ImplementationType *GenericFileElement<ImplementationType>::parent(std::uint8_t n)
{
    ImplementationType *parent = static_cast<ImplementationType *>(this);
    for (; n && parent; --n, parent = parent->m_parent)
        ;
    return parent;
}
 
template <class ImplementationType> inline const ImplementationType *GenericFileElement<ImplementationType>::parent(std::uint8_t n) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->parent(n);
}
 
template <class ImplementationType> inline ImplementationType *GenericFileElement<ImplementationType>::nextSibling()
{
    return m_nextSibling.get();
}
 
template <class ImplementationType> inline const ImplementationType *GenericFileElement<ImplementationType>::nextSibling() const
{
    return m_nextSibling.get();
}
 
template <class ImplementationType> inline ImplementationType *GenericFileElement<ImplementationType>::firstChild()
{
    return m_firstChild.get();
}
 
template <class ImplementationType> inline const ImplementationType *GenericFileElement<ImplementationType>::firstChild() const
{
    return m_firstChild.get();
}
 
template <class ImplementationType> inline ImplementationType *GenericFileElement<ImplementationType>::lastChild()
{
    for (ImplementationType *child = firstChild(); child; child = child->nextSibling()) {
        if (!child->m_nextSibling) {
            return child;
        }
    }
    return nullptr;
}
 
template <class ImplementationType> inline const ImplementationType *GenericFileElement<ImplementationType>::lastChild() const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->lastChild();
}
 
template <class ImplementationType>
ImplementationType *GenericFileElement<ImplementationType>::subelementByPath(Diagnostics &diag, IdentifierType item)
{
    // ensure element is parsed
    parse(diag);
    // return the element if it matches the current and last item in the path
    if (item == id()) {
        return static_cast<ImplementationType *>(this);
    }
    // check whether a sibling matches the item
    if (nextSibling()) {
        return nextSibling()->subelementByPath(diag, item);
    }
    return nullptr;
}
 
template <class ImplementationType>
ImplementationType *GenericFileElement<ImplementationType>::subelementByPath(Diagnostics &diag, IdentifierType item, IdentifierType remainingPath...)
{
    // ensure element is parsed
    parse(diag);
    // continue with next item in path if the element matches the current item
    if (item == id()) {
        if (!firstChild()) {
            return nullptr;
        }
        return firstChild()->subelementByPath(diag, remainingPath);
    }
    // check whether a sibling matches the current item
    if (nextSibling()) {
        return nextSibling()->subelementByPath(diag, item, remainingPath);
    }
    return nullptr;
}
 
template <class ImplementationType>
const ImplementationType *GenericFileElement<ImplementationType>::subelementByPath(Diagnostics &diag, IdentifierType item) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->subelementByPath(diag, item);
}
 
template <class ImplementationType>
const ImplementationType *GenericFileElement<ImplementationType>::subelementByPath(
    Diagnostics &diag, IdentifierType item, IdentifierType remainingPath...) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->subelementByPath(diag, item, remainingPath);
}
 
template <class ImplementationType> ImplementationType *GenericFileElement<ImplementationType>::childById(const IdentifierType &id, Diagnostics &diag)
{
    parse(diag); // ensure element is parsed
    for (ImplementationType *child = firstChild(); child; child = child->nextSibling()) {
        child->parse(diag);
        if (child->id() == id) {
            return child;
        }
    }
    return nullptr;
}
 
template <class ImplementationType>
const ImplementationType *GenericFileElement<ImplementationType>::childById(const IdentifierType &id, Diagnostics &diag) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->childById(id, diag);
}
 
template <class ImplementationType>
ImplementationType *GenericFileElement<ImplementationType>::siblingById(const IdentifierType &id, Diagnostics &diag)
{
    parse(diag); // ensure element is parsed
    for (ImplementationType *sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
        sibling->parse(diag);
        if (sibling->id() == id) {
            return sibling;
        }
    }
    return nullptr;
}
 
template <class ImplementationType>
const ImplementationType *GenericFileElement<ImplementationType>::siblingById(const IdentifierType &id, Diagnostics &diag) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->siblingById(id, diag);
}
 
template <class ImplementationType>
ImplementationType *GenericFileElement<ImplementationType>::siblingByIdIncludingThis(const IdentifierType &id, Diagnostics &diag)
{
    parse(diag); // ensure element is parsed
    for (ImplementationType *sibling = static_cast<ImplementationType *>(this); sibling; sibling = sibling->nextSibling()) {
        sibling->parse(diag);
        if (sibling->id() == id) {
            return sibling;
        }
    }
    return nullptr;
}
 
template <class ImplementationType>
const ImplementationType *GenericFileElement<ImplementationType>::siblingByIdIncludingThis(const IdentifierType &id, Diagnostics &diag) const
{
    return const_cast<GenericFileElement<ImplementationType> *>(this)->siblingByIdIncludingThis(id, diag);
}
 
template <class ImplementationType> inline bool GenericFileElement<ImplementationType>::isParent() const
{
    return static_cast<const ImplementationType *>(this)->isParent();
}
 
template <class ImplementationType> inline bool GenericFileElement<ImplementationType>::isPadding() const
{
    return static_cast<const ImplementationType *>(this)->isPadding();
}
 
template <class ImplementationType> inline std::uint64_t GenericFileElement<ImplementationType>::firstChildOffset() const
{
    return static_cast<const ImplementationType *>(this)->firstChildOffset();
}
 
template <class ImplementationType> inline bool GenericFileElement<ImplementationType>::isParsed() const
{
    return m_parsed;
}
 
template <class ImplementationType> void GenericFileElement<ImplementationType>::clear()
{
    m_id = IdentifierType();
    //m_startOffset = 0;
    m_idLength = 0;
    m_dataSize = 0;
    m_sizeLength = 0;
    m_nextSibling = nullptr;
    m_firstChild = nullptr;
    m_parsed = false;
}
 
template <class ImplementationType> void GenericFileElement<ImplementationType>::parse(Diagnostics &diag)
{
    if (!m_parsed) {
        static_cast<ImplementationType *>(this)->internalParse(diag);
        m_parsed = true;
    }
}
 
template <class ImplementationType> void GenericFileElement<ImplementationType>::reparse(Diagnostics &diag)
{
    clear();
    static_cast<ImplementationType *>(this)->parse(diag);
    m_parsed = true;
}
 
template <class ImplementationType>
void GenericFileElement<ImplementationType>::validateSubsequentElementStructure(
    Diagnostics &diag, std::uint64_t *paddingSize, AbortableProgressFeedback *progress)
{
    if (progress) {
        progress->stopIfAborted();
    }
    // validate element itself by just parsing it
    parse(diag);
    // validate children
    if (firstChild()) {
        try {
            firstChild()->validateSubsequentElementStructure(diag, paddingSize, progress);
        } catch (const Failure &) {
            // ignore critical errors in child structure to continue validating siblings
            // (critical notifications about the errors should have already been added to diag, so nothing to do)
        }
    } else if (paddingSize && isPadding()) { // element is padding
        *paddingSize += totalSize();
    }
    // validate siblings
    if (nextSibling()) {
        nextSibling()->validateSubsequentElementStructure(diag, paddingSize, progress);
    }
}
 
template <class ImplementationType>
template <typename TargetStream>
void GenericFileElement<ImplementationType>::copyHeader(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress)
{
    copyInternal(targetStream, startOffset(), headerSize(), diag, progress);
}
 
template <class ImplementationType>
template <typename TargetStream>
void GenericFileElement<ImplementationType>::copyWithoutChilds(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress)
{
    if (std::uint32_t firstChildOffset = this->firstChildOffset()) {
        copyInternal(targetStream, startOffset(), firstChildOffset, diag, progress);
    } else {
        copyInternal(targetStream, startOffset(), totalSize(), diag, progress);
    }
}
 
template <class ImplementationType>
template <typename TargetStream>
void GenericFileElement<ImplementationType>::copyEntirely(TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress)
{
    copyInternal(targetStream, startOffset(), totalSize(), diag, progress);
}
 
template <class ImplementationType> void GenericFileElement<ImplementationType>::makeBuffer()
{
    m_buffer = std::make_unique<char[]>(totalSize());
    container().stream().seekg(static_cast<std::streamoff>(startOffset()));
    container().stream().read(m_buffer.get(), static_cast<std::streamsize>(totalSize()));
}
 
template <class ImplementationType> inline void GenericFileElement<ImplementationType>::discardBuffer()
{
    m_buffer.reset();
}
 
template <class ImplementationType>
template <typename TargetStream>
inline void GenericFileElement<ImplementationType>::copyBuffer(TargetStream &targetStream)
{
    targetStream.write(m_buffer.get(), static_cast<std::streamsize>(totalSize()));
}
 
template <class ImplementationType>
template <typename TargetStream>
inline void GenericFileElement<ImplementationType>::copyPreferablyFromBuffer(
    TargetStream &targetStream, Diagnostics &diag, AbortableProgressFeedback *progress)
{
    m_buffer ? copyBuffer(targetStream) : copyEntirely(targetStream, diag, progress);
}
 
template <class ImplementationType> inline const std::unique_ptr<char[]> &GenericFileElement<ImplementationType>::buffer()
{
    return m_buffer;
}
 
template <class ImplementationType>
template <typename TargetStream>
void GenericFileElement<ImplementationType>::copyInternal(
    TargetStream &targetStream, std::uint64_t startOffset, std::uint64_t bytesToCopy, Diagnostics &diag, AbortableProgressFeedback *progress)
{
    // ensure the header has been parsed correctly
    try {
        parse(diag);
    } catch (const Failure &) {
        throw InvalidDataException();
    }
    auto &stream = container().stream();
    stream.seekg(static_cast<std::streamoff>(startOffset), std::ios_base::beg);
    CppUtilities::CopyHelper<0x10000> copyHelper;
    if (progress) {
        copyHelper.callbackCopy(stream, targetStream, bytesToCopy, std::bind(&AbortableProgressFeedback::isAborted, std::ref(progress)),
            std::bind(&AbortableProgressFeedback::updateStepPercentageFromFraction, std::ref(progress), std::placeholders::_1));
    } else {
        copyHelper.copy(stream, targetStream, bytesToCopy);
    }
}
 
template <class ImplementationType>
ImplementationType *GenericFileElement<ImplementationType>::denoteFirstChild(std::uint32_t relativeFirstChildOffset)
{
    if (relativeFirstChildOffset + minimumElementSize() <= totalSize()) {
        m_firstChild.reset(new ImplementationType(static_cast<ImplementationType &>(*this), startOffset() + relativeFirstChildOffset));
    } else {
        m_firstChild.reset();
    }
    return m_firstChild.get();
}
 
template <class ImplementationType> constexpr std::uint32_t GenericFileElement<ImplementationType>::maximumIdLengthSupported()
{
    return sizeof(IdentifierType);
}
 
template <class ImplementationType> constexpr std::uint32_t GenericFileElement<ImplementationType>::maximumSizeLengthSupported()
{
    return sizeof(DataSizeType);
}
 
template <class ImplementationType> constexpr std::uint8_t GenericFileElement<ImplementationType>::minimumElementSize()
{
    return FileElementTraits<ImplementationType>::minimumElementSize();
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_GENERICFILEELEMENT_H