NetworkCacheDecoder.h [plain text]
#ifndef NetworkCacheDecoder_h
#define NetworkCacheDecoder_h
#if ENABLE(NETWORK_CACHE)
#include "NetworkCacheCoder.h"
#include <wtf/SHA1.h>
namespace WebKit {
namespace NetworkCache {
class Decoder {
WTF_MAKE_FAST_ALLOCATED;
public:
Decoder(const uint8_t* buffer, size_t bufferSize);
virtual ~Decoder();
size_t length() const { return m_bufferEnd - m_buffer; }
size_t currentOffset() const { return m_bufferPosition - m_buffer; }
bool verifyChecksum();
bool decodeFixedLengthData(uint8_t*, size_t);
bool decode(bool&);
bool decode(uint8_t&);
bool decode(uint16_t&);
bool decode(uint32_t&);
bool decode(uint64_t&);
bool decode(int32_t&);
bool decode(int64_t&);
bool decode(float&);
bool decode(double&);
template<typename T> bool decodeEnum(T& result)
{
static_assert(sizeof(T) <= 8, "Enum type T must not be larger than 64 bits!");
uint64_t value;
if (!decode(value))
return false;
result = static_cast<T>(value);
return true;
}
template<typename T> bool decode(T& t)
{
return Coder<T>::decode(*this, t);
}
template<typename T>
bool bufferIsLargeEnoughToContain(size_t numElements) const
{
static_assert(std::is_arithmetic<T>::value, "Type T must have a fixed, known encoded size!");
if (numElements > std::numeric_limits<size_t>::max() / sizeof(T))
return false;
return bufferIsLargeEnoughToContain(numElements * sizeof(T));
}
private:
bool bufferIsLargeEnoughToContain(size_t) const;
template<typename Type> bool decodeNumber(Type&);
const uint8_t* m_buffer;
const uint8_t* m_bufferPosition;
const uint8_t* m_bufferEnd;
SHA1 m_sha1;
};
}
}
#endif
#endif