abstractattachment.cpp

Go to the documentation of this file.

#include "./abstractattachment.h"
 
#include "./exceptions.h"
#include "./mediafileinfo.h"
#include "./progressfeedback.h"
 
#include <c++utilities/io/copy.h>
 
#include <memory>
#include <sstream>
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
 
struct AbstractAttachmentPrivate {};
 
StreamDataBlock::StreamDataBlock()
    : m_stream(nullptr)
    , m_startOffset(0)
    , m_endOffset(0)
{
}
StreamDataBlock::StreamDataBlock() {…}
 
StreamDataBlock::StreamDataBlock(const std::function<std::istream &()> &stream, std::uint64_t startOffset, std::ios_base::seekdir startDir,
    std::uint64_t endOffset, std::ios_base::seekdir endDir)
    : m_stream(stream)
{
    auto &s = stream();
    auto currentPos = s.tellg();
    s.seekg(static_cast<std::istream::off_type>(startOffset), startDir);
    m_startOffset = static_cast<std::uint64_t>(s.tellg());
    s.seekg(static_cast<std::istream::off_type>(endOffset), endDir);
    m_endOffset = static_cast<std::uint64_t>(s.tellg());
    s.seekg(currentPos);
    if (m_endOffset < m_startOffset) {
        throw std::ios_base::failure("End offset is less than start offset.");
    }
}
 
StreamDataBlock::~StreamDataBlock()
{
}
StreamDataBlock::~StreamDataBlock() {…}
 
void StreamDataBlock::makeBuffer() const
{
    m_buffer = make_unique<char[]>(size());
    stream().seekg(static_cast<std::istream::off_type>(startOffset()));
    stream().read(m_buffer.get(), static_cast<std::streamsize>(size()));
}
void StreamDataBlock::makeBuffer() const {…}
 
void StreamDataBlock::copyTo(ostream &stream) const
{
    if (buffer()) {
        stream.write(buffer().get(), static_cast<std::streamsize>(size()));
    } else {
        CopyHelper<0x2000> copyHelper;
        m_stream().seekg(static_cast<std::streamsize>(startOffset()));
        copyHelper.copy(m_stream(), stream, size());
    }
}
void StreamDataBlock::copyTo(ostream &stream) const {…}
 
FileDataBlock::FileDataBlock(std::string_view path, Diagnostics &diag, AbortableProgressFeedback &progress)
    : m_fileInfo(make_unique<MediaFileInfo>())
{
    m_fileInfo->setPath(path);
    m_fileInfo->open(true);
    m_fileInfo->parseContainerFormat(diag, progress);
    m_startOffset = 0;
    m_endOffset = m_fileInfo->size();
    m_stream = [this]() -> std::istream & { return this->m_fileInfo->stream(); };
}
FileDataBlock::FileDataBlock(std::string_view path, Diagnostics &diag, AbortableProgressFeedback &progress) {…}
 
FileDataBlock::~FileDataBlock()
{
}
FileDataBlock::~FileDataBlock() {…}
 
AbstractAttachment::AbstractAttachment()
    : m_id(0)
    , m_isDataFromFile(false)
    , m_ignored(false)
{
}
AbstractAttachment::AbstractAttachment() {…}
 
AbstractAttachment::~AbstractAttachment()
{
}
AbstractAttachment::~AbstractAttachment() {…}
 
string AbstractAttachment::label() const
{
    stringstream ss;
    ss << "ID: " << id();
    if (!name().empty()) {
        ss << ", name: \"" << name() << "\"";
    }
    if (!mimeType().empty()) {
        ss << ", mime-type: \"" << mimeType() << "\"";
    }
    return ss.str();
}
string AbstractAttachment::label() const {…}
 
void AbstractAttachment::clear()
{
    m_description.clear();
    m_name.clear();
    m_mimeType.clear();
    m_id = 0;
    m_data.reset();
}
void AbstractAttachment::clear() {…}
 
void AbstractAttachment::setFile(string_view path, Diagnostics &diag, AbortableProgressFeedback &progress)
{
    m_data.reset();
    auto file = make_unique<FileDataBlock>(path, diag, progress);
    const auto fileName = file->fileInfo()->fileName();
    if (!fileName.empty()) {
        m_name = fileName;
    }
    const auto mimeType = file->fileInfo()->mimeType();
    if (!mimeType.empty()) {
        m_mimeType = mimeType;
    }
    m_data = std::move(file);
    m_isDataFromFile = true;
}
void AbstractAttachment::setFile(string_view path, Diagnostics &diag, AbortableProgressFeedback &progress) {…}
 
} // namespace TagParser