fieldbasedtag.h

Go to the documentation of this file.

#ifndef TAG_PARSER_FIELDBASEDTAG_H
#define TAG_PARSER_FIELDBASEDTAG_H
 
#include "./tag.h"
 
#include <functional>
#include <map>
 
namespace TagParser {
 
template <typename ImplementationType> class FieldMapBasedTagTraits {};
 
template <class ImplementationType> class FieldMapBasedTag : public Tag {
    friend class FieldMapBasedTagTraits<ImplementationType>;
 
public:
    using FieldType = typename FieldMapBasedTagTraits<ImplementationType>::FieldType;
    using IdentifierType = typename FieldMapBasedTagTraits<ImplementationType>::FieldType::IdentifierType;
    using Compare = typename FieldMapBasedTagTraits<ImplementationType>::Compare;
 
    FieldMapBasedTag();
 
    TagType type() const;
    std::string_view typeName() const;
    TagTextEncoding proposedTextEncoding() const;
    const TagValue &value(const IdentifierType &id) const;
    const TagValue &value(KnownField field) const;
    std::vector<const TagValue *> values(const IdentifierType &id) const;
    std::vector<const TagValue *> values(KnownField field) const;
    bool setValue(const IdentifierType &id, const TagValue &value);
    bool setValue(KnownField field, const TagValue &value);
    bool setValues(const IdentifierType &id, const std::vector<TagValue> &values);
    bool setValues(KnownField field, const std::vector<TagValue> &values);
    bool hasField(KnownField field) const;
    bool hasField(const IdentifierType &id) const;
    void removeAllFields();
    const std::multimap<IdentifierType, FieldType, Compare> &fields() const;
    std::multimap<IdentifierType, FieldType, Compare> &fields();
    std::size_t fieldCount() const;
    IdentifierType fieldId(KnownField value) const;
    KnownField knownField(const IdentifierType &id) const;
    bool supportsField(KnownField field) const;
    using Tag::proposedDataType;
    TagDataType proposedDataType(const IdentifierType &id) const;
    std::size_t insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite);
    std::size_t insertValues(const Tag &from, bool overwrite);
    void ensureTextValuesAreProperlyEncoded();
 
protected:
    using CRTPBase = FieldMapBasedTag<ImplementationType>;
 
    const TagValue &internallyGetValue(const IdentifierType &id) const;
    void internallyGetValuesFromField(const FieldType &field, std::vector<const TagValue *> &values) const;
    std::vector<const TagValue *> internallyGetValues(const IdentifierType &id) const;
    bool internallySetValue(const IdentifierType &id, const TagValue &value);
    bool internallySetValues(const IdentifierType &id, const std::vector<TagValue> &values);
    bool internallyHasField(const IdentifierType &id) const;
    // no default implementation: IdentifierType internallyGetFieldId(KnownField field) const;
    // no default implementation: KnownField internallyGetKnownField(const IdentifierType &id) const;
    TagDataType internallyGetProposedDataType(const IdentifierType &id) const;
 
private:
    std::multimap<IdentifierType, FieldType, Compare> m_fields;
};
 
template <class ImplementationType> FieldMapBasedTag<ImplementationType>::FieldMapBasedTag()
{
}
 
template <class ImplementationType> TagType FieldMapBasedTag<ImplementationType>::type() const
{
    return ImplementationType::tagType;
}
 
template <class ImplementationType> std::string_view FieldMapBasedTag<ImplementationType>::typeName() const
{
    return ImplementationType::tagName;
}
 
template <class ImplementationType> TagTextEncoding FieldMapBasedTag<ImplementationType>::proposedTextEncoding() const
{
    return ImplementationType::defaultTextEncoding;
}
 
template <class ImplementationType> const TagValue &FieldMapBasedTag<ImplementationType>::internallyGetValue(const IdentifierType &id) const
{
    auto i = m_fields.find(id);
    return i != m_fields.end() ? i->second.value() : TagValue::empty();
}
 
template <class ImplementationType>
void FieldMapBasedTag<ImplementationType>::internallyGetValuesFromField(
    const FieldMapBasedTag<ImplementationType>::FieldType &field, std::vector<const TagValue *> &values) const
{
    if (!field.value().isEmpty()) {
        values.emplace_back(&field.value());
    }
}
 
template <class ImplementationType>
std::vector<const TagValue *> FieldMapBasedTag<ImplementationType>::internallyGetValues(const IdentifierType &id) const
{
    auto range = m_fields.equal_range(id);
    std::vector<const TagValue *> values;
    for (auto i = range.first; i != range.second; ++i) {
        static_cast<const ImplementationType *>(this)->internallyGetValuesFromField(i->second, values);
    }
    return values;
}
 
template <class ImplementationType> inline const TagValue &FieldMapBasedTag<ImplementationType>::value(const IdentifierType &id) const
{
    return static_cast<const ImplementationType *>(this)->internallyGetValue(id);
}
 
template <class ImplementationType> inline const TagValue &FieldMapBasedTag<ImplementationType>::value(KnownField field) const
{
    return value(fieldId(field));
}
 
template <class ImplementationType> inline std::vector<const TagValue *> FieldMapBasedTag<ImplementationType>::values(const IdentifierType &id) const
{
    return static_cast<const ImplementationType *>(this)->internallyGetValues(id);
}
 
template <class ImplementationType> inline std::vector<const TagValue *> FieldMapBasedTag<ImplementationType>::values(KnownField field) const
{
    return static_cast<const ImplementationType *>(this)->values(fieldId(field));
}
 
template <class ImplementationType> inline bool FieldMapBasedTag<ImplementationType>::setValue(KnownField field, const TagValue &value)
{
    const auto id = fieldId(field);
    if constexpr (std::is_arithmetic_v<IdentifierType>) {
        if (!id) {
            return false;
        }
    } else {
        if (id.empty()) {
            return false;
        }
    }
    return setValue(id, value);
}
 
template <class ImplementationType> bool FieldMapBasedTag<ImplementationType>::internallySetValue(const IdentifierType &id, const TagValue &value)
{
    auto i = m_fields.find(id);
    if (i != m_fields.end()) { // field already exists -> set its value
        i->second.setValue(value);
    } else if (!value.isEmpty()) { // field doesn't exist -> create new one if value is not null
        m_fields.insert(std::make_pair(id, FieldType(id, value)));
    } else { // otherwise return false
        return false;
    }
    return true;
}
 
template <class ImplementationType>
bool FieldMapBasedTag<ImplementationType>::internallySetValues(const FieldMapBasedTag::IdentifierType &id, const std::vector<TagValue> &values)
{
    auto valuesIterator = values.cbegin();
    auto range = m_fields.equal_range(id);
    // iterate through all specified and all existing values
    for (; valuesIterator != values.cend() && range.first != range.second; ++valuesIterator) {
        // replace existing value with non-empty specified value
        if (!valuesIterator->isEmpty()) {
            auto &field = range.first->second;
            field.clearValue();
            field.setValue(*valuesIterator);
            ++range.first;
        }
    }
    // add remaining specified values (there are more specified values than existing ones)
    for (; valuesIterator != values.cend(); ++valuesIterator) {
        if (!valuesIterator->isEmpty()) {
            m_fields.insert(std::make_pair(id, FieldType(id, *valuesIterator)));
        }
    }
    // remove remaining existing values (there are more existing values than specified ones)
    for (; range.first != range.second; ++range.first) {
        range.first->second.clearValue();
    }
    return true;
}
 
template <class ImplementationType> bool FieldMapBasedTag<ImplementationType>::setValue(const IdentifierType &id, const TagParser::TagValue &value)
{
    return static_cast<ImplementationType *>(this)->internallySetValue(id, value);
}
 
template <class ImplementationType>
bool FieldMapBasedTag<ImplementationType>::setValues(const IdentifierType &id, const std::vector<TagValue> &values)
{
    return static_cast<ImplementationType *>(this)->internallySetValues(id, values);
}
 
template <class ImplementationType> bool FieldMapBasedTag<ImplementationType>::setValues(KnownField field, const std::vector<TagValue> &values)
{
    const auto id = fieldId(field);
    if constexpr (std::is_arithmetic_v<IdentifierType>) {
        if (!id) {
            return false;
        }
    } else {
        if (id.empty()) {
            return false;
        }
    }
    return setValues(id, values);
}
 
template <class ImplementationType> inline bool FieldMapBasedTag<ImplementationType>::hasField(KnownField field) const
{
    return hasField(fieldId(field));
}
 
template <class ImplementationType> bool FieldMapBasedTag<ImplementationType>::internallyHasField(const IdentifierType &id) const
{
    for (auto range = m_fields.equal_range(id); range.first != range.second; ++range.first) {
        if (!range.first->second.value().isEmpty()) {
            return true;
        }
    }
    return false;
}
 
template <class ImplementationType> inline bool FieldMapBasedTag<ImplementationType>::hasField(const IdentifierType &id) const
{
    return static_cast<const ImplementationType *>(this)->internallyHasField(id);
}
 
template <class ImplementationType> inline void FieldMapBasedTag<ImplementationType>::removeAllFields()
{
    m_fields.clear();
}
 
template <class ImplementationType>
inline auto FieldMapBasedTag<ImplementationType>::fields() const -> const std::multimap<IdentifierType, FieldType, Compare> &
{
    return m_fields;
}
 
template <class ImplementationType> inline auto FieldMapBasedTag<ImplementationType>::fields() -> std::multimap<IdentifierType, FieldType, Compare> &
{
    return m_fields;
}
 
template <class ImplementationType> std::size_t FieldMapBasedTag<ImplementationType>::fieldCount() const
{
    auto count = std::size_t(0);
    for (const auto &field : m_fields) {
        if (!field.second.value().isEmpty()) {
            ++count;
        }
    }
    return count;
}
 
template <class ImplementationType>
inline typename FieldMapBasedTag<ImplementationType>::IdentifierType FieldMapBasedTag<ImplementationType>::fieldId(KnownField value) const
{
    return static_cast<const ImplementationType *>(this)->internallyGetFieldId(value);
}
 
template <class ImplementationType> inline KnownField FieldMapBasedTag<ImplementationType>::knownField(const IdentifierType &id) const
{
    return static_cast<const ImplementationType *>(this)->internallyGetKnownField(id);
}
 
template <class ImplementationType> inline bool FieldMapBasedTag<ImplementationType>::supportsField(KnownField field) const
{
    static const auto def = IdentifierType();
    return fieldId(field) != def;
}
 
template <class ImplementationType>
inline TagDataType FieldMapBasedTag<ImplementationType>::internallyGetProposedDataType(const IdentifierType &id) const
{
    return Tag::proposedDataType(knownField(id));
}
 
template <class ImplementationType> inline TagDataType FieldMapBasedTag<ImplementationType>::proposedDataType(const IdentifierType &id) const
{
    return static_cast<ImplementationType *>(this)->determineProposedDataType(id);
}
 
template <class ImplementationType>
std::size_t FieldMapBasedTag<ImplementationType>::insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite)
{
    auto fieldsInserted = std::size_t(0);
    for (const auto &pair : from.fields()) {
        const FieldType &fromField = pair.second;
        if (fromField.value().isEmpty()) {
            continue;
        }
        bool fieldInserted = false;
        auto range = fields().equal_range(fromField.id());
        for (auto i = range.first; i != range.second; ++i) {
            FieldType &ownField = i->second;
            if ((fromField.isTypeInfoAssigned() && ownField.isTypeInfoAssigned() && fromField.typeInfo() == ownField.typeInfo())
                || (!fromField.isTypeInfoAssigned() && !ownField.isTypeInfoAssigned())) {
                if (overwrite || ownField.value().isEmpty()) {
                    ownField = fromField;
                    ++fieldsInserted;
                }
                fieldInserted = true;
                continue;
            }
        }
        if (!fieldInserted) {
            fields().insert(std::make_pair(fromField.id(), fromField));
            ++fieldsInserted;
        }
    }
    return fieldsInserted;
}
 
template <class ImplementationType> std::size_t FieldMapBasedTag<ImplementationType>::insertValues(const Tag &from, bool overwrite)
{
    if (type() == from.type()) {
        // the tags are of the same type, we can insert the fields directly
        return insertFields(static_cast<const FieldMapBasedTag<ImplementationType> &>(from), overwrite);
    } else {
        return Tag::insertValues(from, overwrite);
    }
}
 
template <class ImplementationType> void FieldMapBasedTag<ImplementationType>::ensureTextValuesAreProperlyEncoded()
{
    for (auto &field : fields()) {
        field.second.value().convertDataEncodingForTag(this);
    }
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_FIELDBASEDTAG_H