FontTaggedSettings.h [plain text]
#pragma once
#include <array>
#include <wtf/HashTraits.h>
#include <wtf/Vector.h>
namespace WTF {
class TextStream;
}
namespace WebCore {
typedef std::array<char, 4> FontTag;
inline FontTag fontFeatureTag(const char arr[4]) { return {{ arr[0], arr[1], arr[2], arr[3] }}; }
struct FourCharacterTagHash {
static unsigned hash(const FontTag& characters) { return (characters[0] << 24) | (characters[1] << 16) | (characters[2] << 8) | characters[3]; }
static bool equal(const FontTag& a, const FontTag& b) { return a == b; }
static const bool safeToCompareToEmptyOrDeleted = true;
};
struct FourCharacterTagHashTraits : WTF::GenericHashTraits<FontTag> {
static const bool emptyValueIsZero = true;
static void constructDeletedValue(FontTag& slot) { new (NotNull, std::addressof(slot)) FontTag({{ ff, ff, ff, ff }}); }
static bool isDeletedValue(const FontTag& value) { return value == FontTag({{ ff, ff, ff, ff }}); }
private:
static constexpr char ff = static_cast<char>(0xFF);
};
template <typename T>
class FontTaggedSetting {
public:
FontTaggedSetting() = delete;
FontTaggedSetting(const FontTag&, T value);
FontTaggedSetting(FontTag&&, T value);
bool operator==(const FontTaggedSetting<T>& other) const;
bool operator!=(const FontTaggedSetting<T>& other) const { return !(*this == other); }
bool operator<(const FontTaggedSetting<T>& other) const;
const FontTag& tag() const { return m_tag; }
T value() const { return m_value; }
bool enabled() const { return value(); }
template<class Encoder> void encode(Encoder&) const;
template<class Decoder> static Optional<FontTaggedSetting<T>> decode(Decoder&);
private:
FontTag m_tag;
T m_value;
};
template <typename T>
FontTaggedSetting<T>::FontTaggedSetting(const FontTag& tag, T value)
: m_tag(tag)
, m_value(value)
{
}
template <typename T>
FontTaggedSetting<T>::FontTaggedSetting(FontTag&& tag, T value)
: m_tag(WTFMove(tag))
, m_value(value)
{
}
template <typename T>
bool FontTaggedSetting<T>::operator==(const FontTaggedSetting<T>& other) const
{
return m_tag == other.m_tag && m_value == other.m_value;
}
template <typename T>
bool FontTaggedSetting<T>::operator<(const FontTaggedSetting<T>& other) const
{
return (m_tag < other.m_tag) || (m_tag == other.m_tag && m_value < other.m_value);
}
template <typename T>
template <class Encoder>
void FontTaggedSetting<T>::encode(Encoder& encoder) const
{
encoder << static_cast<uint8_t>(m_tag[0]);
encoder << static_cast<uint8_t>(m_tag[1]);
encoder << static_cast<uint8_t>(m_tag[2]);
encoder << static_cast<uint8_t>(m_tag[3]);
encoder << m_value;
}
template <typename T>
template <class Decoder>
Optional<FontTaggedSetting<T>> FontTaggedSetting<T>::decode(Decoder& decoder)
{
Optional<uint8_t> char0;
decoder >> char0;
if (!char0)
return WTF::nullopt;
Optional<uint8_t> char1;
decoder >> char1;
if (!char1)
return WTF::nullopt;
Optional<uint8_t> char2;
decoder >> char2;
if (!char2)
return WTF::nullopt;
Optional<uint8_t> char3;
decoder >> char3;
if (!char3)
return WTF::nullopt;
Optional<T> value;
decoder >> value;
if (!value)
return WTF::nullopt;
return FontTaggedSetting<T>({{
static_cast<char>(*char0),
static_cast<char>(*char1),
static_cast<char>(*char2),
static_cast<char>(*char3)
}}, *value);
}
template <typename T>
class FontTaggedSettings {
public:
void insert(FontTaggedSetting<T>&&);
bool operator==(const FontTaggedSettings<T>& other) const { return m_list == other.m_list; }
bool operator!=(const FontTaggedSettings<T>& other) const { return !(*this == other); }
bool isEmpty() const { return !size(); }
size_t size() const { return m_list.size(); }
const FontTaggedSetting<T>& operator[](int index) const { return m_list[index]; }
const FontTaggedSetting<T>& at(size_t index) const { return m_list.at(index); }
typename Vector<FontTaggedSetting<T>>::const_iterator begin() const { return m_list.begin(); }
typename Vector<FontTaggedSetting<T>>::const_iterator end() const { return m_list.end(); }
unsigned hash() const;
template<class Encoder> void encode(Encoder&) const;
template<class Decoder> static Optional<FontTaggedSettings<T>> decode(Decoder&);
private:
Vector<FontTaggedSetting<T>> m_list;
};
template <typename T>
void FontTaggedSettings<T>::insert(FontTaggedSetting<T>&& feature)
{
size_t i;
for (i = 0; i < m_list.size(); ++i) {
if (!(feature < m_list[i]))
break;
}
if (i < m_list.size() && feature.tag() == m_list[i].tag())
m_list.remove(i);
m_list.insert(i, WTFMove(feature));
}
template <typename T>
template <class Encoder>
void FontTaggedSettings<T>::encode(Encoder& encoder) const
{
encoder << m_list;
}
template <typename T>
template <class Decoder>
Optional<FontTaggedSettings<T>> FontTaggedSettings<T>::decode(Decoder& decoder)
{
Optional<Vector<FontTaggedSetting<T>>> list;
decoder >> list;
if (!list)
return WTF::nullopt;
FontTaggedSettings result;
result.m_list = WTFMove(*list);
return result;
}
typedef FontTaggedSetting<int> FontFeature;
typedef FontTaggedSettings<int> FontFeatureSettings;
template <> unsigned FontFeatureSettings::hash() const;
typedef FontTaggedSettings<float> FontVariationSettings;
WTF::TextStream& operator<<(WTF::TextStream&, const FontVariationSettings&);
template <> unsigned FontVariationSettings::hash() const;
}