#ifndef NetworkCacheKey_h
#define NetworkCacheKey_h
#if ENABLE(NETWORK_CACHE)
#include "NetworkCacheData.h"
#include <wtf/SHA1.h>
#include <wtf/text/WTFString.h>
namespace WebKit {
namespace NetworkCache {
class Encoder;
class Decoder;
class Key {
public:
typedef SHA1::Digest HashType;
Key() { }
Key(const Key&);
Key(Key&&) = default;
Key(const String& partition, const String& type, const String& range, const String& identifier, const Salt&);
Key& operator=(const Key&);
Key& operator=(Key&&) = default;
Key(WTF::HashTableDeletedValueType);
bool isHashTableDeletedValue() const { return m_identifier.isHashTableDeletedValue(); }
bool isNull() const { return m_identifier.isNull(); }
const String& partition() const { return m_partition; }
const String& identifier() const { return m_identifier; }
const String& type() const { return m_type; }
const String& range() const { return m_range; }
const HashType& hash() const { return m_hash; }
const HashType& partitionHash() const { return m_partitionHash; }
static bool stringToHash(const String&, HashType&);
static size_t hashStringLength() { return 2 * sizeof(m_hash); }
String hashAsString() const { return hashAsString(m_hash); }
String partitionHashAsString() const { return hashAsString(m_partitionHash); }
void encode(Encoder&) const;
static bool decode(Decoder&, Key&);
bool operator==(const Key&) const;
bool operator!=(const Key& other) const { return !(*this == other); }
private:
static String hashAsString(const HashType&);
HashType computeHash(const Salt&) const;
HashType computePartitionHash(const Salt&) const;
String m_partition;
String m_type;
String m_identifier;
String m_range;
HashType m_hash;
HashType m_partitionHash;
};
}
}
namespace WTF {
struct NetworkCacheKeyHash {
static unsigned hash(const WebKit::NetworkCache::Key& key)
{
static_assert(SHA1::hashSize >= sizeof(unsigned), "Hash size must be greater than sizeof(unsigned)");
return *reinterpret_cast<const unsigned*>(key.hash().data());
}
static bool equal(const WebKit::NetworkCache::Key& a, const WebKit::NetworkCache::Key& b)
{
return a == b;
}
static const bool safeToCompareToEmptyOrDeleted = false;
};
template<typename T> struct DefaultHash;
template<> struct DefaultHash<WebKit::NetworkCache::Key> {
typedef NetworkCacheKeyHash Hash;
};
template<> struct HashTraits<WebKit::NetworkCache::Key> : SimpleClassHashTraits<WebKit::NetworkCache::Key> {
static const bool emptyValueIsZero = false;
static const bool hasIsEmptyValueFunction = true;
static bool isEmptyValue(const WebKit::NetworkCache::Key& key) { return key.isNull(); }
};
}
#endif
#endif