You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
606 lines
13 KiB
606 lines
13 KiB
|
|
#include <list>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include "UDPTCPNetwork-json.h"
|
|
|
|
/***********************************************************************
|
|
***********************************************************************
|
|
*
|
|
* JSONParse
|
|
*
|
|
***********************************************************************
|
|
***********************************************************************
|
|
*/
|
|
|
|
// FIXME: need to test embedded arrays
|
|
|
|
enum {
|
|
STEP_NONE = 0,
|
|
STEP_STARTNAME,
|
|
STEP_NAME,
|
|
STEP_STARTVALUE,
|
|
STEP_VALUE,
|
|
STEP_END
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////
|
|
//
|
|
// clear out all data
|
|
//
|
|
void JSONParse::Clear() {
|
|
jsondata = "";
|
|
names.clear();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
//
|
|
// read every element and keep only this in memory.
|
|
//
|
|
int JSONParse::Set(std::string json) {
|
|
int i;
|
|
int step;
|
|
int level;
|
|
bool ignorenext;
|
|
|
|
JSONElement jelement;
|
|
|
|
Clear();
|
|
|
|
// find start and read until end
|
|
for (step = STEP_NONE, i = 0, ignorenext = false; i < (int) json.length(); i++) {
|
|
// need to copy next character
|
|
// debug (0, "JSONParse: step:%d i:%d name:'%s' value:'%s'", step, i, jelement.name.c_str(), jelement.value.c_str());
|
|
if (ignorenext) {
|
|
ignorenext = false;
|
|
if (step == STEP_NAME) jelement.name += json[i];
|
|
if (step == STEP_VALUE) jelement.value += json[i];
|
|
}
|
|
|
|
// searching for startname
|
|
else if (step == STEP_NONE) {
|
|
if (json[i] == '{') {
|
|
step = STEP_STARTNAME;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// searching for startname
|
|
else if (step == STEP_STARTNAME) {
|
|
if (json[i] == '"') {
|
|
step = STEP_NAME;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// copy name
|
|
else if (step == STEP_NAME) {
|
|
if (json[i] == '"') {
|
|
step = STEP_STARTVALUE;
|
|
continue;
|
|
}
|
|
else {
|
|
jelement.name += json[i];
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// searching for startvalue
|
|
else if (step == STEP_STARTVALUE) {
|
|
if (json[i] == '"') {
|
|
step = STEP_VALUE;
|
|
jelement.type = JSON_T_STRING;
|
|
continue;
|
|
}
|
|
if (json[i] == '{') {
|
|
step = STEP_VALUE;
|
|
level = 0;
|
|
jelement.type = JSON_T_OBJECT;
|
|
jelement.value = "{";
|
|
continue;
|
|
}
|
|
if (json[i] == '[') {
|
|
step = STEP_VALUE;
|
|
level = 0;
|
|
jelement.type = JSON_T_ARRAY;
|
|
jelement.value = "[";
|
|
continue;
|
|
}
|
|
if ((json[i] >= '0' && json[i] <= '9') ||
|
|
(json[i] == '+' || json[i] == '-')) {
|
|
step = STEP_VALUE;
|
|
level = 0;
|
|
jelement.type = JSON_T_NUMBER;
|
|
jelement.value = json[i];
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// copy value
|
|
else if (step == STEP_VALUE) {
|
|
if (jelement.type == JSON_T_STRING) {
|
|
if (json[i] == '"') step = STEP_END;
|
|
else jelement.value += json[i];
|
|
continue;
|
|
}
|
|
else if (jelement.type == JSON_T_OBJECT) {
|
|
if (json[i] == '}' && level == 0) {
|
|
jelement.value += json[i];
|
|
step = STEP_END;
|
|
}
|
|
else {
|
|
if (json[i] == '{') level++; // increase level
|
|
if (json[i] == '}') level--; // decrease level
|
|
jelement.value += json[i];
|
|
}
|
|
continue;
|
|
}
|
|
else if (jelement.type == JSON_T_ARRAY) {
|
|
if (json[i] == ']' && level == 0) {
|
|
jelement.value += json[i];
|
|
step = STEP_END;
|
|
}
|
|
else {
|
|
if (json[i] == '[') level++; // increase level
|
|
if (json[i] == ']') level--; // decrease level
|
|
jelement.value += json[i];
|
|
}
|
|
continue;
|
|
}
|
|
else if (jelement.type == JSON_T_NUMBER) {
|
|
if ((json[i] < '0' || json[i] > '9') && json[i] != '.' &&
|
|
json[i] != '+' && json[i] != 'e' && json[i] != 'E') step = STEP_END;
|
|
else {
|
|
jelement.value += json[i];
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// another element?
|
|
if (step == STEP_END) {
|
|
if (json[i] == ',') {
|
|
// debug (0, "* JSON.Set Add name:%s", jelement.name.c_str());
|
|
if (jelement.type != JSON_T_NONE) {
|
|
// debug (0, "%s:%d json add element type:%d", __FILE__, __LINE__, jelement.type);
|
|
names.push_back (jelement);
|
|
}
|
|
jelement.Clear();
|
|
step = STEP_STARTNAME;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
// debug (0, "* JSON.Set Add name:%s", jelement.name.c_str());
|
|
if (jelement.type != JSON_T_NONE) {
|
|
// debug (0, "%s:%d json add element type:%d", __FILE__, __LINE__, jelement.type);
|
|
names.push_back (jelement);
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
|
|
int JSONParse::GetValue(std::string varname, std::string *dest) {
|
|
std::list<JSONElement>::iterator iter;
|
|
|
|
if (dest == NULL) return 0;
|
|
*dest = "";
|
|
|
|
for (iter = names.begin(); iter != names.end(); iter++) {
|
|
if (varname.compare(iter->name) == 0) {
|
|
*dest = iter->value;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
|
|
int JSONParse::GetValueInt(std::string varname, int *dest) {
|
|
std::string s;
|
|
int res = GetValue(varname, &s);
|
|
if (res) {
|
|
*dest = atoi (s.c_str());
|
|
return 1;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
|
|
int JSONParse::GetValueInt64(std::string varname, int64_t *dest) {
|
|
std::string s;
|
|
int res = GetValue(varname, &s);
|
|
if (res) {
|
|
*dest = atol (s.c_str());
|
|
return 1;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
|
|
int JSONParse::GetValueString(std::string varname, std::string *dest) {
|
|
std::string s;
|
|
int res = GetValue(varname, &s);
|
|
if (res) {
|
|
*dest = JSONElement::StringRemoveEscape(&s);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
|
|
int JSONParse::GetObject(std::string varname, JSONParse *dest) {
|
|
std::list<JSONElement>::iterator iter;
|
|
|
|
if (dest == NULL) return 0;
|
|
|
|
for (iter = names.begin(); iter != names.end(); iter++) {
|
|
if (varname.compare(iter->name) == 0) {
|
|
dest->Set(iter->value);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
|
|
#define MAXRECURSIVE 255
|
|
/// @brief Reads the source and returns the string of element requested.
|
|
/// @param src source json array
|
|
/// @param idx index to read
|
|
/// @param dest destiantion of the string
|
|
/// @return 0 not found else 1
|
|
int JSONParse::GetIdx(std::string src, int idx, std::string *dest) {
|
|
char recursive[MAXRECURSIVE];
|
|
int i = 0, rcnt = 0, cnt = 0;
|
|
// debug ("src:%s\n\n", src.c_str());
|
|
(*dest) = "";
|
|
|
|
for (i = 0; i < MAXRECURSIVE; i++) recursive[i] = 0;
|
|
for (i = 0; i < (int) src.length() && rcnt < MAXRECURSIVE && cnt <= idx; i++) {
|
|
|
|
/* if (src[i] == '[' || src[i] == ']' || src[i] == '"' || src[i] == ',' || src[i] == '}' || src[i] == '{') {
|
|
int _i;
|
|
debug ("src[i]:%c i:%d rcnt:%d cnt:%d idx:%d recursive:", src[i], i, rcnt, cnt, idx);
|
|
for (int _i = 0; _i < rcnt; _i++) printf ("%c", recursive[_i]);
|
|
printf ("\n");
|
|
}
|
|
*/
|
|
if (src[i] == '[') {
|
|
recursive[rcnt++] = src[i];
|
|
continue;
|
|
}
|
|
else if (src[i] == '{' ) recursive[rcnt++] = src[i];
|
|
else if (src[i] == '}' && recursive[rcnt-1] == '{') rcnt--;
|
|
else if (src[i] == '"' && recursive[rcnt-1] == '"') rcnt--;
|
|
else if (src[i] == '"') recursive[rcnt++] = src[i];
|
|
else if (src[i] == ',' && rcnt == 1) {
|
|
cnt++;
|
|
continue;
|
|
}
|
|
else if (src[i] == ']' && rcnt > 0) {
|
|
continue;
|
|
}
|
|
|
|
if (rcnt > 0 && cnt == idx) {
|
|
(*dest) += src[i];
|
|
if (src[i] == '\\') (*dest) += src[i];
|
|
}
|
|
else {
|
|
if (src[i] == '\\')i++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// final checks
|
|
if (cnt == 0 && idx == 0 && // empty source/array?
|
|
dest->size() == 0) return 0; //
|
|
if (cnt >= idx) return 1; // found the right element
|
|
return 0; // element not found
|
|
}
|
|
#undef MAXRECURSIVE
|
|
|
|
int JSONParse::GetValueIdx(std::string varname, int idx, std::string *dest) {
|
|
std::list<JSONElement>::iterator iter;
|
|
|
|
if (dest == NULL) return 0;
|
|
|
|
for (iter = names.begin(); iter != names.end(); iter++) {
|
|
if (varname.compare(iter->name) == 0) {
|
|
return GetIdx(iter->value, idx, dest);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
int JSONParse::GetObjectIdx(std::string varname, int idx, JSONParse *dest) {
|
|
std::list<JSONElement>::iterator iter;
|
|
std::string deststr;
|
|
int ret = 0;
|
|
|
|
if (dest == NULL) return 0;
|
|
|
|
for (iter = names.begin(); iter != names.end(); iter++) {
|
|
// debug ("name:%s value:%s\n", iter->name.c_str(), iter->value.c_str());
|
|
if (varname.compare(iter->name) == 0) {
|
|
ret = GetIdx(iter->value, idx, &deststr);
|
|
if (ret == 1) dest->Set(deststr);
|
|
// debug ("Return: %s\n", deststr.c_str());
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
std::list<JSONElement> JSONParse::GetElements() {
|
|
std::list<JSONElement> l;
|
|
std::list<JSONElement>::iterator iter;
|
|
|
|
l.clear();
|
|
for (iter = names.begin(); iter != names.end(); iter++) {
|
|
l.push_back(*iter);
|
|
}
|
|
|
|
return l;
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (JSONElement element) {
|
|
names.push_back (element);
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (std::string name, JSONParse jp) {
|
|
JSONElement je;
|
|
je.SetObject(name, jp.ToString());
|
|
names.push_back(je);
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (std::string name, int val) {
|
|
JSONElement je;
|
|
je.Set(name, val);
|
|
names.push_back(je);
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (std::string name, int64_t val) {
|
|
JSONElement je;
|
|
je.Set(name, val);
|
|
names.push_back(je);
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (std::string name, std::string val) {
|
|
JSONElement je;
|
|
je.Set(name, val);
|
|
names.push_back(je);
|
|
};
|
|
|
|
|
|
void JSONParse::AddObject (std::string name, double val) {
|
|
JSONElement je;
|
|
je.Set(name, val);
|
|
names.push_back(je);
|
|
};
|
|
|
|
|
|
std::string JSONParse::ToString() {
|
|
std::list<JSONElement>::iterator iter;
|
|
std::string output;
|
|
int level, i;
|
|
|
|
output = "{";
|
|
|
|
for (level = 1, iter = names.begin(); iter != names.end(); iter++) {
|
|
if (iter != names.begin()) output += ",";
|
|
output += "\n";
|
|
for (i = 0; i < 4*level; i++) output += " ";
|
|
output += iter->GetString();
|
|
}
|
|
|
|
output += "\n}\n";
|
|
|
|
return output;
|
|
};
|
|
|
|
|
|
int JSONParse::LoadFromFile(std::string filename) {
|
|
int fd;
|
|
struct stat fs;
|
|
char *buffer;
|
|
|
|
if (stat(filename.c_str(), &fs) != 0) return -1;
|
|
buffer = (char *) malloc (fs.st_size+1);
|
|
memset (buffer, 0x0, fs.st_size+1);
|
|
|
|
fd = open(filename.c_str(), O_RDONLY);
|
|
if (fd < 0) return -1;
|
|
read (fd, buffer, fs.st_size);
|
|
close (fd);
|
|
|
|
Set(buffer);
|
|
free (buffer);
|
|
|
|
return 0;
|
|
};
|
|
|
|
int JSONParse::SaveToFile(std::string filename) {
|
|
std::ofstream out(filename);
|
|
|
|
if (!out) return -1;
|
|
|
|
out << ToString();
|
|
out.close();
|
|
|
|
return 0;
|
|
};
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
***********************************************************************
|
|
*
|
|
* JSONElement
|
|
*
|
|
***********************************************************************
|
|
***********************************************************************
|
|
*/
|
|
|
|
|
|
std::string JSONElement::StringAddEscape (std::string *s) {
|
|
std::string res = "";
|
|
if (s == NULL) return res;
|
|
|
|
for (int i = 0; i < s->length(); i++) {
|
|
if ((*s)[i] == '\"') {
|
|
res += "\\\"";
|
|
continue;
|
|
}
|
|
res += (*s)[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
std::string JSONElement::StringRemoveEscape (std::string *s) {
|
|
std::string res = "";
|
|
if (s == NULL) return res;
|
|
|
|
for (int i = 0; i < s->length(); i++) {
|
|
if ((*s)[i] == '\\') {
|
|
continue;
|
|
}
|
|
res += (*s)[i];
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
void JSONElement::Set (std::string n, double v) {
|
|
name = n;
|
|
value = std::to_string(v);
|
|
type = JSON_T_NUMBER;
|
|
};
|
|
|
|
|
|
void JSONElement::Set (std::string n, int v) {
|
|
name = n;
|
|
value = std::to_string(v);
|
|
type = JSON_T_NUMBER;
|
|
};
|
|
|
|
|
|
void JSONElement::Set (std::string n, int64_t v) {
|
|
name = n;
|
|
value = std::to_string(v);
|
|
type = JSON_T_NUMBER;
|
|
};
|
|
|
|
|
|
void JSONElement::Set (std::string n, std::string v) {
|
|
name = n;
|
|
value = StringAddEscape(&v);
|
|
type = JSON_T_STRING;
|
|
};
|
|
|
|
|
|
void JSONElement::SetArray (std::string n, std::list<JSONElement> *l) {
|
|
std::list<JSONElement>::iterator iter;
|
|
|
|
name = n;
|
|
value = "[";
|
|
type = JSON_T_STRING;
|
|
|
|
for (iter = l->begin(); iter != l->end(); iter++) {
|
|
if (iter != l->begin()) value += ",";
|
|
value += iter->GetString();
|
|
}
|
|
value += "]";
|
|
};
|
|
|
|
|
|
void JSONElement::SetAddArray (std::string n, std::string jpstring) {
|
|
std::size_t ab; // start of array [
|
|
std::size_t ae; // end of array ]
|
|
|
|
if (type != JSON_T_ARRAY || n.compare (name) != 0) {
|
|
// reset array
|
|
value = "[]";
|
|
name = n;
|
|
}
|
|
type = JSON_T_ARRAY;
|
|
|
|
ab = value.find_first_of('[');
|
|
ae = value.find_last_of(']');
|
|
|
|
value = value.substr(0, ae);
|
|
|
|
if (value.length() > 2) value += ",";
|
|
value += jpstring + "]";
|
|
}
|
|
|
|
|
|
void JSONElement::SetObject (std::string n, std::string s) {
|
|
name = n;
|
|
value = s;
|
|
type = JSON_T_OBJECT;
|
|
};
|
|
|
|
|
|
std::string JSONElement::GetString () {
|
|
std::string output = "";
|
|
std::string filename = __FILE__;
|
|
|
|
switch (type) {
|
|
case(JSON_T_NUMBER):
|
|
output += "\"" + name + "\" : " + value;
|
|
break;
|
|
case(JSON_T_STRING):
|
|
if (value.length()==0) {
|
|
output += "\"" + name + "\" : \"\"";
|
|
}
|
|
else if (value[0] != '"') {
|
|
output += "\"" + name + "\" : \"" + value + "\"";
|
|
}
|
|
else output += "\"" + name + "\" : " + value;
|
|
break;
|
|
case(JSON_T_OBJECT):
|
|
output += "\"" + name + "\" : " + value;
|
|
break;
|
|
case(JSON_T_ARRAY):
|
|
if (value.length()==0) {
|
|
output += "\"" + name + "\" : []";
|
|
}
|
|
else if (value[0] != '[') {
|
|
output += "\"" + name + "\" : [" + value + "]";
|
|
}
|
|
else output += "\"" + name + "\" : " + value;
|
|
break;
|
|
default:
|
|
output += "\"error\" : \""+ filename + ":" + std::to_string(__LINE__)
|
|
+" JSONElement unknown type error ("+std::to_string(type)+")\"";
|
|
break;
|
|
}
|
|
|
|
return output;
|
|
};
|
|
|