tagvalue.h

Go to the documentation of this file.

#ifndef TAG_PARSER_TAGVALUE_H
#define TAG_PARSER_TAGVALUE_H
 
#include "./localehelper.h"
#include "./positioninset.h"
#include "./tagtype.h"
 
#include <c++utilities/chrono/datetime.h>
#include <c++utilities/chrono/timespan.h>
#include <c++utilities/conversion/binaryconversion.h>
#include <c++utilities/misc/flagenumclass.h>
#include <c++utilities/misc/traits.h>
 
#include <cstdint>
#include <cstring>
#include <iosfwd>
#include <memory>
#include <string>
#include <unordered_map>
 
namespace TagParser {
 
class Tag;
class Id3v2Frame;
 
enum class TagTextEncoding : unsigned int {
    Latin1, 
    Utf8, 
    Utf16LittleEndian, 
    Utf16BigEndian, 
    Unspecified 
};
 
enum class TagValueFlags : std::uint64_t {
    None, 
    ReadOnly, 
};
 
} // namespace TagParser
 
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(TagParser, TagParser::TagValueFlags)
 
namespace TagParser {
 
constexpr int characterSize(TagTextEncoding encoding)
{
    switch (encoding) {
    case TagTextEncoding::Latin1:
    case TagTextEncoding::Utf8:
        return 1;
    case TagTextEncoding::Utf16LittleEndian:
    case TagTextEncoding::Utf16BigEndian:
        return 2;
    default:
        return 0;
    }
}
 
struct TAG_PARSER_EXPORT Popularity {
    std::string user;
    double rating = 0.0;
    std::uint64_t playCounter = 0;
    TagType scale = TagType::Unspecified;
 
    bool scaleTo(TagType targetScale);
    Popularity scaled(TagType targetScale) const;
    std::string toString() const;
    static Popularity fromString(std::string_view str);
    static Popularity fromString(std::string_view str, TagType scale);
 
    bool isEmpty() const
    {
        return user.empty() && rating == 0.0 && !playCounter;
    }
 
    bool operator==(const Popularity &other) const
    {
        return playCounter == other.playCounter && rating == other.rating && user == other.user && scale == other.scale;
    }
};
 
inline Popularity Popularity::scaled(TagType targetScale) const
{
    auto copy = *this;
    copy.scaleTo(targetScale);
    return copy;
}
 
enum class TagDataType : unsigned int {
    Text, 
    Integer, 
    PositionInSet, 
    StandardGenreIndex, 
    TimeSpan, 
    DateTime, 
    Picture, 
    Binary, 
    Undefined, 
    Popularity, 
    UnsignedInteger, 
    DateTimeExpression, 
};
 
TAG_PARSER_EXPORT std::string_view tagDataTypeString(TagDataType dataType);
 
enum class TagValueComparisionFlags : unsigned int {
    None, 
    CaseInsensitive = 0x1, 
    IgnoreMetaData = 0x2, 
};
 
struct TagValuePrivate;
 
class TAG_PARSER_EXPORT TagValue {
public:
    // constructor, destructor
    explicit TagValue();
    explicit TagValue(const char *text, std::size_t textSize, TagTextEncoding textEncoding = TagTextEncoding::Latin1,
        TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    explicit TagValue(
        const char *text, TagTextEncoding textEncoding = TagTextEncoding::Latin1, TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    explicit TagValue(
        const std::string &text, TagTextEncoding textEncoding = TagTextEncoding::Latin1, TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    explicit TagValue(
        std::string_view text, TagTextEncoding textEncoding = TagTextEncoding::Latin1, TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    explicit TagValue(int value);
    explicit TagValue(std::uint64_t value);
    explicit TagValue(
        const char *data, std::size_t length, TagDataType type = TagDataType::Undefined, TagTextEncoding encoding = TagTextEncoding::Latin1);
    explicit TagValue(std::unique_ptr<char[]> &&data, std::size_t length, TagDataType type = TagDataType::Binary,
        TagTextEncoding encoding = TagTextEncoding::Latin1);
    explicit TagValue(PositionInSet value);
    explicit TagValue(CppUtilities::DateTime value);
    explicit TagValue(const CppUtilities::DateTimeExpression &value);
    explicit TagValue(CppUtilities::TimeSpan value);
    explicit TagValue(const Popularity &value);
    TagValue(const TagValue &other);
    TagValue(TagValue &&other);
    ~TagValue();
 
    // operators
    TagValue &operator=(const TagValue &other);
    TagValue &operator=(TagValue &&other);
    bool operator==(const TagValue &other) const;
    bool operator!=(const TagValue &other) const;
    operator bool() const;
 
    // methods
    bool isNull() const;
    bool isEmpty() const;
    void clearData();
    void clearMetadata();
    void clearDataAndMetadata();
    TagDataType type() const;
    std::string toString(TagTextEncoding encoding = TagTextEncoding::Unspecified) const;
    std::string toDisplayString() const;
    void toString(std::string &result, TagTextEncoding encoding = TagTextEncoding::Unspecified) const;
    std::u16string toWString(TagTextEncoding encoding = TagTextEncoding::Unspecified) const;
    void toWString(std::u16string &result, TagTextEncoding encoding = TagTextEncoding::Unspecified) const;
    std::int32_t toInteger() const;
    std::uint64_t toUnsignedInteger() const;
    int toStandardGenreIndex() const;
    PositionInSet toPositionInSet() const;
    CppUtilities::TimeSpan toTimeSpan() const;
    CppUtilities::DateTime toDateTime() const;
    CppUtilities::DateTimeExpression toDateTimeExpression() const;
    Popularity toPopularity() const;
    Popularity toScaledPopularity(TagType scale = TagType::Unspecified) const;
    std::size_t dataSize() const;
    char *dataPointer();
    const char *dataPointer() const;
    std::string_view data() const;
    const std::string &description() const;
    void setDescription(std::string_view value, TagTextEncoding encoding = TagTextEncoding::Latin1);
    const std::string &mimeType() const;
    void setMimeType(std::string_view mimeType);
    const Locale &locale() const;
    Locale &locale();
    void setLocale(const Locale &locale);
    TagValueFlags flags() const;
    void setFlags(TagValueFlags flags);
    bool isLabeledAsReadonly() const;
    void setReadonly(bool readOnly);
    const std::unordered_map<std::string, std::string> &nativeData() const;
    std::unordered_map<std::string, std::string> &nativeData();
    TagTextEncoding dataEncoding() const;
    void convertDataEncoding(TagTextEncoding encoding);
    void convertDataEncodingForTag(const Tag *tag);
    TagTextEncoding descriptionEncoding() const;
    void convertDescriptionEncoding(TagTextEncoding encoding);
    static const TagValue &empty();
 
    void assignText(const char *text, std::size_t textSize, TagTextEncoding textEncoding = TagTextEncoding::Latin1,
        TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    void assignText(
        const std::string &text, TagTextEncoding textEncoding = TagTextEncoding::Latin1, TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    void assignText(
        std::string_view text, TagTextEncoding textEncoding = TagTextEncoding::Latin1, TagTextEncoding convertTo = TagTextEncoding::Unspecified);
    void assignInteger(int value);
    void assignUnsignedInteger(std::uint64_t value);
    void assignStandardGenreIndex(int index);
    void assignData(const char *data, std::size_t length, TagDataType type = TagDataType::Binary, TagTextEncoding encoding = TagTextEncoding::Latin1);
    void assignData(std::unique_ptr<char[]> &&data, std::size_t length, TagDataType type = TagDataType::Binary,
        TagTextEncoding encoding = TagTextEncoding::Latin1);
    void assignPosition(PositionInSet value);
    void assignTimeSpan(CppUtilities::TimeSpan value);
    void assignDateTime(CppUtilities::DateTime value);
    void assignDateTimeExpression(const CppUtilities::DateTimeExpression &value);
    void assignPopularity(const Popularity &value);
 
    static void stripBom(const char *&text, std::size_t &length, TagTextEncoding encoding);
    static void ensureHostByteOrder(std::u16string &u16str, TagTextEncoding currentEncoding);
    template <typename ContainerType,
        CppUtilities::Traits::EnableIf<CppUtilities::Traits::IsIteratable<ContainerType>,
            std::is_same<typename std::add_const<typename std::remove_pointer<typename ContainerType::value_type>::type>::type, const TagValue>>
            * = nullptr>
    static std::vector<std::string> toStrings(const ContainerType &values, TagTextEncoding encoding = TagTextEncoding::Utf8);
    bool compareTo(const TagValue &other, TagValueComparisionFlags options = TagValueComparisionFlags::None) const;
    bool compareData(const TagValue &other, bool ignoreCase = false) const;
    static bool compareData(const std::string &data1, const std::string &data2, bool ignoreCase = false);
    static bool compareData(const char *data1, std::size_t size1, const char *data2, std::size_t size2, bool ignoreCase = false);
 
private:
    std::unique_ptr<char[]> m_ptr;
    std::size_t m_size;
    std::string m_desc;
    std::string m_mimeType;
    Locale m_locale;
    std::unordered_map<std::string, std::string> m_nativeData;
    TagDataType m_type;
    TagTextEncoding m_encoding;
    TagTextEncoding m_descEncoding;
    TagValueFlags m_flags;
    std::unique_ptr<TagValuePrivate> m_p;
};
 
inline TagValue::TagValue(int value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::Integer)
{
}
 
inline TagParser::TagValue::TagValue(std::uint64_t value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::UnsignedInteger)
{
}
 
inline TagValue::TagValue(PositionInSet value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::PositionInSet)
{
}
 
inline TagValue::TagValue(CppUtilities::DateTime value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::DateTime)
{
}
 
inline TagValue::TagValue(const CppUtilities::DateTimeExpression &value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::DateTimeExpression)
{
}
 
inline TagValue::TagValue(CppUtilities::TimeSpan value)
    : TagValue(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::TimeSpan)
{
}
 
inline TagValue::TagValue(const Popularity &value)
    : TagValue()
{
    assignPopularity(value);
}
 
inline bool TagValue::operator==(const TagValue &other) const
{
    return compareTo(other, TagValueComparisionFlags::None);
}
 
inline bool TagValue::operator!=(const TagValue &other) const
{
    return !compareTo(other, TagValueComparisionFlags::None);
}
 
inline TagParser::TagValue::operator bool() const
{
    return !isEmpty();
}
 
inline void TagValue::assignText(const std::string &text, TagTextEncoding textEncoding, TagTextEncoding convertTo)
{
    assignText(text.data(), text.size(), textEncoding, convertTo);
}
 
inline void TagValue::assignText(std::string_view text, TagTextEncoding textEncoding, TagTextEncoding convertTo)
{
    assignText(text.data(), text.size(), textEncoding, convertTo);
}
 
inline void TagValue::assignPosition(PositionInSet value)
{
    if (value.isNull()) {
        m_type = TagDataType::PositionInSet;
        clearData();
    } else {
        assignData(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::PositionInSet);
    }
}
 
inline void TagValue::assignTimeSpan(CppUtilities::TimeSpan value)
{
    assignData(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::TimeSpan);
}
 
inline void TagValue::assignDateTime(CppUtilities::DateTime value)
{
    assignData(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::DateTime);
}
 
inline void TagParser::TagValue::assignDateTimeExpression(const CppUtilities::DateTimeExpression &value)
{
    assignData(reinterpret_cast<const char *>(&value), sizeof(value), TagDataType::DateTimeExpression);
}
 
inline void TagValue::assignStandardGenreIndex(int index)
{
    assignInteger(index);
    m_type = TagDataType::StandardGenreIndex;
}
 
inline TagDataType TagValue::type() const
{
    return m_type;
}
 
inline std::string TagValue::toString(TagTextEncoding encoding) const
{
    std::string res;
    toString(res, encoding);
    return res;
}
 
inline std::u16string TagValue::toWString(TagTextEncoding encoding) const
{
    std::u16string res;
    toWString(res, encoding);
    return res;
}
 
inline bool TagValue::isNull() const
{
    return m_ptr == nullptr;
}
 
inline bool TagValue::isEmpty() const
{
    return m_ptr == nullptr || m_size == 0;
}
 
inline void TagValue::clearData()
{
    m_size = 0;
    m_ptr.reset();
}
 
inline void TagValue::clearDataAndMetadata()
{
    clearData();
    clearMetadata();
}
 
inline std::size_t TagValue::dataSize() const
{
    return m_size;
}
 
inline char *TagValue::dataPointer()
{
    return m_ptr.get();
}
 
inline const char *TagValue::dataPointer() const
{
    return m_ptr.get();
}
 
inline std::string_view TagValue::data() const
{
    return std::string_view(m_ptr.get(), m_size);
}
 
inline const std::string &TagValue::description() const
{
    return m_desc;
}
 
inline void TagValue::setDescription(std::string_view value, TagTextEncoding encoding)
{
    m_desc = value;
    m_descEncoding = encoding;
}
 
inline const std::string &TagValue::mimeType() const
{
    return m_mimeType;
}
 
inline void TagValue::setMimeType(std::string_view mimeType)
{
    m_mimeType = mimeType;
}
 
inline const Locale &TagValue::locale() const
{
    return m_locale;
}
 
inline Locale &TagValue::locale()
{
    return m_locale;
}
 
inline void TagValue::setLocale(const Locale &locale)
{
    m_locale = locale;
}
 
inline TagValueFlags TagValue::flags() const
{
    return m_flags;
}
 
inline void TagValue::setFlags(TagValueFlags flags)
{
    m_flags = flags;
}
 
inline bool TagValue::isLabeledAsReadonly() const
{
    return m_flags & TagValueFlags::ReadOnly;
}
 
inline void TagValue::setReadonly(bool readOnly)
{
    CppUtilities::modFlagEnum(m_flags, TagValueFlags::ReadOnly, readOnly);
}
 
inline const std::unordered_map<std::string, std::string> &TagValue::nativeData() const
{
    return m_nativeData;
}
 
inline std::unordered_map<std::string, std::string> &TagValue::nativeData()
{
    return m_nativeData;
}
 
inline TagTextEncoding TagValue::dataEncoding() const
{
    return m_encoding;
}
 
inline TagTextEncoding TagValue::descriptionEncoding() const
{
    return m_descEncoding;
}
 
template <typename ContainerType,
    CppUtilities::Traits::EnableIf<CppUtilities::Traits::IsIteratable<ContainerType>,
        std::is_same<typename std::add_const<typename std::remove_pointer<typename ContainerType::value_type>::type>::type, const TagValue>> *>
std::vector<std::string> TagValue::toStrings(const ContainerType &values, TagTextEncoding encoding)
{
    std::vector<std::string> res;
    res.reserve(values.size());
    for (const auto &value : values) {
        res.emplace_back(CppUtilities::Traits::dereferenceMaybe(value).toString(encoding));
    }
    return res;
}
 
inline bool TagValue::compareData(const TagValue &other, bool ignoreCase) const
{
    return compareData(m_ptr.get(), m_size, other.m_ptr.get(), other.m_size, ignoreCase);
}
 
inline bool TagValue::compareData(const std::string &data1, const std::string &data2, bool ignoreCase)
{
    return compareData(data1.data(), data1.size(), data2.data(), data2.size(), ignoreCase);
}
 
} // namespace TagParser
 
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(TagParser, TagParser::TagValueComparisionFlags)
 
#endif // TAG_PARSER_TAGVALUE_H