static char *SerializePrefs(SerializableGlobalPrefs& globalPrefs, FileHistory& root, Favorites *favs, size_t* lenOut)
{
char *data = NULL;
BencDict *prefs = new BencDict();
if (!prefs)
goto Error;
BencDict* global = SerializeGlobalPrefs(globalPrefs);
if (!global)
goto Error;
prefs->Add(GLOBAL_PREFS_STR, global);
BencArray *fileHistory = SerializeFileHistory(root, globalPrefs.globalPrefsOnly);
if (!fileHistory)
goto Error;
prefs->Add(FILE_HISTORY_STR, fileHistory);
BencArray *favsArr = SerializeFavorites(favs);
if (!favsArr)
goto Error;
prefs->Add(FAVS_STR, favsArr);
data = prefs->Encode();
*lenOut = str::Len(data);
Error:
delete prefs;
return data;
}
static void DeserializePrefs(const char *prefsTxt, SerializableGlobalPrefs& globalPrefs,
FileHistory& fh, Favorites *favs)
{
BencObj *obj = BencObj::Decode(prefsTxt);
if (!obj || obj->Type() != BT_DICT)
goto Exit;
BencDict *prefs = static_cast<BencDict *>(obj);
BencDict *global = prefs->GetDict(GLOBAL_PREFS_STR);
if (!global)
goto Exit;
DeserializeStruct(gGlobalPrefInfo, dimof(gGlobalPrefInfo), &globalPrefs, global);
free(globalPrefs.prevSerialization);
globalPrefs.prevSerialization = global->Encode();
int weekDiff = GetWeekCount() - globalPrefs.openCountWeek;
globalPrefs.openCountWeek = GetWeekCount();
BencArray *fileHistory = prefs->GetArray(FILE_HISTORY_STR);
if (!fileHistory)
goto Exit;
size_t dlen = fileHistory->Length();
for (size_t i = 0; i < dlen; i++) {
BencDict *dict = fileHistory->GetDict(i);
assert(dict);
if (!dict) continue;
DisplayState *state = DeserializeDisplayState(dict, globalPrefs.globalPrefsOnly);
if (state) {
// "age" openCount statistics (cut in in half after every week)
state->openCount >>= weekDiff;
fh.Append(state);
}
}
BencArray *favsArr = prefs->GetArray(FAVS_STR);
if (!favsArr)
goto Exit;
for (size_t i = 0; i < favsArr->Length(); i += 2) {
BencString *filePathBenc = favsArr->GetString(i);
BencArray *favData = favsArr->GetArray(i+1);
if (!filePathBenc || !favData)
break;
ScopedMem<WCHAR> filePath(filePathBenc->Value());
for (size_t j = 0; j < favData->Length(); j += 2) {
// we're lenient about errors
BencInt *pageNoBenc = favData->GetInt(j);
BencString *nameBenc = favData->GetString(j + 1);
if (!pageNoBenc || !nameBenc)
break;
int pageNo = (int)pageNoBenc->Value();
ScopedMem<WCHAR> name(nameBenc->Value());
favs->AddOrReplace(filePath, pageNo, EmptyToNull(name));
}
}
Exit:
delete obj;
}
static void BencTestStress()
{
char key[64];
char val[64];
WCHAR tval[64];
Vec<BencObj*> stack(29);
BencDict *startDict = new BencDict();
BencDict *d = startDict;
BencArray *a = NULL;
srand((unsigned int)time(NULL));
// generate new dict or array with 5% probability each, close an array or
// dict with 8% probability (less than 10% probability of opening one, to
// encourage nesting), generate int, string or raw strings uniformly
// across the remaining 72% probability
for (int i = 0; i < 10000; i++)
{
int n = rand() % 100;
if (n < 5) {
BencDict *nd = new BencDict();
if (a) {
a->Add(nd);
} else {
GenRandStr(key, dimof(key));
d->Add(key, nd);
}
stack.Push(nd);
d = nd;
a = NULL;
} else if (n < 10) {
BencArray *na = new BencArray();
if (a) {
a->Add(na);
} else {
GenRandStr(key, dimof(key));
d->Add(key, na);
}
stack.Push(na);
d = NULL;
a = na;
} else if (n < 18) {
if (stack.Count() > 0) {
n = rand() % 100;
stack.Pop();
BencObj *o = startDict;
if (stack.Count() > 0) {
o = stack.Last();
}
a = NULL; d = NULL;
if (BT_ARRAY == o->Type()) {
a = static_cast<BencArray *>(o);
} else {
d = static_cast<BencDict *>(o);
}
}
} else if (n < (18 + 24)) {
int64_t v = rand();
if (a) {
a->Add(v);
} else {
GenRandStr(key, dimof(key));
d->Add(key, v);
}
} else if (n < (18 + 24 + 24)) {
GenRandStr(val, dimof(val));
if (a) {
a->AddRaw((const char*)val);
} else {
GenRandStr(key, dimof(key));
d->AddRaw((const char*)key, val);
}
} else {
GenRandTStr(tval, dimof(tval));
if (a) {
a->Add(tval);
} else {
GenRandStr(key, dimof(key));
d->Add((const char*)key, (const WCHAR *)val);
}
}
}
char *s = startDict->Encode();
free(s);
delete startDict;
}
