RefPtr<SharedBuffer> serializeIDBKeyData(const IDBKeyData& key)
{
#if USE(CF)
Vector<char> data;
data.append(SIDBKeyVersion);
encodeKey(data, key);
return SharedBuffer::adoptVector(data);
#else
auto encoder = KeyedEncoder::encoder();
key.encode(*encoder);
return encoder->finishEncoding();
#endif
}
static void encodeKey(Vector<char>& data, const IDBKeyData& key)
{
SIDBKeyType type = serializedTypeForKeyType(key.type());
data.append(static_cast<char>(type));
switch (type) {
case SIDBKeyType::Number:
writeDouble(data, key.number());
break;
case SIDBKeyType::Date:
writeDouble(data, key.date());
break;
case SIDBKeyType::String: {
auto string = key.string();
uint32_t length = string.length();
writeLittleEndian(data, length);
for (size_t i = 0; i < length; ++i)
writeLittleEndian(data, string[i]);
break;
}
case SIDBKeyType::Binary: {
auto& buffer = key.binary();
uint64_t size = buffer.size();
writeLittleEndian(data, size);
auto* bufferData = buffer.data();
ASSERT(bufferData || !size);
if (bufferData)
data.append(bufferData->data(), bufferData->size());
break;
}
case SIDBKeyType::Array: {
auto& array = key.array();
uint64_t size = array.size();
writeLittleEndian(data, size);
for (auto& key : array)
encodeKey(data, key);
break;
}
case SIDBKeyType::Min:
case SIDBKeyType::Max:
break;
}
}
void KeyBuilder::createKey( char cp[sizeKey] ) {
GUID guid;
(void)::CoCreateGuid( &guid );
encodeKey( (uint8_t*)&guid, cp );
}
KeyBuilder::KeyBuilder( const uint8_t key[sizeGuid] ) {
encodeKey( (const uint8_t*)key, buf );
}
static void writeEntries(FILE *pStream, const KEntryMap &entryMap, bool defaultGroup, bool &firstEntry, const QCString &localeString)
{
// now write out all other groups.
QCString currentGroup;
for(KEntryMapConstIterator aIt = entryMap.begin(); aIt != entryMap.end(); ++aIt)
{
const KEntryKey &key = aIt.key();
// Either proces the default group or all others
if((key.mGroup != "<default>") == defaultGroup)
continue; // Skip
// Skip default values and group headers.
if((key.bDefault) || key.mKey.isEmpty())
continue; // Skip
const KEntry ¤tEntry = *aIt;
KEntryMapConstIterator aTestIt = aIt;
++aTestIt;
bool hasDefault = (aTestIt != entryMap.end());
if(hasDefault)
{
const KEntryKey &defaultKey = aTestIt.key();
if((!defaultKey.bDefault) || (defaultKey.mKey != key.mKey) || (defaultKey.mGroup != key.mGroup) || (defaultKey.bLocal != key.bLocal))
hasDefault = false;
}
if(hasDefault)
{
// Entry had a default value
if((currentEntry.mValue == (*aTestIt).mValue) && (currentEntry.bDeleted == (*aTestIt).bDeleted))
continue; // Same as default, don't write.
}
else
{
// Entry had no default value.
if(currentEntry.bDeleted)
continue; // Don't write deleted entries if there is no default.
}
if(!defaultGroup && (currentGroup != key.mGroup))
{
if(!firstEntry)
fprintf(pStream, "\n");
currentGroup = key.mGroup;
fprintf(pStream, "[%s]\n", encodeGroup(currentGroup).data());
}
firstEntry = false;
// it is data for a group
fputs(encodeKey(key.mKey.data()), pStream); // Key
if(currentEntry.bNLS)
{
fputc('[', pStream);
fputs(localeString.data(), pStream);
fputc(']', pStream);
}
if(currentEntry.bDeleted)
{
fputs("[$d]\n", pStream); // Deleted
}
else
{
if(currentEntry.bImmutable || currentEntry.bExpand)
{
fputc('[', pStream);
fputc('$', pStream);
if(currentEntry.bImmutable)
fputc('i', pStream);
if(currentEntry.bExpand)
fputc('e', pStream);
fputc(']', pStream);
}
fputc('=', pStream);
fputs(stringToPrintable(currentEntry.mValue).data(), pStream);
fputc('\n', pStream);
}
} // for loop
}
