PersistentCoders.cpp [plain text]
#include "config.h"
#include <wtf/persistence/PersistentCoders.h>
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>
namespace WTF {
namespace Persistence {
void Coder<AtomString>::encode(Encoder& encoder, const AtomString& atomString)
{
encoder << atomString.string();
}
Optional<AtomString> Coder<AtomString>::decode(Decoder& decoder)
{
Optional<String> string;
decoder >> string;
if (!string)
return WTF::nullopt;
return {{ WTFMove(*string) }};
}
void Coder<CString>::encode(Encoder& encoder, const CString& string)
{
if (string.isNull()) {
encoder << std::numeric_limits<uint32_t>::max();
return;
}
uint32_t length = string.length();
encoder << length;
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length);
}
Optional<CString> Coder<CString>::decode(Decoder& decoder)
{
Optional<uint32_t> length;
decoder >> length;
if (!length)
return WTF::nullopt;
if (length == std::numeric_limits<uint32_t>::max()) {
return CString();
}
if (!decoder.bufferIsLargeEnoughToContain<char>(*length))
return WTF::nullopt;
char* buffer;
CString string = CString::newUninitialized(*length, buffer);
if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), *length))
return WTF::nullopt;
return string;
}
void Coder<String>::encode(Encoder& encoder, const String& string)
{
if (string.isNull()) {
encoder << std::numeric_limits<uint32_t>::max();
return;
}
uint32_t length = string.length();
bool is8Bit = string.is8Bit();
encoder << length << is8Bit;
if (is8Bit)
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar));
else
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar));
}
template <typename CharacterType>
static inline Optional<String> decodeStringText(Decoder& decoder, uint32_t length)
{
if (!decoder.bufferIsLargeEnoughToContain<CharacterType>(length))
return WTF::nullopt;
CharacterType* buffer;
String string = String::createUninitialized(length, buffer);
if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType)))
return WTF::nullopt;
return string;
}
Optional<String> Coder<String>::decode(Decoder& decoder)
{
Optional<uint32_t> length;
decoder >> length;
if (!length)
return WTF::nullopt;
if (*length == std::numeric_limits<uint32_t>::max()) {
return String();
}
Optional<bool> is8Bit;
decoder >> is8Bit;
if (!is8Bit)
return WTF::nullopt;
if (*is8Bit)
return decodeStringText<LChar>(decoder, *length);
return decodeStringText<UChar>(decoder, *length);
}
void Coder<SHA1::Digest>::encode(Encoder& encoder, const SHA1::Digest& digest)
{
encoder.encodeFixedLengthData(digest.data(), sizeof(digest));
}
Optional<SHA1::Digest> Coder<SHA1::Digest>::decode(Decoder& decoder)
{
SHA1::Digest tmp;
if (!decoder.decodeFixedLengthData(tmp.data(), sizeof(tmp)))
return WTF::nullopt;
return tmp;
}
}
}