github-starred/ultimatepp
2
0
Fork 0
mirror of https://github.com/ultimatepp/ultimatepp.git synced 2026-07-11 22:03:01 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

Core: Xmlize/Jsonize of containers moved as container methods

Browse source 
git-svn-id: svn://ultimatepp.org/upp/trunk@5506 f0d560ea-af0d-0410-9eb7-867de7ffcac7
This commit is contained in:
cxl 2012-11-01 19:22:25 +00:00
parent 6ea6b06271
commit 8fc22bf83c
11 changed files with 393 additions and 459 deletions
Download patch file Download diff file Expand all files Collapse all files

8
uppsrc/Core/Core.h
View file

@ -259,6 +259,9 @@ inline void operator delete[](void *ptr, const std::nothrow_t&) throw() { UPP::
NAMESPACE_UPP
class XmlIO;
class JsonIO;
#include "Mt.h"
#include "Global.h"
#include "Topt.h"
@ -278,8 +281,6 @@ NAMESPACE_UPP
#include "Tuple.h"
#include "Other.h"
#include "Algo.h"
#include "Vcont.hpp"
#include "Index.hpp"
#include "Value.h"
#include "ValueUtil.h"
@ -319,6 +320,9 @@ NAMESPACE_UPP
#include "Win32Util.h"
#include "Vcont.hpp"
#include "Index.hpp"
#if (defined(HEAPDBG) || defined(TESTLEAKS)) && defined(PLATFORM_POSIX)
extern int sMemDiagInitCount;
#endif

2
uppsrc/Core/Index.h
View file

@ -162,6 +162,8 @@ public:
#ifdef UPP
void Serialize(Stream& s);
void Xmlize(XmlIO& xio, const char *itemtag = "key");
void Jsonize(JsonIO& jio);
#endif
V PickKeys() pick_ { return key; }

24
uppsrc/Core/Index.hpp
View file

@ -234,6 +234,18 @@ void AIndex<T, V, HashFn>::Serialize(Stream& s) {
key.Serialize(s);
hash.Serialize(s);
}
template <class T, class V, class HashFn>
void AIndex<T, V, HashFn>::Xmlize(XmlIO& xio, const char *itemtag)
{
XmlizeIndex<T, AIndex<T, V, HashFn> >(xio, itemtag, *this);
}
template <class T, class V, class HashFn>
void AIndex<T, V, HashFn>::Jsonize(JsonIO& jio)
{
JsonizeIndex<AIndex<T, V, HashFn>, T>(jio, *this);
}
#endif
template <class T, class V, class HashFn>
@ -520,6 +532,18 @@ void AMap<K, T, V, HashFn>::Serialize(Stream& s) {
int version = 0;
s / version % key % value;
}
template <class K, class T, class V, class HashFn>
void AMap<K, T, V, HashFn>::Xmlize(XmlIO& xio)
{
XmlizeMap<K, T, AMap<K, T, V, HashFn> >(xio, "key", "value", *this);
}
template <class K, class T, class V, class HashFn>
void AMap<K, T, V, HashFn>::Jsonize(JsonIO& jio)
{
JsonizeMap<AMap<K, T, V, HashFn>, K, T>(jio, *this, "key", "value");
}
#endif
template <class K, class T, class V, class HashFn>

686
uppsrc/Core/JSON.h
View file

@ -1,361 +1,325 @@
Value ParseJSON(CParser& p);
Value ParseJSON(const char *s);
inline String AsJSON(int i) { return IsNull(i) ? "null" : AsString(i); }
inline String AsJSON(double n) { return IsNull(n) ? "null" : AsString(n); }
inline String AsJSON(bool b) { return b ? "true" : "false"; }
inline String AsJSON(const String& s) { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
inline String AsJSON(const WString& s) { return AsCString(s.ToString(), INT_MAX, NULL, ASCSTRING_JSON); }
inline String AsJSON(const char *s) { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
String AsJSON(const Value& v, const String& indent, bool pretty);
String AsJSON(const Value& v, bool pretty = false);
class JsonArray;
class Json {
String text;
public:
Json& CatRaw(const char *key, const String& val);
String ToString() const { return "{" + text + "}"; }
String operator~() const { return ToString(); }
operator String() const { return ToString(); }
operator bool() const { return text.GetCount(); }
Json& operator()(const char *key, const Value& value) { return CatRaw(key, AsJSON(value)); }
Json& operator()(const char *key, int i) { return CatRaw(key, AsJSON(i)); }
Json& operator()(const char *key, double n) { return CatRaw(key, AsJSON(n)); }
Json& operator()(const char *key, bool b) { return CatRaw(key, AsJSON(b)); }
Json& operator()(const char *key, const String& s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const WString& s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const char *s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const Json& object) { return CatRaw(key, ~object); }
Json& operator()(const char *key, const JsonArray& array);
Json() {}
Json(const char *key, const Value& value) { CatRaw(key, AsJSON(value)); }
Json(const char *key, int i) { CatRaw(key, AsJSON(i)); }
Json(const char *key, double n) { CatRaw(key, AsJSON(n)); }
Json(const char *key, bool b) { CatRaw(key, AsJSON(b)); }
Json(const char *key, const String& s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const WString& s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const char *s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const Json& object) { CatRaw(key, ~object); }
Json(const char *key, const JsonArray& array) { operator()(key, array); }
};
class JsonArray {
String text;
public:
JsonArray& CatRaw(const String& val);
String ToString() const { return "[" + text + "]"; }
String operator~() const { return ToString(); }
operator String() const { return ToString(); }
operator bool() const { return text.GetCount(); }
JsonArray& operator<<(const Value& value) { return CatRaw(AsJSON(value)); }
JsonArray& operator<<(int i) { return CatRaw(AsJSON(i)); }
JsonArray& operator<<(double n) { return CatRaw(AsJSON(n)); }
JsonArray& operator<<(bool b) { return CatRaw(AsJSON(b)); }
JsonArray& operator<<(const String& s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const WString& s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const char *s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const Json& object) { return CatRaw(~object); }
JsonArray& operator<<(const JsonArray& array) { return CatRaw(~array); }
JsonArray() {}
};
inline Json& Json::operator()(const char *key, const JsonArray& array)
{
return CatRaw(key, array);
}
class JsonIO {
const Value *src;
One<ValueMap> map;
Value tgt;
public:
bool IsLoading() const { return src; }
bool IsStoring() const { return !src; }
const Value& Get() const { ASSERT(IsLoading()); return *src; }
void Set(const Value& v) { ASSERT(IsStoring() && !map); tgt = v; }
void Put(Value& v) { ASSERT(IsStoring()); if(map) v = *map; else v = tgt; }
Value GetResult() const { ASSERT(IsStoring()); return map ? Value(*map) : tgt; }
template <class T>
JsonIO& operator()(const char *key, T& value);
JsonIO(const Value& src) : src(&src) {}
JsonIO() { src = NULL; }
};
struct JsonizeError : Exc {
JsonizeError(const String& s) : Exc(s) {}
};
template <class T>
void Jsonize(JsonIO& io, T& var)
{
var.Jsonize(io);
}
template <class T>
JsonIO& JsonIO::operator()(const char *key, T& value)
{
if(IsLoading()) {
const Value& v = (*src)[key];
if(!v.IsVoid()) {
JsonIO jio(v);
Jsonize(jio, value);
}
}
else {
ASSERT(tgt.IsVoid());
if(!map)
map.Create();
JsonIO jio;
Jsonize(jio, value);
if(jio.map)
map->Add(key, *jio.map);
else
map->Add(key, jio.tgt);
}
return *this;
}
template <class T>
Value StoreAsJsonValue(const T& var)
{
JsonIO io;
Jsonize(io, const_cast<T&>(var));
return io.GetResult();
}
template <class T>
void LoadFromJsonValue(T& var, const Value& x)
{
JsonIO io(x);
Jsonize(io, var);
}
template <class T>
String StoreAsJson(const T& var, bool pretty = false)
{
return AsJSON(StoreAsJsonValue(var), pretty);
}
template <class T>
bool LoadFromJson(T& var, const char *json)
{
try {
Value jv = ParseJSON(json);
if(jv.IsError())
return false;
LoadFromJsonValue(var, jv);
}
catch(JsonizeError) {
return false;
}
return true;
}
String sJsonFile(const char *file);
template <class T>
bool StoreAsJsonFile(const T& var, const char *file = NULL, bool pretty = false)
{
return SaveFile(sJsonFile(file), StoreAsJson(var, pretty));;
}
template <class T>
bool LoadFromJsonFile(T& var, const char *file = NULL)
{
return LoadFromJson(var, LoadFile(sJsonFile(file)));
}
template<> void Jsonize(JsonIO& io, int& var);
template<> void Jsonize(JsonIO& io, int16& var);
template<> void Jsonize(JsonIO& io, int64& var);
template<> void Jsonize(JsonIO& io, double& var);
template<> void Jsonize(JsonIO& io, bool& var);
template<> void Jsonize(JsonIO& io, String& var);
template<> void Jsonize(JsonIO& io, WString& var);
template<> void Jsonize(JsonIO& io, Date& var);
template<> void Jsonize(JsonIO& io, Time& var);
template <class T, class V>
void JsonizeArray(JsonIO& io, T& array)
{
if(io.IsLoading()) {
const Value& va = io.Get();
array.SetCount(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
JsonIO jio(va[i]);
Jsonize(jio, array[i]);
}
}
else {
Vector<Value> va;
va.SetCount(array.GetCount());
for(int i = 0; i < array.GetCount(); i++) {
JsonIO jio;
Jsonize(jio, array[i]);
jio.Put(va[i]);
}
io.Set(ValueArray(va));
}
}
template <class T>
void Jsonize(JsonIO& io, Vector<T>& var)
{
JsonizeArray<Vector<T>, T>(io, var);
}
template <class T>
void Jsonize(JsonIO& io, Array<T>& var)
{
JsonizeArray<Array<T>, T>(io, var);
}
template <class T, class K, class V>
void JsonizeMap(JsonIO& io, T& map, const char *keyid, const char *valueid)
{
if(io.IsLoading()) {
map.Clear();
const Value& va = io.Get();
map.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
K key;
V value;
LoadFromJsonValue(key, va[i][keyid]);
LoadFromJsonValue(value, va[i][valueid]);
map.Add(key, value);
}
}
else {
Vector<Value> va;
va.SetCount(map.GetCount());
for(int i = 0; i < map.GetCount(); i++)
if(!map.IsUnlinked(i)) {
ValueMap item;
item.Add(keyid, StoreAsJsonValue(map.GetKey(i)));
item.Add(valueid, StoreAsJsonValue(map[i]));
va[i] = item;
}
io.Set(ValueArray(va));
}
}
template <class K, class V, class H>
void Jsonize(JsonIO& io, VectorMap<K, V, H>& map)
{
JsonizeMap<VectorMap<K, V, H>, K, V>(io, map, "key", "value");
}
template <class K, class V, class H>
void Jsonize(JsonIO& io, ArrayMap<K, V, H>& map)
{
JsonizeMap<ArrayMap<K, V, H>, K, V>(io, map, "key", "value");
}
template <class T, class K, class V>
void JsonizeStringMap(JsonIO& io, T& map)
{
if(io.IsLoading()) {
map.Clear();
const ValueMap& va = io.Get();
map.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
V value;
String key = va.GetKey(i);
LoadFromJsonValue(key, va.GetKey(i));
LoadFromJsonValue(value, va.GetValue(i));
map.Add(key, value);
}
}
else {
Index<Value> index;
Vector<Value> values;
index.Reserve(map.GetCount());
values.Reserve(map.GetCount());
for (int i=0; i<map.GetCount(); ++i)
{
index.Add(StoreAsJsonValue(map.GetKey(i)));
values.Add(StoreAsJsonValue(map[i]));
}
ValueMap vm(index, values);
io.Set(vm);
}
}
template <class K, class V, class H>
void StringMap(JsonIO& io, VectorMap<K, V, H>& map)
{
JsonizeStringMap<VectorMap<K, V, H>, K, V>(io, map);
}
template <class K, class V, class H>
void StringMap(JsonIO& io, ArrayMap<K, V, H>& map)
{
JsonizeStringMap<ArrayMap<K, V, H>, K, V>(io, map);
}
template <class T, class V>
void JsonizeIndex(JsonIO& io, T& index)
{
if(io.IsLoading()) {
const Value& va = io.Get();
index.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
V v;
LoadFromJsonValue(v, va[i]);
index.Add(v);
}
}
else {
Vector<Value> va;
for(int i = 0; i < index.GetCount(); i++)
if(!index.IsUnlinked(i))
va.Add(StoreAsJsonValue(index[i]));
io.Set(ValueArray(va));
}
}
template <class T>
void Jsonize(JsonIO& io, Index<T>& var)
{
JsonizeIndex<Index<T>, T>(io, var);
}
template <class T>
void Jsonize(JsonIO& io, ArrayIndex<T>& var)
{
JsonizeIndex<ArrayIndex<T>, T>(io, var);
}
template <class T>
void JsonizeBySerialize(JsonIO& jio, T& x)
{
String h;
if(jio.IsStoring())
h = HexString(StoreAsString(x));
jio("data", h);
if(jio.IsLoading())
try {
LoadFromString(x, ScanHexString(h));
}
catch(LoadingError) {
throw JsonizeError("jsonize by serialize error");
}
}
Value ParseJSON(CParser& p);
Value ParseJSON(const char *s);
inline String AsJSON(int i) { return IsNull(i) ? "null" : AsString(i); }
inline String AsJSON(double n) { return IsNull(n) ? "null" : AsString(n); }
inline String AsJSON(bool b) { return b ? "true" : "false"; }
inline String AsJSON(const String& s) { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
inline String AsJSON(const WString& s) { return AsCString(s.ToString(), INT_MAX, NULL, ASCSTRING_JSON); }
inline String AsJSON(const char *s) { return AsCString(s, INT_MAX, NULL, ASCSTRING_JSON); }
String AsJSON(const Value& v, const String& indent, bool pretty);
String AsJSON(const Value& v, bool pretty = false);
class JsonArray;
class Json {
String text;
public:
Json& CatRaw(const char *key, const String& val);
String ToString() const { return "{" + text + "}"; }
String operator~() const { return ToString(); }
operator String() const { return ToString(); }
operator bool() const { return text.GetCount(); }
Json& operator()(const char *key, const Value& value) { return CatRaw(key, AsJSON(value)); }
Json& operator()(const char *key, int i) { return CatRaw(key, AsJSON(i)); }
Json& operator()(const char *key, double n) { return CatRaw(key, AsJSON(n)); }
Json& operator()(const char *key, bool b) { return CatRaw(key, AsJSON(b)); }
Json& operator()(const char *key, const String& s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const WString& s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const char *s) { return CatRaw(key, AsJSON(s)); }
Json& operator()(const char *key, const Json& object) { return CatRaw(key, ~object); }
Json& operator()(const char *key, const JsonArray& array);
Json() {}
Json(const char *key, const Value& value) { CatRaw(key, AsJSON(value)); }
Json(const char *key, int i) { CatRaw(key, AsJSON(i)); }
Json(const char *key, double n) { CatRaw(key, AsJSON(n)); }
Json(const char *key, bool b) { CatRaw(key, AsJSON(b)); }
Json(const char *key, const String& s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const WString& s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const char *s) { CatRaw(key, AsJSON(s)); }
Json(const char *key, const Json& object) { CatRaw(key, ~object); }
Json(const char *key, const JsonArray& array) { operator()(key, array); }
};
class JsonArray {
String text;
public:
JsonArray& CatRaw(const String& val);
String ToString() const { return "[" + text + "]"; }
String operator~() const { return ToString(); }
operator String() const { return ToString(); }
operator bool() const { return text.GetCount(); }
JsonArray& operator<<(const Value& value) { return CatRaw(AsJSON(value)); }
JsonArray& operator<<(int i) { return CatRaw(AsJSON(i)); }
JsonArray& operator<<(double n) { return CatRaw(AsJSON(n)); }
JsonArray& operator<<(bool b) { return CatRaw(AsJSON(b)); }
JsonArray& operator<<(const String& s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const WString& s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const char *s) { return CatRaw(AsJSON(s)); }
JsonArray& operator<<(const Json& object) { return CatRaw(~object); }
JsonArray& operator<<(const JsonArray& array) { return CatRaw(~array); }
JsonArray() {}
};
inline Json& Json::operator()(const char *key, const JsonArray& array)
{
return CatRaw(key, array);
}
class JsonIO {
const Value *src;
One<ValueMap> map;
Value tgt;
public:
bool IsLoading() const { return src; }
bool IsStoring() const { return !src; }
const Value& Get() const { ASSERT(IsLoading()); return *src; }
void Set(const Value& v) { ASSERT(IsStoring() && !map); tgt = v; }
void Put(Value& v) { ASSERT(IsStoring()); if(map) v = *map; else v = tgt; }
Value GetResult() const { ASSERT(IsStoring()); return map ? Value(*map) : tgt; }
template <class T>
JsonIO& operator()(const char *key, T& value);
JsonIO(const Value& src) : src(&src) {}
JsonIO() { src = NULL; }
};
struct JsonizeError : Exc {
JsonizeError(const String& s) : Exc(s) {}
};
template <class T>
void Jsonize(JsonIO& io, T& var)
{
var.Jsonize(io);
}
template <class T>
JsonIO& JsonIO::operator()(const char *key, T& value)
{
if(IsLoading()) {
const Value& v = (*src)[key];
if(!v.IsVoid()) {
JsonIO jio(v);
Jsonize(jio, value);
}
}
else {
ASSERT(tgt.IsVoid());
if(!map)
map.Create();
JsonIO jio;
Jsonize(jio, value);
if(jio.map)
map->Add(key, *jio.map);
else
map->Add(key, jio.tgt);
}
return *this;
}
template <class T>
Value StoreAsJsonValue(const T& var)
{
JsonIO io;
Jsonize(io, const_cast<T&>(var));
return io.GetResult();
}
template <class T>
void LoadFromJsonValue(T& var, const Value& x)
{
JsonIO io(x);
Jsonize(io, var);
}
template <class T>
String StoreAsJson(const T& var, bool pretty = false)
{
return AsJSON(StoreAsJsonValue(var), pretty);
}
template <class T>
bool LoadFromJson(T& var, const char *json)
{
try {
Value jv = ParseJSON(json);
if(jv.IsError())
return false;
LoadFromJsonValue(var, jv);
}
catch(JsonizeError) {
return false;
}
return true;
}
String sJsonFile(const char *file);
template <class T>
bool StoreAsJsonFile(const T& var, const char *file = NULL, bool pretty = false)
{
return SaveFile(sJsonFile(file), StoreAsJson(var, pretty));;
}
template <class T>
bool LoadFromJsonFile(T& var, const char *file = NULL)
{
return LoadFromJson(var, LoadFile(sJsonFile(file)));
}
template<> void Jsonize(JsonIO& io, int& var);
template<> void Jsonize(JsonIO& io, int16& var);
template<> void Jsonize(JsonIO& io, int64& var);
template<> void Jsonize(JsonIO& io, double& var);
template<> void Jsonize(JsonIO& io, bool& var);
template<> void Jsonize(JsonIO& io, String& var);
template<> void Jsonize(JsonIO& io, WString& var);
template<> void Jsonize(JsonIO& io, Date& var);
template<> void Jsonize(JsonIO& io, Time& var);
template <class T, class V>
void JsonizeArray(JsonIO& io, T& array)
{
if(io.IsLoading()) {
const Value& va = io.Get();
array.SetCount(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
JsonIO jio(va[i]);
Jsonize(jio, array[i]);
}
}
else {
Vector<Value> va;
va.SetCount(array.GetCount());
for(int i = 0; i < array.GetCount(); i++) {
JsonIO jio;
Jsonize(jio, array[i]);
jio.Put(va[i]);
}
io.Set(ValueArray(va));
}
}
template <class T, class K, class V>
void JsonizeMap(JsonIO& io, T& map, const char *keyid, const char *valueid)
{
if(io.IsLoading()) {
map.Clear();
const Value& va = io.Get();
map.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
K key;
V value;
LoadFromJsonValue(key, va[i][keyid]);
LoadFromJsonValue(value, va[i][valueid]);
map.Add(key, value);
}
}
else {
Vector<Value> va;
va.SetCount(map.GetCount());
for(int i = 0; i < map.GetCount(); i++)
if(!map.IsUnlinked(i)) {
ValueMap item;
item.Add(keyid, StoreAsJsonValue(map.GetKey(i)));
item.Add(valueid, StoreAsJsonValue(map[i]));
va[i] = item;
}
io.Set(ValueArray(va));
}
}
template <class T, class K, class V>
void JsonizeStringMap(JsonIO& io, T& map)
{
if(io.IsLoading()) {
map.Clear();
const ValueMap& va = io.Get();
map.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
V value;
String key = va.GetKey(i);
LoadFromJsonValue(key, va.GetKey(i));
LoadFromJsonValue(value, va.GetValue(i));
map.Add(key, value);
}
}
else {
Index<Value> index;
Vector<Value> values;
index.Reserve(map.GetCount());
values.Reserve(map.GetCount());
for (int i=0; i<map.GetCount(); ++i)
{
index.Add(StoreAsJsonValue(map.GetKey(i)));
values.Add(StoreAsJsonValue(map[i]));
}
ValueMap vm(index, values);
io.Set(vm);
}
}
template <class K, class V, class H>
void StringMap(JsonIO& io, VectorMap<K, V, H>& map)
{
JsonizeStringMap<VectorMap<K, V, H>, K, V>(io, map);
}
template <class K, class V, class H>
void StringMap(JsonIO& io, ArrayMap<K, V, H>& map)
{
JsonizeStringMap<ArrayMap<K, V, H>, K, V>(io, map);
}
template <class T, class V>
void JsonizeIndex(JsonIO& io, T& index)
{
if(io.IsLoading()) {
const Value& va = io.Get();
index.Reserve(va.GetCount());
for(int i = 0; i < va.GetCount(); i++) {
V v;
LoadFromJsonValue(v, va[i]);
index.Add(v);
}
}
else {
Vector<Value> va;
for(int i = 0; i < index.GetCount(); i++)
if(!index.IsUnlinked(i))
va.Add(StoreAsJsonValue(index[i]));
io.Set(ValueArray(va));
}
}
template <class T>
void JsonizeBySerialize(JsonIO& jio, T& x)
{
String h;
if(jio.IsStoring())
h = HexString(StoreAsString(x));
jio("data", h);
if(jio.IsLoading())
try {
LoadFromString(x, ScanHexString(h));
}
catch(LoadingError) {
throw JsonizeError("jsonize by serialize error");
}
}

2
uppsrc/Core/Map.h
View file

@ -89,6 +89,8 @@ public:
#ifdef UPP
void Serialize(Stream& s);
void Xmlize(XmlIO& xio);
void Jsonize(JsonIO& jio);
#endif
void Swap(AMap& x) { UPP::Swap(value, x.value);

4
uppsrc/Core/Vcont.h
View file

@ -95,6 +95,8 @@ public:
#ifdef UPP
void Serialize(Stream& s) { StreamContainer(s, *this); }
void Xmlize(XmlIO& xio, const char *itemtag = "item");
void Jsonize(JsonIO& jio);
#endif
Vector() { vector = NULL; items = alloc = 0; }
@ -228,6 +230,8 @@ public:
#ifdef UPP
void Serialize(Stream& s) { StreamContainer(s, *this); }
void Xmlize(XmlIO& xio, const char *itemtag = "item");
void Jsonize(JsonIO& jio);
#endif
Array() {}

28
uppsrc/Core/Vcont.hpp
View file

@ -324,6 +324,20 @@ void Vector<T>::Set(int i, const T& x, int count) {
}
}
#ifdef UPP
template <class T>
void Vector<T>::Xmlize(XmlIO& xio, const char *itemtag)
{
XmlizeContainer(xio, itemtag, *this);
}
template <class T>
void Vector<T>::Jsonize(JsonIO& jio)
{
JsonizeArray<Vector<T>, T>(jio, *this);
}
#endif
// ------------------
template <class T>
@ -475,6 +489,20 @@ void Array<T>::Insert(int i, const Array& x, int offset, int count) {
vector[q + i] = DeepCopyNew(x[q + offset]);
}
#ifdef UPP
template <class T>
void Array<T>::Xmlize(XmlIO& xio, const char *itemtag)
{
XmlizeContainer(xio, itemtag, *this);
}
template <class T>
void Array<T>::Jsonize(JsonIO& jio)
{
JsonizeArray<Array<T>, T>(jio, *this);
}
#endif
// ------------------
template <class T, int NBLK>

4
uppsrc/Core/Xmlize.cpp
View file

@ -172,9 +172,7 @@ void XmlizeLang(XmlIO& xml, const char *tag, int& lang, const char *id)
String StoreAsXML(Callback1<XmlIO> xmlize, const char *name)
{
String n = Filter(name, CharFilterAlpha);
if(IsNull(n))
n = "app";
String n = Filter(name ? name : "app", CharFilterAlpha);
XmlNode node;
xmlize(XmlIO(node(n), false, Value()));
return AsXML(node);

50
uppsrc/Core/Xmlize.h
View file

@ -74,7 +74,7 @@ void Xmlize(XmlIO& xml, T& var)
template <class T>
void Xmlize(XmlIO& xml, const char* itemtag, T& var)
{
var.Xmlize(xml);
var.Xmlize(xml, itemtag);
}
template <class T> XmlIO XmlIO::operator()(const char *tag, T& var) {
@ -146,30 +146,6 @@ void XmlizeContainer(XmlIO& xml, const char *tag, T& data)
}
}
template<class T>
void Xmlize(XmlIO& xml, Vector<T>& data)
{
XmlizeContainer(xml, "item", data);
}
template<class T>
void Xmlize(XmlIO& xml, const char* itemtag, Vector<T>& data)
{
XmlizeContainer(xml, itemtag, data);
}
template<class T>
void Xmlize(XmlIO& xml, Array<T>& data)
{
XmlizeContainer(xml, "item", data);
}
template<class T>
void Xmlize(XmlIO& xml, const char* itemtag, Array<T>& data)
{
XmlizeContainer(xml, itemtag, data);
}
template<class T>
void XmlizeStore(XmlIO& xml, const T& data)
{
@ -202,18 +178,6 @@ void XmlizeMap(XmlIO& xml, const char *keytag, const char *valuetag, T& data)
}
}
template<class K, class V, class H>
void Xmlize(XmlIO& xml, VectorMap<K, V, H>& data)
{
XmlizeMap<K, V>(xml, "key", "value", data);
}
template<class K, class V, class H>
void Xmlize(XmlIO& xml, ArrayMap<K, V, H>& data)
{
XmlizeMap<K, V>(xml, "key", "value", data);
}
template<class K, class T>
void XmlizeIndex(XmlIO& xml, const char *keytag, T& data)
{
@ -240,18 +204,6 @@ void XmlizeIndex(XmlIO& xml, const char *keytag, T& data)
}
}
template<class K, class H>
void Xmlize(XmlIO& xml, Index<K, H>& data)
{
XmlizeIndex<K>(xml, "key", data);
}
template<class K, class H>
void Xmlize(XmlIO& xml, ArrayIndex<K, H>& data)
{
XmlizeIndex<K>(xml, "key", data);
}
template <class T>
struct ParamHelper__ {
T& data;

20
uppsrc/Core/src.tpp/Jsonize$en-us.tpp
View file

@ -139,26 +139,6 @@ sonIO][@(0.0.255) `&]_[*@3 io], [@(0.0.255) bool`&]_[*@3 var])&]
sonIO][@(0.0.255) `&]_[*@3 io], [_^Date^ Date][@(0.0.255) `&]_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,Time`&`): [@(0.0.255) template]_<>_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ J
sonIO][@(0.0.255) `&]_[*@3 io], [_^Time^ Time][@(0.0.255) `&]_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>
_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io],
[_^Vector^ Vector]<[*@4 T]>`&_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_
[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io],
[_^Array^ Array]<[*@4 T]>`&_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,Index`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_
[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io],
[_^Index^ Index]<[*@4 T]>`&_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,ArrayIndex`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T
]>_[@(0.0.255) void]_[* Jsonize]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io],
[_^ArrayIndex^ ArrayIndex]<[*@4 T]>`&_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,VectorMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) clas
s]_[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Jsoniz
e]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], [_^VectorMap^ VectorMap]<[*@4 K],
[*@4 V], [*@4 H]>`&_[*@3 var])&]
[s5;:Jsonize`(JsonIO`&`,ArrayMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class
]_[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Jsonize
]([_^JsonIO^ JsonIO][@(0.0.255) `&]_[*@3 io], [_^ArrayMap^ ArrayMap]<[*@4 K],
[*@4 V], [*@4 H]>`&_[*@3 var])&]
[s2; Provides Jsonize template specialization to support [*@3 var]
data type.&]
[s3; &]

24
uppsrc/Core/src.tpp/XmlIO$en-us.tpp
View file

@ -270,30 +270,6 @@ mlIO][@(0.0.255) `&]_[*@3 xml], [_^int16^ int16][@(0.0.255) `&]_[*@3 var])&]
mlIO][@(0.0.255) `&]_[*@3 xml], [_^int64^ int64][@(0.0.255) `&]_[*@3 var])&]
[s5;:Xmlize`(XmlIO`&`,byte`&`): [@(0.0.255) template]_<>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ X
mlIO][@(0.0.255) `&]_[*@3 xml], [_^byte^ byte][@(0.0.255) `&]_[*@3 var])&]
[s5;:Xmlize`(XmlIO`&`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_[@(0.0.255) v
oid]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], [_^Vector^ Vector]<[*@4 T]>`&_[*@3 d
ata])&]
[s5;:Xmlize`(XmlIO`&`,const char`*`,Vector`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) c
lass]_[*@4 T]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml],
[@(0.0.255) const]_[@(0.0.255) char`*]_[*@3 itemtag], [_^Vector^ Vector]<[*@4 T]>`&_[*@3 data
])&]
[s5;:Xmlize`(XmlIO`&`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 T]>_[@(0.0.255) v
oid]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml], [_^Array^ Array]<[*@4 T]>`&_[*@3 dat
a])&]
[s5;:Xmlize`(XmlIO`&`,const char`*`,Array`<T`>`&`): [@(0.0.255) template]_<[@(0.0.255) cl
ass]_[*@4 T]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 xml],
[@(0.0.255) const]_[@(0.0.255) char`*]_[*@3 itemtag], [_^Array^ Array]<[*@4 T]>`&_[*@3 data])
&]
[s5;:Xmlize`(XmlIO`&`,ArrayMap`<K`,V`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_
[*@4 K], [@(0.0.255) class]_[*@4 V], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ X
mlIO][@(0.0.255) `&]_[*@3 xml], [_^ArrayMap^ ArrayMap]<[*@4 K], [*@4 V],
[*@4 H]>`&_[*@3 data])&]
[s5;:Xmlize`(XmlIO`&`,Index`<K`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 K],
[@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 x
ml], [_^Index^ Index]<[*@4 K], [*@4 H]>`&_[*@3 data])&]
[s5;:Xmlize`(XmlIO`&`,ArrayIndex`<K`,H`>`&`): [@(0.0.255) template]_<[@(0.0.255) class]_[*@4 K
], [@(0.0.255) class]_[*@4 H]>_[@(0.0.255) void]_[* Xmlize]([_^XmlIO^ XmlIO][@(0.0.255) `&]_[*@3 x
ml], [_^ArrayIndex^ ArrayIndex]<[*@4 K], [*@4 H]>`&_[*@3 data])&]
[s2; Provides template specialization to support Xmlization of [*@3 var]
data types.&]
[s3;%% &]