abstractattachment.h

Go to the documentation of this file.

#ifndef TAG_PARSER_ABSTRACTATTACHMENT_H
#define TAG_PARSER_ABSTRACTATTACHMENT_H
 
#include "./diagnostics.h"
 
#include <functional>
#include <iostream>
#include <memory>
#include <string>
 
namespace TagParser {
 
class AbortableProgressFeedback;
class MediaFileInfo;
 
class TAG_PARSER_EXPORT StreamDataBlock {
public:
    StreamDataBlock(const std::function<std::istream &()> &stream, uint64_t startOffset = 0, std::ios_base::seekdir startDir = std::ios_base::beg,
        uint64_t endOffset = 0, std::ios_base::seekdir endDir = std::ios_base::end);
    virtual ~StreamDataBlock();
 
    std::istream &stream() const;
    std::uint64_t startOffset() const;
    std::uint64_t endOffset() const;
    std::uint64_t size() const;
    const std::unique_ptr<char[]> &buffer() const;
    void makeBuffer() const;
    void discardBuffer();
    void copyTo(std::ostream &stream) const;
 
protected:
    StreamDataBlock();
 
    std::function<std::istream &()> m_stream;
    std::uint64_t m_startOffset;
    std::uint64_t m_endOffset;
    mutable std::unique_ptr<char[]> m_buffer;
};
 
inline std::istream &StreamDataBlock::stream() const
{
    return m_stream();
}
 
inline std::uint64_t StreamDataBlock::startOffset() const
{
    return m_startOffset;
}
 
inline std::uint64_t StreamDataBlock::endOffset() const
{
    return m_endOffset;
}
 
inline std::uint64_t StreamDataBlock::size() const
{
    return m_endOffset - m_startOffset;
}
 
inline const std::unique_ptr<char[]> &StreamDataBlock::buffer() const
{
    return m_buffer;
}
 
inline void StreamDataBlock::discardBuffer()
{
    m_buffer.reset();
}
 
class TAG_PARSER_EXPORT FileDataBlock : public StreamDataBlock {
public:
    FileDataBlock(std::string_view path, Diagnostics &diag, AbortableProgressFeedback &progress);
    ~FileDataBlock();
    const MediaFileInfo *fileInfo() const;
 
private:
    std::unique_ptr<MediaFileInfo> m_fileInfo;
};
 
inline const MediaFileInfo *FileDataBlock::fileInfo() const
{
    return m_fileInfo.get();
}
 
struct AbstractAttachmentPrivate;
 
class TAG_PARSER_EXPORT AbstractAttachment {
public:
    const std::string &description() const;
    void setDescription(std::string_view description);
    const std::string &name() const;
    void setName(std::string_view name);
    const std::string &mimeType() const;
    void setMimeType(std::string_view mimeType);
    std::uint64_t id() const;
    void setId(std::uint64_t id);
    const StreamDataBlock *data() const;
    void setData(std::unique_ptr<StreamDataBlock> &&data);
    void setFile(std::string_view path, Diagnostics &diag, AbortableProgressFeedback &progress);
    bool isDataFromFile() const;
    std::string label() const;
    void clear();
    bool isIgnored() const;
    void setIgnored(bool ignored);
    bool isEmpty() const;
 
protected:
    explicit AbstractAttachment();
    virtual ~AbstractAttachment();
 
private:
    std::string m_description;
    std::string m_name;
    std::string m_mimeType;
    std::uint64_t m_id;
    std::unique_ptr<StreamDataBlock> m_data;
    std::unique_ptr<AbstractAttachmentPrivate> m_p;
    bool m_isDataFromFile;
    bool m_ignored;
};
 
inline const std::string &AbstractAttachment::description() const
{
    return m_description;
}
 
inline void AbstractAttachment::setDescription(std::string_view description)
{
    m_description = description;
}
 
inline const std::string &AbstractAttachment::name() const
{
    return m_name;
}
 
inline void AbstractAttachment::setName(std::string_view name)
{
    m_name = name;
}
 
inline const std::string &AbstractAttachment::mimeType() const
{
    return m_mimeType;
}
 
inline void AbstractAttachment::setMimeType(std::string_view mimeType)
{
    m_mimeType = mimeType;
}
 
inline std::uint64_t AbstractAttachment::id() const
{
    return m_id;
}
 
inline void AbstractAttachment::setId(uint64_t id)
{
    m_id = id;
}
 
inline const StreamDataBlock *AbstractAttachment::data() const
{
    return m_data.get();
}
 
inline void AbstractAttachment::setData(std::unique_ptr<StreamDataBlock> &&data)
{
    m_data = std::move(data);
    m_isDataFromFile = false;
}
 
inline bool AbstractAttachment::isDataFromFile() const
{
    return m_isDataFromFile;
}
 
inline bool AbstractAttachment::isIgnored() const
{
    return m_ignored;
}
 
inline void AbstractAttachment::setIgnored(bool ignored)
{
    m_ignored = ignored;
}
 
inline bool AbstractAttachment::isEmpty() const
{
    return m_description.empty() && m_name.empty() && !m_mimeType.empty() && !m_data;
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_ABSTRACTATTACHMENT_H