tag.h

Go to the documentation of this file.

#ifndef TAG_PARSER_TAG_H
#define TAG_PARSER_TAG_H
 
#include "./tagtarget.h"
#include "./tagtype.h"
#include "./tagvalue.h"
 
#include <c++utilities/io/binaryreader.h>
 
#include <cstdint>
#include <memory>
#include <string>
#include <type_traits>
 
namespace TagParser {
 
enum class KnownField : unsigned int {
    Invalid = std::numeric_limits<unsigned int>::max(), 
    Title = 0, 
    Album, 
    Artist, 
    Genre, 
    Comment, 
    Bpm, 
    Bps, 
    Lyricist, 
    TrackPosition, 
    DiskPosition, 
    PartNumber, 
    TotalParts, 
    Encoder, 
    RecordDate, 
    Performers, 
    Length, 
    Language, 
    EncoderSettings, 
    Lyrics, 
    SynchronizedLyrics, 
    Grouping, 
    RecordLabel, 
    Cover, 
    Composer, 
    Rating, 
    Description, 
    Vendor, 
    AlbumArtist, 
    ReleaseDate, 
    Subtitle, 
    LeadPerformer, 
    Arranger, 
    Conductor, 
    Director, 
    AssistantDirector, 
    DirectorOfPhotography, 
    SoundEngineer, 
    ArtDirector, 
    ProductionDesigner, 
    Choregrapher, 
    CostumeDesigner, 
    Actor, 
    Character, 
    WrittenBy, 
    ScreenplayBy, 
    EditedBy, 
    Producer, 
    Coproducer, 
    ExecutiveProducer, 
    DistributedBy, 
    MasteredBy, 
    EncodedBy, 
    MixedBy, 
    RemixedBy, 
    ProductionStudio, 
    ThanksTo, 
    Publisher, 
    Mood, 
    OriginalMediaType, 
    ContentType, 
    Subject, 
    Keywords, 
    Summary, 
    Synopsis, 
    InitialKey, 
    Period, 
    LawRating, 
    EncodingDate, 
    TaggingDate, 
    OriginalReleaseDate, 
    DigitalizationDate, 
    WritingDate, 
    PurchasingDate, 
    RecordingLocation, 
    CompositionLocation, 
    ComposerNationality, 
    PlayCounter, 
    Measure, 
    Tuning, 
    ISRC, 
    MCDI, 
    ISBN, 
    Barcode, 
    CatalogNumber, 
    LabelCode, 
    LCCN, 
    IMDB, 
    TMDB, 
    TVDB, 
    PurchaseItem, 
    PurchaseInfo, 
    PurchaseOwner, 
    PurchasePrice, 
    PurchaseCurrency, 
    Copyright, 
    ProductionCopyright, 
    License, 
    TermsOfUse, 
    PublisherWebpage, 
    StoreDescription, 
};
 
constexpr KnownField firstKnownField = KnownField::Title;
 
constexpr KnownField lastKnownField = KnownField::StoreDescription;
 
constexpr unsigned int knownFieldArraySize = static_cast<unsigned int>(lastKnownField) + 1;
 
constexpr bool isKnownFieldDeprecated(KnownField field)
{
    CPP_UTILITIES_UNUSED(field)
    return false;
}
 
constexpr KnownField nextKnownField(KnownField field)
{
    const auto next = field == lastKnownField ? KnownField::Invalid : static_cast<KnownField>(static_cast<int>(field) + 1);
    return isKnownFieldDeprecated(next) ? nextKnownField(next) : next;
}
 
struct TagPrivate;
 
class TAG_PARSER_EXPORT Tag {
public:
    virtual ~Tag();
 
    virtual TagType type() const;
    virtual std::string_view typeName() const;
    std::string toString() const;
    virtual TagTextEncoding proposedTextEncoding() const;
    virtual bool canEncodingBeUsed(TagTextEncoding encoding) const;
    virtual const TagValue &value(KnownField field) const = 0;
    virtual std::vector<const TagValue *> values(KnownField field) const;
    virtual bool setValue(KnownField field, const TagValue &value) = 0;
    virtual bool setValues(KnownField field, const std::vector<TagValue> &values);
    virtual bool hasField(KnownField field) const = 0;
    virtual void removeAllFields() = 0;
    const std::string &version() const;
    std::uint64_t size() const;
    virtual bool supportsTarget() const;
    const TagTarget &target() const;
    TagTarget &target();
    void setTarget(const TagTarget &target);
    virtual TagTargetLevel targetLevel() const;
    std::string_view targetLevelName() const;
    bool isTargetingLevel(TagTargetLevel tagTargetLevel) const;
    std::string targetString() const;
    virtual std::size_t fieldCount() const = 0;
    virtual bool supportsField(KnownField field) const = 0;
    virtual TagDataType proposedDataType(KnownField field) const;
    virtual bool supportsDescription(KnownField field) const;
    virtual bool supportsMimeType(KnownField field) const;
    virtual bool supportsMultipleValues(KnownField field) const;
    virtual std::size_t insertValues(const Tag &from, bool overwrite);
    virtual void ensureTextValuesAreProperlyEncoded() = 0;
 
protected:
    Tag();
 
    std::string m_version;
    std::uint64_t m_size;
    std::unique_ptr<TagPrivate> m_p;
    TagTarget m_target;
};
 
inline TagType Tag::type() const
{
    return TagType::Unspecified;
}
 
inline std::string_view Tag::typeName() const
{
    return "unspecified";
}
 
inline TagTextEncoding Tag::proposedTextEncoding() const
{
    return TagTextEncoding::Latin1;
}
 
inline bool Tag::canEncodingBeUsed(TagTextEncoding encoding) const
{
    return encoding == proposedTextEncoding();
}
 
inline const std::string &Tag::version() const
{
    return m_version;
}
 
inline std::uint64_t Tag::size() const
{
    return m_size;
}
 
inline bool Tag::supportsTarget() const
{
    return false;
}
 
inline const TagTarget &Tag::target() const
{
    return m_target;
}
 
inline TagTarget &Tag::target()
{
    return m_target;
}
 
inline void Tag::setTarget(const TagTarget &target)
{
    m_target = target;
}
 
inline TagTargetLevel Tag::targetLevel() const
{
    return TagTargetLevel::Unspecified;
}
 
inline std::string_view Tag::targetLevelName() const
{
    return supportsTarget() ? tagTargetLevelName(targetLevel()) : std::string_view();
}
 
inline bool Tag::isTargetingLevel(TagTargetLevel tagTargetLevel) const
{
    return !supportsTarget() || static_cast<std::uint8_t>(targetLevel()) >= static_cast<std::uint8_t>(tagTargetLevel);
}
 
inline std::string Tag::targetString() const
{
    return target().toString(targetLevel());
}
 
inline TagDataType Tag::proposedDataType(KnownField field) const
{
    switch (field) {
    case KnownField::Bpm:
    case KnownField::Bps:
    case KnownField::PartNumber:
    case KnownField::TotalParts:
    case KnownField::PlayCounter:
        return TagDataType::Integer;
    case KnownField::Cover:
        return TagDataType::Picture;
    case KnownField::Length:
        return TagDataType::TimeSpan;
    case KnownField::TrackPosition:
    case KnownField::DiskPosition:
        return TagDataType::PositionInSet;
    case KnownField::Genre:
        return TagDataType::StandardGenreIndex;
    case KnownField::MCDI:
        return TagDataType::Binary;
    case KnownField::Rating:
        // could also be a plain integer but popularity should generally be used (and can be converted
        // to an integer)
        return TagDataType::Popularity;
    case KnownField::SynchronizedLyrics:
        // not supported
        return TagDataType::Undefined;
    default:
        return TagDataType::Text;
    }
}
 
inline bool Tag::supportsDescription(KnownField) const
{
    return false;
}
 
inline bool Tag::supportsMimeType(KnownField) const
{
    return false;
}
 
inline bool Tag::supportsMultipleValues(KnownField) const
{
    return false;
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_TAG_H