void JsonRpcPrivate::jsonReaderCallback(std::string const & jsonText) {
Json::Value request;
Json::Value response;
Json::Reader reader;
bool const success(reader.parse(jsonText, request));
if (!success) {
response = parseError();
} else if (request.isObject()) {
response = handleObject(request);
} else if (request.isArray()) {
response = handleArray(request);
} else {
Json::Value const null;
response = invalidRequest(null);
}
if (!response.isNull()) {
try {
serializeAndSendJson(response, m_output);
} catch (const std::exception &e) {
// NOLINT
fprintf(
stderr,
"exception sending response: %s\n",
e.what());
}
}
}
void RemDev::handleItem(char *data) {
/*if (data.size() > MAX_TRANSACTION_SIZE) {
// TODO
return;
}*/
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(data, &error);
// Check for registration before handling parsing errors because it will just
// return if any errors occurred (we don't want to send anything to prevent
// overload attacks if we're unregistered)
if ( ! registered) {
if ( ! doc.isObject()) return;
handleRegistration(doc.object());
return;
}
if (error.error != QJsonParseError::NoError) {
return;
}
if (doc.isArray()) {
// TODO
return;
}
if (doc.isObject()) {
QJsonObject obj = doc.object();
handleObject(obj);
return;
}
// TODO: Failed
}
void BTSerializedEditor::editField(BTDisplay &d, ObjectSerializer &serial, const char *text, XMLAction *curField, int modField, int where)
{
int key;
switch (curField->getType())
{
case XMLTYPE_STDSTRING:
{
std::string val = curField->createString();
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
*(reinterpret_cast<std::string*>(curField->object)) = val;
break;
}
case XMLTYPE_STRING:
{
std::string val = curField->createString();
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
{
char *str = *(reinterpret_cast<char**>(curField->object));
if (str)
{
delete [] str;
}
int len = val.length();
str = new char[len + 1];
strncpy(str, val.c_str(), len);
str[len] = 0;
*(reinterpret_cast<char**>(curField->object)) = str;
}
break;
}
case XMLTYPE_BOOL:
{
BTDisplay::selectItem vals[2];
vals[0].name = "false";
vals[1].name = "true";
int lookupStart(0);
int lookupCurrent((*(reinterpret_cast<bool*>(curField->object)) ? 1 : 0));
d.addSelection(vals, 2, lookupStart, lookupCurrent);
if (27 != d.process())
{
*(reinterpret_cast<bool*>(curField->object)) = lookupCurrent;
}
break;
}
case XMLTYPE_BITFIELD:
{
ValueLookup *lookup = reinterpret_cast<ValueLookup*>(curField->data);
BitField *bits = reinterpret_cast<BitField*>(curField->object);
BTDisplay::selectItem lookupItem[lookup->size()];
for (int i = 0; i < lookup->size(); ++i)
{
lookupItem[i].name = lookup->getName(i);
if (bits->isSet(i))
lookupItem[i].first = '*';
}
int lookupStart(0);
int lookupCurrent(0);
d.addSelection(lookupItem, lookup->size(), lookupStart, lookupCurrent);
int key;
while (27 != (key = d.process()))
{
if (bits->toggle(lookupCurrent))
lookupItem[lookupCurrent].first = '*';
else
lookupItem[lookupCurrent].first = 0;
}
break;
}
case XMLTYPE_INT:
{
if (curField->data)
{
ValueLookup *lookup = reinterpret_cast<ValueLookup*>(curField->data);
bool extra = ((curField->extra == EXTRA_NONE) ? false : true);
BTDisplay::selectItem lookupItem[lookup->size() + (extra ? 1 : 0)];
int i = 0;
if (extra)
{
lookupItem[0].name = curField->extraText;
lookupItem[0].value = -1;
++i;
}
int endIndex = lookup->getEndIndex();
int lookupCurrent(0);
int valIndex((*(reinterpret_cast<int*>(curField->object))) + (extra ? 1 : 0));
for (int curIndex = lookup->getFirstIndex(); curIndex != endIndex; curIndex = lookup->getNextIndex(curIndex))
{
lookupItem[i].name = lookup->getName(curIndex);
lookupItem[i].value = curIndex;
if (curIndex == valIndex)
lookupCurrent = i;
++i;
}
int lookupStart(0);
d.addSelection(lookupItem, lookup->size() + (extra ? 1 : 0), lookupStart, lookupCurrent);
if (27 != d.process())
{
*(reinterpret_cast<int*>(curField->object)) = lookupItem[lookupCurrent].value;
}
}
else
{
std::string val = curField->createString();
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
*(reinterpret_cast<int*>(curField->object)) = atol(val.c_str());
}
break;
}
case XMLTYPE_UINT:
{
std::string val = curField->createString();
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
*(reinterpret_cast<unsigned int*>(curField->object)) = atol(val.c_str());
break;
}
case XMLTYPE_INT16:
{
std::string val = curField->createString();
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
*(reinterpret_cast<int16_t*>(curField->object)) = atol(val.c_str());
break;
}
case XMLTYPE_VECTORUINT:
{
std::vector<unsigned int> *vec = reinterpret_cast<std::vector<unsigned int> *>(curField->object);
std::string val;
for (size_t i = 0; i < vec->size(); ++i)
{
if (i != 0)
val += ",";
char convert[30];
sprintf(convert, "%u", (*vec)[i]);
val += convert;
}
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
{
size_t i = 0;
const char *start = val.c_str();
for (const char *comma = strchr(val.c_str(), ','); (start) && (*start); ++i)
{
if (i < vec->size())
(*vec)[i] = atol(start);
else
vec->push_back(atol(start));
start = comma;
if (start)
{
if ((*start) == ',')
++start;
comma = strchr(start, ',');
}
}
if (i < vec->size())
vec->resize(i);
}
break;
}
case XMLTYPE_OBJECT:
{
XMLObject *obj = reinterpret_cast<XMLObject*>(curField->object);
BTDice *dice = dynamic_cast<BTDice*>(obj);
if (dice)
{
std::ostringstream stream;
stream << dice->getNumber();
std::string val = stream.str();
d.addReadString(std::string(text) + "- Number of Dice: ", 100, val);
key = d.process();
if ('\r' == key)
dice->setNumber(atol(val.c_str()));
d.clearText();
stream.str("");
stream << dice->getType();
val = stream.str();
d.addReadString(std::string(text) + "- Type of Dice: ", 100, val);
key = d.process();
if ('\r' == key)
dice->setType(atol(val.c_str()));
d.clearText();
stream.str("");
stream << dice->getModifier();
val = stream.str();
d.addReadString(std::string(text) + "- Modifier to Roll: ", 100, val);
key = d.process();
if ('\r' == key)
dice->setModifier(atol(val.c_str()));
}
else
printf("Unsuppported type: %d\n", curField->getType());
break;
}
case XMLTYPE_CREATE:
{
XMLArray *obj = reinterpret_cast<XMLArray*>(curField->object);
handleObject(d, obj->get(where), modField);
break;
}
case XMLTYPE_PICTURE:
{
BTDisplayConfig *oldConfig = d.getConfig();
BTDisplayConfig config;
XMLSerializer parser;
config.serialize(&parser);
parser.parse(BTDisplay::applyDisplayDir("data/pictureselect.xml").c_str(), true);
d.setConfig(&config);
d.clearText();
d.addText(text);
int val(reinterpret_cast<PictureIndex*>(curField->object)->value);
d.addSelectImage(val);
key = d.process();
if ('\r' == key)
reinterpret_cast<PictureIndex*>(curField->object)->value = val;
d.clearImage();
d.setConfig(oldConfig);
break;
}
case XMLTYPE_VECTORSTRING:
{
std::vector<std::string> *obj = reinterpret_cast<std::vector<std::string>*>(curField->object);
std::string val = (*obj)[where];
d.addReadString(std::string(text) + ": ", 100, val);
key = d.process();
if ('\r' == key)
(*obj)[where] = val;
break;
}
default:
printf("Unsuppported type: %d\n", curField->getType());
break;
}
d.clearText();
}
void ParserImpl::handle()
{
enum json_type type = json_next(_pJSON);
switch (type)
{
case JSON_DONE:
return;
case JSON_NULL:
_pHandler->null();
break;
case JSON_TRUE:
if (_pHandler) _pHandler->value(true);
break;
case JSON_FALSE:
if (_pHandler) _pHandler->value(false);
break;
case JSON_NUMBER:
{
if (_pHandler)
{
std::string str(json_get_string(_pJSON, NULL));
if (str.find(_decimalPoint) != str.npos || str.find('e') != str.npos || str.find('E') != str.npos)
{
_pHandler->value(NumberParser::parseFloat(str));
}
else
{
Poco::Int64 val;
if (NumberParser::tryParse64(str, val))
_pHandler->value(val);
else
_pHandler->value(NumberParser::parseUnsigned64(str));
}
}
break;
}
case JSON_STRING:
if (_pHandler) _pHandler->value(std::string(json_get_string(_pJSON, NULL)));
break;
case JSON_OBJECT:
if (_pHandler) _pHandler->startObject();
handleObject();
break;
case JSON_OBJECT_END:
if (_pHandler) _pHandler->endObject();
return;
case JSON_ARRAY:
if (_pHandler) _pHandler->startArray();
handleArray();
break;
case JSON_ARRAY_END:
if (_pHandler) _pHandler->endArray();
return;
case JSON_ERROR:
{
const char* pErr = json_get_error(_pJSON);
std::string err(pErr ? pErr : "JSON parser error.");
throw JSONException(err);
}
}
}
