#include <type_traits>
#include <cstdint>
#include <cctype>
#include <vector>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cassert>
template<typename T>
using Array = std::vector<T>;
using String = std::string;
using Integer32 = int32_t;
template <class V>
void Visit(V& v, Integer32& i)
{
v.Visit(i);
}
template <class V>
void Visit(V& v, String& str)
{
v.Visit(str);
}
template <class V, class T>
void Visit(V& v, Array<T>& arr)
{
v.Visit(arr);
}
template <class V, class T>
void Visit(V& v, const char* /*name*/, T& var)
{
//v.Enter(name);
var.Visit(v);
//v.Exit(name);
}
class XMLSerializerVisitor
{
public:
XMLSerializerVisitor()
{
reset();
}
void Enter(const char* name)
{
indent(depth);
output += "<";
output += name;
output += ">\n";
depth++;
}
void Exit(const char* name)
{
depth--;
indent(depth);
output += "</";
output += name;
output += ">\n";
}
template <class T>
void Visit(Array<T>& arr)
{
/*
Integer32 siz = arr.size();
Visit("length", siz);
for (int i = 0; i < arr.size(); i++)
{
char buf[1024];
snprintf(buf, 1024, "element[%i]", i);
Visit(buf, arr.at(i));
}
*/
for (auto i : arr)
{
Visit("item", i);
}
}
void Visit(Integer32& var)
{
indent(depth);
output += std::to_string(var);
output += "\n";
}
void Visit(String& var)
{
// TODO: limitiation is that the string can not have a new line
indent(depth);
output += var;
output += "\n";
}
template <class T>
void Visit(const char* name, T& var)
{
Enter(name);
::Visit(*this, var);
Exit(name);
}
std::string& Output()
{
output += "</xml>\n";
return output;
}
void reset()
{
output = "<xml>\n";
depth = 1;
}
private:
int depth = 0;
std::string output;
void indent(int spaces)
{
for(int i = 0; i < spaces; i++)
{
output += " ";
}
}
};
class XMLDeserializerVisitor
{
public:
XMLDeserializerVisitor(std::string data) : input(data)
{
String str;
Visit(str);
// deserialize the <xml> tag
}
void Enter(const char* name)
{
String str;
Visit(str);
//printf("enter deserializing for -%s-, got -%s-\n", name, str.c_str());
}
void Exit(const char* name)
{
String str;
Visit(str);
//printf("exit deserializing for -%s-, got -%s-\n", name, str.c_str());
}
template <class T>
void Visit(Array<T>& arr)
{
/*
Integer32 siz = 0;
Visit("length", siz);
arr.resize(siz);
//printf("deserializing array of len: %i\n", siz);
for (int i = 0; i < arr.size(); i++)
{
char buf[1024];
snprintf(buf, 1024, "element[%i]", i);
Visit(buf, arr.at(i));
}
*/
while (true)
{
int oldOffset = offset;
String str;
Visit(str);
offset = oldOffset;
if (str != "<item>")
break;
T item;
Visit("item", item);
arr.push_back(item);
}
}
void Visit(Integer32& var)
{
const char* ptr = input.c_str();
char* endPtr;
var = strtol(ptr + offset, &endPtr, 10);
offset = endPtr - ptr;
}
void Visit(String& var)
{
stripWhiteSpace();
int newLineOff = input.find("\n", offset);
if (newLineOff != std::string::npos)
var = input.substr(offset, newLineOff-offset);
offset = newLineOff;
}
template <class T>
void Visit(const char* name, T& var)
{
Enter(name);
::Visit(*this, var);
Exit(name);
}
private:
std::string input;
int offset = 0;
void stripWhiteSpace()
{
while (isspace(input.c_str()[offset]))
{
offset++;
}
}
};
class JsonSerializerVisitor
{
public:
JsonSerializerVisitor()
{
reset();
}
void Enter(const char* name)
{
output += indent(depth) + quoted(name) + " : {\n";
depth++;
}
void Exit(const char* name)
{
output += "\n" + indent(--depth) + "}\n";
}
template <class T>
void Visit(Array<T>& arr)
{
output += "[ ";
for (int i = 0; i < arr.size(); i++)
{
Visit(arr.at(i));
if ( i != arr.size() - 1 )
output += " ,";
output += " ";
}
output += "]";
}
void Visit(Integer32& var)
{
output += std::to_string(var);
}
void Visit(String& var)
{
output += quoted(var.c_str());
}
template <class T>
void Visit(const char* name, T& var)
{
if (lastDepth == depth)
output += " ,\n";
lastDepth = depth;
output += indent(depth) + quoted(name) + " : ";
::Visit(*this, var);
}
std::string& Output()
{
output += "}\n";
return output;
}
void reset()
{
output = "{\n";
depth = 1;
}
private:
int lastDepth = 0;
int depth = 0;
std::string output;
std::string quoted(const char* name)
{
return std::string("\"" + std::string(name) + "\"");
}
std::string indent(int spaces)
{
return std::string(spaces*2, ' ');
}
};
class JsonDeserializerVisitor
{
public:
JsonDeserializerVisitor(std::string data) : input(data)
{
String str;
ParseString(str); // gets the '{'
assert(str == "{");
}
void ParseString(String& var)
{
stripWhiteSpace();
int pos = offset;
while (input.c_str()[pos])
{
if (isspace(input.c_str()[pos]))
{
var = input.substr(offset, pos-offset);
offset = pos;
return;
}
pos++;
}
}
void Enter(const char* name)
{
String str;
ParseString(str); // gets the name
//printf("name: -%s-", quoted(name).c_str());
//printf("str: -%s-", str.c_str());
assert(str == quoted(name));
ParseString(str); // gets the ':'
assert(str == ":");
ParseString(str); // gets the '{'
assert(str == "{");
//printf("enter deserializing for -%s-, got -%s-\n", name, str.c_str());
}
void Exit(const char* name)
{
String str;
ParseString(str); // gets the '}'
assert(str == "}");
//printf("exit deserializing for -%s-, got -%s-\n", name, str.c_str());
}
template <class T>
void Visit(Array<T>& arr)
{
String str;
ParseString(str); // gets the '['
assert(str == "[");
while (true)
{
T item;
Visit(item);
arr.push_back(item);
String str;
ParseString(str); // gets the ',' or ']' or '],'
if (str != ",")
{
//printf("expecting ]");
//printf("str: -%s-", str.c_str());
assert(str == "]");
break;
}
}
}
void Visit(Integer32& var)
{
const char* ptr = input.c_str();
char* endPtr;
var = strtol(ptr + offset, &endPtr, 10);
offset = endPtr - ptr;
}
void Visit(String& var)
{
// TODO
stripWhiteSpace();
int newLineOff = input.find("\"", offset + 1);
if (newLineOff != std::string::npos)
var = input.substr(offset + 1, newLineOff - offset - 1);
offset = newLineOff + 1;
}
template <class T>
void Visit(const char* name, T& var)
{
String str;
ParseString(str); // gets the name
//printf("name: -%s-", quoted(name).c_str());
//printf("str: -%s-", str.c_str());
assert(str == quoted(name));
ParseString(str); // gets the ':'
assert(str == ":");
::Visit(*this, var);
int oldOffset = offset;
ParseString(str); // gets the ',' if there
if (str != ",")
offset = oldOffset;
}
private:
std::string input;
int offset = 0;
std::string quoted(const char* name)
{
return std::string("\"" + std::string(name) + "\"");
}
void stripWhiteSpace()
{
while (isspace(input.c_str()[offset]))
{
offset++;
}
}
};
struct Person
{
Integer32 id;
String name;
Array<String> email;
Array<String> phoneNumbers;
// This can do both the serializing and de-serializing
// This might be good to have generated, but possibly being more explicit could be better too
// Also note the members could be private and this will still work
template <class V>
void Visit(V& v)
{
v.Enter("person");
v.Visit("id",id);
v.Visit("name",name);
v.Visit("email",email);
v.Visit("numbers",phoneNumbers);
v.Exit("person");
}
};
int main(int argc, char* argv[])
{
std::string input;
{
Person a;
a.id = 10;
a.name = "blah";
a.email.push_back("em@ail.com");
a.email.push_back("other@add.com");
a.phoneNumbers.push_back("123555");
XMLSerializerVisitor serializer;
Visit(serializer, "personA", a);
printf("%s", serializer.Output().c_str());
input = serializer.Output();
}
{
Person b;
XMLDeserializerVisitor deserializer(input);
Visit(deserializer, "personB", b);
{
XMLSerializerVisitor serializer;
Visit(serializer, "personB", b);
printf("%s", serializer.Output().c_str());
}
}
{
Person a;
a.id = 10;
a.name = "blah";
a.email.push_back("em@ail.com");
a.email.push_back("other@add.com");
a.phoneNumbers.push_back("123555");
JsonSerializerVisitor serializer;
Visit(serializer, "personA", a);
printf("%s", serializer.Output().c_str());
input = serializer.Output();
}
{
Person b;
JsonDeserializerVisitor deserializer(input);
Visit(deserializer, "personB", b);
{
JsonSerializerVisitor serializer;
Visit(serializer, "personB", b);
printf("%s", serializer.Output().c_str());
}
}
}
