generictagfield.h

Go to the documentation of this file.

#ifndef TAG_PARSER_TAGFIELD_H
#define TAG_PARSER_TAGFIELD_H
 
#include "./tagvalue.h"
 
namespace TagParser {
 
template <class implementationType> class TagField;
 
template <typename ImplementationType> class TagFieldTraits {};
 
template <class ImplementationType> class TAG_PARSER_EXPORT TagField {
    friend class TagFieldTraits<ImplementationType>;
 
public:
    using IdentifierType = typename TagFieldTraits<ImplementationType>::IdentifierType;
    using TypeInfoType = typename TagFieldTraits<ImplementationType>::TypeInfoType;
 
    TagField();
    TagField(const IdentifierType &id, const TagValue &value);
    ~TagField();
 
    IdentifierType &id();
    const IdentifierType &id() const;
    std::string idToString() const;
    void setId(const IdentifierType &id);
    void clearId();
 
    TagValue &value();
    const TagValue &value() const;
    void setValue(const TagValue &value);
    void clearValue();
 
    const TypeInfoType &typeInfo() const;
    void setTypeInfo(const TypeInfoType &typeInfo);
    void removeTypeInfo();
    bool isTypeInfoAssigned() const;
 
    bool isDefault() const;
    void setDefault(bool isDefault);
 
    void clear();
 
    bool isAdditionalTypeInfoUsed() const;
 
    const std::vector<ImplementationType> &nestedFields() const;
    std::vector<ImplementationType> &nestedFields();
    bool supportsNestedFields() const;
 
protected:
    void internallyClearValue();
    void internallyClearFurtherData();
 
private:
    IdentifierType m_id;
    TagValue m_value;
    TypeInfoType m_typeInfo;
    bool m_typeInfoAssigned;
    bool m_default;
    std::vector<ImplementationType> m_nestedFields;
};
 
template <class ImplementationType>
TagField<ImplementationType>::TagField()
    : m_id(IdentifierType())
    , m_value(TagValue())
    , m_typeInfo(TypeInfoType())
    , m_typeInfoAssigned(false)
    , m_default(false)
{
}
 
template <class ImplementationType>
TagField<ImplementationType>::TagField(const IdentifierType &id, const TagValue &value)
    : m_id(id)
    , m_value(value)
    , m_typeInfo(TypeInfoType())
    , m_typeInfoAssigned(false)
    , m_default(false)
{
}
 
template <class ImplementationType> TagField<ImplementationType>::~TagField()
{
}
 
template <class ImplementationType> inline typename TagField<ImplementationType>::IdentifierType &TagField<ImplementationType>::id()
{
    return m_id;
}
 
template <class ImplementationType> inline const typename TagField<ImplementationType>::IdentifierType &TagField<ImplementationType>::id() const
{
    return m_id;
}
 
template <class ImplementationType> inline std::string TagField<ImplementationType>::idToString() const
{
    return ImplementationType::fieldIdToString(m_id);
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::setId(const IdentifierType &id)
{
    m_id = id;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::clearId()
{
    m_id = IdentifierType();
}
 
template <class ImplementationType> inline TagValue &TagField<ImplementationType>::value()
{
    return m_value;
}
 
template <class ImplementationType> inline const TagValue &TagField<ImplementationType>::value() const
{
    return m_value;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::setValue(const TagValue &value)
{
    m_value = value;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::clearValue()
{
    static_cast<ImplementationType *>(this)->internallyClearValue();
}
 
template <class ImplementationType> inline const typename TagField<ImplementationType>::TypeInfoType &TagField<ImplementationType>::typeInfo() const
{
    return m_typeInfo;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::setTypeInfo(const TypeInfoType &typeInfo)
{
    m_typeInfo = typeInfo;
    m_typeInfoAssigned = true;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::removeTypeInfo()
{
    m_typeInfo = TypeInfoType();
    m_typeInfoAssigned = false;
}
 
template <class ImplementationType> inline bool TagField<ImplementationType>::isTypeInfoAssigned() const
{
    return m_typeInfoAssigned;
}
 
template <class ImplementationType> inline bool TagField<ImplementationType>::isDefault() const
{
    return m_default;
}
 
template <class ImplementationType> inline void TagField<ImplementationType>::setDefault(bool isDefault)
{
    m_default = isDefault;
}
 
template <class ImplementationType> void TagField<ImplementationType>::clear()
{
    clearId();
    clearValue();
    static_cast<ImplementationType *>(this)->internallyClearFurtherData();
    m_typeInfo = TypeInfoType();
    m_typeInfoAssigned = false;
    m_default = true;
}
 
template <class ImplementationType> inline bool TagField<ImplementationType>::isAdditionalTypeInfoUsed() const
{
    return static_cast<ImplementationType *>(this)->isAdditionalTypeInfoUsed();
}
 
template <class ImplementationType> const std::vector<ImplementationType> &TagField<ImplementationType>::nestedFields() const
{
    return m_nestedFields;
}
 
template <class ImplementationType> inline std::vector<ImplementationType> &TagField<ImplementationType>::nestedFields()
{
    return m_nestedFields;
}
 
template <class ImplementationType> inline bool TagField<ImplementationType>::supportsNestedFields() const
{
    return static_cast<ImplementationType *>(this)->supportsNestedFields();
}
 
template <class ImplementationType> void TagField<ImplementationType>::internallyClearValue()
{
    m_value.clearDataAndMetadata();
}
 
template <class ImplementationType> void TagField<ImplementationType>::internallyClearFurtherData()
{
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_TAGFIELD_H