void ProxyBlockEval::eval(const std::string &id, const Poco::JSON::Object::Ptr &blockDesc)
{
auto env = Pothos::ProxyEnvironment::make("managed");
auto registry = env->findProxy("Pothos/BlockRegistry");
auto path = blockDesc->getValue<std::string>("path");
//load up the constructor args
std::vector<Pothos::Proxy> ctorArgs;
if (blockDesc->isArray("args")) for (auto arg : *blockDesc->getArray("args"))
{
const auto obj = this->lookupOrEvalAsType(arg);
ctorArgs.push_back(env->convertObjectToProxy(obj));
}
//create the block
try
{
_proxyBlock = registry.getHandle()->call(path, ctorArgs.data(), ctorArgs.size());
}
catch (const Pothos::Exception &ex)
{
throw Pothos::Exception("ProxyBlockEval factory("+path+")", ex);
}
_proxyBlock.callVoid("setName", id);
//make the calls
if (blockDesc->isArray("calls")) for (auto call : *blockDesc->getArray("calls"))
{
this->handleCall(call.extract<Poco::JSON::Object::Ptr>());
}
}
string ExposerConfig::extract_token(string response_string) {
try
{
//Try to extract token
Poco::JSON::Parser parser;
Poco::Dynamic::Var result = parser.parse(response_string);
Poco::JSON::Object::Ptr object = result.extract<Poco::JSON::Object::Ptr>();
string tmptoken = object->get("token");
ostringstream tmpmsg;
//tmpmsg << " ===== Got a token: " << tmptoken;
tmpmsg << " ===== Got a token.";
Log::log(Log::INFO, tmpmsg.str());
return tmptoken;
}
catch (std::exception &ex)
{
ostringstream tmpmsg;
tmpmsg << "Exception when trying to read token: " << ex.what();
Log::log(Log::ERROR, tmpmsg.str());
return "";
}
}
void ChannelController::copy()
{
Poco::JSON::Object::Ptr pcfParameters;
if (data().has("input") && data().isObject("input"))
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
std::vector<std::string> parameters = getParameters();
if (parameters.size() > 2)
{
pcfParameters->set("FromChannelName", parameters[2]);
}
if (parameters.size() > 1)
{
pcfParameters->set("ToChannelName", parameters[1]);
}
// Copy all query parameters to PCF
for (Poco::Net::NameValueCollection::ConstIterator it = form().begin(); it != form().end(); ++it)
{
pcfParameters->set(it->first, it->second);
}
}
ChannelCopy command(*commandServer(), pcfParameters);
command.execute();
}
void ChannelController::start()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("input") && data().isObject("input") )
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
setData("input", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter is a channelname
if ( parameters.size() > 1 )
{
pcfParameters->set("ChannelName", parameters[1]);
}
else
{
if ( form().has("ChannelName") ) pcfParameters->set("ChannelName", form().get("ChannelName"));
}
if ( form().has("CommandScope") ) pcfParameters->set("CommandScope", form().get("CommandScope"));
if ( form().has("ChannelDisposition") ) pcfParameters->set("ChannelDisposition", form().get("ChannelDisposition"));
}
ChannelStart command(*commandServer(), pcfParameters);
setData("data", command.execute());
}
void updateTasksList()
{
printf("updateTasksList()\n");
tasksNum = task_manager->getTasksNumber();
if(tasksNum > 0)
{
Poco::JSON::Object::Ptr pObj = new Poco::JSON::Object;
task_manager->getTasks(pObj);
Poco::DynamicStruct ds = *pObj;
printf("ds:%s\n", ds.toString().c_str());
if(pObj->has("tasks"))
printf("pObj has tasks\n");
if(pObj->isArray("tasks"))
printf("pObj is array tasks\n");
Poco::JSON::Array::Ptr pArray = pObj->getArray("tasks");
printf("tasksNum:%d, array size:%d\n", tasksNum, pArray->size());
for(int i = 0; i < tasksNum; i++)
{
memset(pTask[i], 0, sizeof(TaskInfo));
Poco::Dynamic::Var var = pArray->get(i);
Poco::DynamicStruct dss = var.extract<Poco::DynamicStruct>();
pTask[i]->id = (Poco::Int64)dss["id"].extract<Poco::Int64>();
pTask[i]->option = dss["option"].extract<int>();
pTask[i]->hour = dss["hour"].extract<int>();
pTask[i]->minute = dss["minute"].extract<int>();
pTask[i]->weekday = dss["weekday"].extract<int>();
}
}
}
void QueueStatusController::inquire()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("input") && data().isObject("input") )
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
setData("input", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter can be a queuename. If this is passed, the
// query parameter QName or queueName is ignored.
if ( parameters.size() > 1 )
{
pcfParameters->set("QName", parameters[1]);
}
else
{
// Handle query parameters
pcfParameters->set("QName", form().get("QName", "*"));
}
pcfParameters->set("ExcludeSystem", form().get("ExcludeSystem", "false").compare("true") == 0);
pcfParameters->set("ExcludeTemp", form().get("ExcludeTemp", "false").compare("true") == 0);
if ( form().has("CommandScope") )
{
pcfParameters->set("CommandScope", form().get("CommandScope"));
}
if ( form().has("QSGDisposition") )
{
pcfParameters->set("QSGDisposition", form().get("QSGDisposition"));
}
if ( form().has("StatusType") ) pcfParameters->set("StatusType", form().get("StatusType"));
if ( form().has("OpenType") ) pcfParameters->set("OpenType", form().get("OpenType"));
handleFilterForm(pcfParameters);
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
formElementToJSONArray("QStatusAttrs", attrs);
if ( attrs->size() == 0 ) // Nothing found for QStatusAttrs, try Attrs
{
formElementToJSONArray("Attrs", attrs);
}
if ( attrs->size() > 0 )
{
pcfParameters->set("QStatusAttrs", attrs);
}
}
QueueStatusInquire command(*commandServer(), pcfParameters);
setData("data", command.execute());
}
void ChannelController::create()
{
Poco::JSON::Object::Ptr pcfParameters;
if (data().has("input") && data().isObject("input"))
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
std::vector<std::string> parameters = getParameters();
if (parameters.size() > 1)
{
pcfParameters->set("ChannelName", parameters[1]);
}
if (parameters.size() > 2)
{
pcfParameters->set("ChannelType", parameters[2]);
}
// Copy all query parameters to PCF, except ChannelName if it is already set on the URI
for (Poco::Net::NameValueCollection::ConstIterator it = form().begin(); it != form().end(); ++it)
{
if (parameters.size() > 1 && Poco::icompare(it->first, "ChannelName") == 0) continue;
if (parameters.size() > 2 && Poco::icompare(it->first, "ChannelType") == 0) continue;
pcfParameters->set(it->first, it->second);
}
}
ChannelCreate command(*commandServer(), pcfParameters);
command.execute();
}
/***********************************************************************
* block factory - make blocks from JSON object
**********************************************************************/
static Pothos::Proxy makeBlock(
const Pothos::Proxy ®istry,
const Pothos::Proxy &evaluator,
const Poco::JSON::Object::Ptr &blockObj)
{
const auto id = blockObj->getValue<std::string>("id");
if (not blockObj->has("path")) throw Pothos::DataFormatException(
"Pothos::Topology::make()", "blocks["+id+"] missing 'path' field");
const auto path = blockObj->getValue<std::string>("path");
//load up the constructor args
Poco::JSON::Array::Ptr argsArray;
if (blockObj->isArray("args")) argsArray = blockObj->getArray("args");
const auto ctorArgs = evalArgsArray(evaluator, argsArray);
//create the block
auto block = registry.getHandle()->call(path, ctorArgs.data(), ctorArgs.size());
//make the calls
Poco::JSON::Array::Ptr callsArray;
if (blockObj->isArray("calls")) callsArray = blockObj->getArray("calls");
if (callsArray) for (size_t i = 0; i < callsArray->size(); i++)
{
const auto callArray = callsArray->getArray(i);
auto name = callArray->getElement<std::string>(0);
const auto callArgs = evalArgsArray(evaluator, callArray, 1/*offset*/);
block.getHandle()->call(name, callArgs.data(), callArgs.size());
}
return block;
}
int main(int argc, char** argv)
{
Poco::JSON::Object::Ptr obj;
std::string dir = Poco::Environment::get("POCO_BASE") + "/JSON/samples/Benchmark/";
Poco::Path filePath(dir, "input");
std::ostringstream ostr;
if ( filePath.isFile() )
{
Poco::File inputFile(filePath);
if ( inputFile.exists() )
{
Poco::FileInputStream fis(filePath.toString());
Poco::StreamCopier::copyStream(fis, ostr);
}
else
{
std::cout << filePath.toString() << " doesn't exist!" << std::endl;
return 1;
}
}
std::cout << std::setw(25) << "POCO JSON";
std::string jsonStr = ostr.str();
try
{
Poco::JSON::DefaultHandler handler;
Poco::JSON::Parser parser;
parser.setHandler(&handler);
Poco::Timestamp time1;
parser.parse(jsonStr);
Poco::DynamicAny result = handler.result();
Poco::Timestamp time2;
printTimeDiff(time1, time2);
if ( result.type() == typeid(Poco::JSON::Object::Ptr) )
{
obj = result.extract<Poco::JSON::Object::Ptr>();
}
//Serialize to string
std::ostringstream out;
Poco::Timestamp time3;
obj->stringify(out);
Poco::Timestamp time4;
printTimeDiff(time3, time4);
std::cout << std::endl;
}
catch(Poco::JSON::JSONException jsone)
{
std::cout << jsone.message() << std::endl;
}
return 0;
}
void ServiceController::inquire()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("filter") && data().isObject("filter") )
{
pcfParameters = data().getObject("filter");
}
else
{
pcfParameters = new Poco::JSON::Object();
set("filter", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter can be a servicename. If this is passed
// the query parameter ServiceName is ignored.
if ( parameters.size() > 1 )
{
pcfParameters->set("ServiceName", parameters[1]);
}
else
{
// Handle query parameters
std::string serviceNameField;
if ( form().has("ServiceName") )
{
serviceNameField = form().get("ServiceName");
}
else if ( form().has("name") )
{
serviceNameField = form().get("name");
}
if ( serviceNameField.empty() )
{
serviceNameField = "*";
}
pcfParameters->set("ServiceName", serviceNameField);
}
pcfParameters->set("ExcludeSystem", form().get("ExcludeSystem", "false").compare("true") == 0);
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
formElementToJSONArray("ServiceAttrs", attrs);
if ( attrs->size() == 0 ) // Nothing found for ServiceAttrs, try Attrs
{
formElementToJSONArray("Attrs", attrs);
}
if ( attrs->size() > 0 )
{
pcfParameters->set("ServiceAttrs", attrs);
}
handleFilterForm(pcfParameters);
}
ServiceMapper mapper(*commandServer(), pcfParameters);
set("services", mapper.inquire());
}
void save(Archive & ar, const Poco::JSON::Object::Ptr &t, const unsigned int)
{
bool isNull = t.isNull();
ar << isNull;
if (isNull) return;
std::ostringstream oss; t->stringify(oss);
std::string s = oss.str(); ar << s;
}
void BlockEval::eval(const std::string &id, const Poco::JSON::Object::Ptr &blockDesc)
{
auto env = Pothos::ProxyEnvironment::make("managed");
auto registry = env->findProxy("Pothos/BlockRegistry");
auto path = blockDesc->getValue<std::string>("path");
//load up the constructor args
std::vector<Pothos::Proxy> ctorArgs;
for (auto arg : *blockDesc->getArray("args"))
{
const auto propKey = arg.extract<std::string>();
const auto obj = _properties[propKey];
ctorArgs.push_back(env->convertObjectToProxy(obj));
}
//create the block
try
{
_proxyBlock = registry.getHandle()->call(path, ctorArgs.data(), ctorArgs.size());
}
catch (const Pothos::Exception &ex)
{
throw Pothos::Exception("BlockEval factory("+path+")", ex);
}
_proxyBlock.callVoid("setName", id);
//inspect before making any calls -- calls may fails
_portDesc = this->inspectPorts();
//make the calls
for (auto call : *blockDesc->getArray("calls"))
{
const auto callObj = call.extract<Poco::JSON::Object::Ptr>();
const auto callName = callObj->get("name").extract<std::string>();
std::vector<Pothos::Proxy> callArgs;
for (auto arg : *callObj->getArray("args"))
{
const auto propKey = arg.extract<std::string>();
const auto obj = _properties[propKey];
callArgs.push_back(env->convertObjectToProxy(obj));
}
try
{
_proxyBlock.getHandle()->call(callName, callArgs.data(), callArgs.size());
}
catch (const Pothos::Exception &ex)
{
throw Pothos::Exception("BlockEval call("+callName+")", ex);
}
}
//inspect after making calls -- ports may have changed
_portDesc = this->inspectPorts();
}
//! helper to convert the port info vector into JSON for serialization of the block
static Poco::JSON::Array::Ptr portInfosToJSON(const std::vector<Pothos::PortInfo> &infos)
{
Poco::JSON::Array::Ptr array = new Poco::JSON::Array();
for (const auto &info : infos)
{
Poco::JSON::Object::Ptr portInfo = new Poco::JSON::Object();
portInfo->set("name", info.name);
portInfo->set("isSigSlot", info.isSigSlot);
portInfo->set("size", info.dtype.size());
portInfo->set("dtype", info.dtype.toMarkup());
array->add(portInfo);
}
return array;
}
QString BlockPropertiesPanel::getParamDocString(const Poco::JSON::Object::Ptr ¶mDesc)
{
assert(paramDesc);
QString output;
output += QString("<h3>%1</h3>").arg(QString::fromStdString(paramDesc->getValue<std::string>("name")));
if (paramDesc->isArray("desc")) for (const auto &lineObj : *paramDesc->getArray("desc"))
{
const auto line = lineObj.extract<std::string>();
if (line.empty()) output += "<p /><p>";
else output += QString::fromStdString(line)+"\n";
}
else output += QString("<p>%1</p>").arg(tr("Undocumented"));
return output;
}
void GraphConnection::deserialize(Poco::JSON::Object::Ptr obj)
{
auto outputId = QString::fromStdString(obj->getValue<std::string>("outputId"));
auto inputId = QString::fromStdString(obj->getValue<std::string>("inputId"));
auto outputKey = QString::fromStdString(obj->getValue<std::string>("outputKey"));
auto inputKey = QString::fromStdString(obj->getValue<std::string>("inputKey"));
auto draw = dynamic_cast<GraphDraw *>(this->parent());
assert(draw != nullptr);
//resolve IO objects by id
QPointer<GraphObject> inputObj = nullptr;
QPointer<GraphObject> outputObj = nullptr;
for (const auto obj : draw->getGraphObjects(false))
{
if (obj->getId() == inputId) inputObj = obj;
if (obj->getId() == outputId) outputObj = obj;
}
if (inputObj.isNull()) throw Pothos::Exception("GraphConnection::deserialize()", "cant resolve object with ID: '"+inputId.toStdString()+"'");
if (outputObj.isNull()) throw Pothos::Exception("GraphConnection::deserialize()", "cant resolve object with ID: '"+outputId.toStdString()+"'");
this->setupEndpoint(GraphConnectionEndpoint(inputObj, GraphConnectableKey(inputKey, true)));
this->setupEndpoint(GraphConnectionEndpoint(outputObj, GraphConnectableKey(outputKey, false)));
assert(this->getInputEndpoint().isValid());
assert(this->getOutputEndpoint().isValid());
GraphObject::deserialize(obj);
}
void Controller::searchSimilarRequest(std::map<std::string, std::string>& params, const Poco::Dynamic::Var& request) {
Record record;
vector<uint8_t>* image_data = NULL;
int count = 10;
if (params.count("blockHash")) {
record.getHashes()[BlockHash] = str2bin(params["blockHash"]);
}
if (params.count("dHash")) {
record.getHashes()[DHash] = str2bin(params["dHash"]);
}
if (params.count("gaussDHash")) {
record.getHashes()[GaussDHash] = str2bin(params["gaussDHash"]);
}
if (params.count("gauss2DHash")) {
record.getHashes()[Gauss2DHash] = str2bin(params["gauss2DHash"]);
}
if (params.count("gaussBlockHash")) {
record.getHashes()[GaussBlockHash] = str2bin(params["gaussBlockHash"]);
}
if (params.count("url")) {
image_data = Image::fromUrl(params["url"]);
}
if (params.count("count")) {
count = atoi(params["count"].c_str());
}
if (!request.isEmpty()) {
Poco::JSON::Object::Ptr json = request.extract<Poco::JSON::Object::Ptr>();
if (!image_data && json->has("image_base64")) {
image_data = Image::fromBase64(json->getValue<string>("image_base64"));
}
if (!image_data && json->has("image_url")) {
image_data = Image::fromUrl(json->getValue<string>("image_url"));
}
}
if (image_data) {
HashAlgorithmManager::getInstance().attachSimilarHashes(record, image_data);
delete image_data;
}
appio::print_ok(HashManager::getInstance().searchSimilar(record, count));
}
/*!
* Extract an args array and kwargs object parsed from an args string
*/
static void extractArgs(const std::string &argsStr, Poco::JSON::Array::Ptr &args, Poco::JSON::Object::Ptr &kwargs)
{
for (const auto &arg : splitCommaArgs(argsStr))
{
const Poco::StringTokenizer kvpTok(arg, "=", Poco::StringTokenizer::TOK_TRIM);
const std::vector<std::string> kvp(kvpTok.begin(), kvpTok.end());
if (kwargs and kvp.size() == 2) kwargs->set(kvp[0], exprToDynVar(kvp[1]));
else if (args) args->add(exprToDynVar(arg));
}
}
void AuthorityServiceController::inquire()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("filter") && data().isObject("filter") )
{
pcfParameters = data().getObject("filter");
// There is a bug in MQCMD_INQUIRE_AUTH_SERVICE, AuthServiceAttrs is required!
if ( !pcfParameters->has("AuthServiceAttrs") )
{
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
attrs->add("All");
pcfParameters->set("AuthServiceAttrs", attrs);
}
}
else
{
pcfParameters = new Poco::JSON::Object();
set("filter", pcfParameters);
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
formElementToJSONArray("AuthServiceAttrs", attrs);
if ( attrs->size() == 0 ) // Nothing found for AuthServiceAttrs, try Attrs
{
formElementToJSONArray("Attrs", attrs);
}
if ( attrs->size() == 0 ) // Default must be specified for this command!
{
attrs->add("All");
}
pcfParameters->set("AuthServiceAttrs", attrs);
if ( form().has("ServiceComponent") )
{
pcfParameters->set("ServiceComponent", form().get("ServiceComponent"));
}
handleFilterForm(pcfParameters);
}
AuthorityServiceMapper mapper(*commandServer(), pcfParameters);
set("authservices", mapper.inquire());
}
void ProxyBlockEval::handleCall(const Poco::JSON::Object::Ptr &callObj)
{
auto env = Pothos::ProxyEnvironment::make("managed");
const auto callName = callObj->get("name").extract<std::string>();
std::vector<Pothos::Proxy> callArgs;
for (auto arg : *callObj->getArray("args"))
{
const auto obj = this->lookupOrEvalAsType(arg);
callArgs.push_back(env->convertObjectToProxy(obj));
}
try
{
_proxyBlock.getHandle()->call(callName, callArgs.data(), callArgs.size());
}
catch (const Pothos::Exception &ex)
{
throw Pothos::Exception("ProxyBlockEval call("+callName+")", ex);
}
}
Poco::JSON::Object::Ptr AffinityZoneEditor::getCurrentConfig(void) const
{
Poco::JSON::Object::Ptr config = new Poco::JSON::Object();
config->set("color", _colorPicker->currentColor().name().toStdString());
config->set("hostUri", _hostsBox->itemText(_hostsBox->currentIndex()).toStdString());
config->set("processName", _processNameEdit->text().toStdString());
config->set("numThreads", _numThreadsSpin->value());
config->set("priority", _prioritySpin->value()/100.0);
assert(_cpuSelection != nullptr);
config->set("affinityMode", _cpuSelection->mode());
Poco::JSON::Array::Ptr affinityMask = new Poco::JSON::Array();
for (auto num : _cpuSelection->selection()) affinityMask->add(num);
config->set("affinityMask", affinityMask);
config->set("yieldMode", _yieldModeBox->itemData(_yieldModeBox->currentIndex()).toString().toStdString());
return config;
}
void QueueController::clear()
{
Poco::JSON::Object::Ptr pcfParameters;
if (data().has("input") && data().isObject("input"))
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
meta().set("input", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter can be a queuename. If this is passed, the
// query parameter QName or queueName is ignored.
if (parameters.size() > 1)
{
pcfParameters->set("QName", parameters[1]);
}
else
{
// Handle query parameters
pcfParameters->set("QName", form().get("QName", "*"));
}
if (form().has("CommandScope"))
{
pcfParameters->set("CommandScope", form().get("CommandScope"));
}
if (form().has("QSGDisposition"))
{
pcfParameters->set("QSGDisposition", form().get("QSGDisposition"));
}
}
QueueClear command(*commandServer(), pcfParameters);
setData("data", command.execute());
}
void ChannelController::remove()
{
Poco::JSON::Object::Ptr pcfParameters;
if (data().has("input") && data().isObject("input"))
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
meta().set("input", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter can be a queuename. If this is passed, the
// query parameter QName or queueName is ignored.
if (parameters.size() > 1)
{
pcfParameters->set("ChannelName", parameters[1]);
}
else
{
// Handle query parameters
std::string channelName;
if (form().has("ChannelName"))
{
channelName = form().get("ChannelName");
}
pcfParameters->set("ChannelName", channelName);
}
if (form().has("CommandScope"))
{
pcfParameters->set("CommandScope", form().get("CommandScope"));
}
if (form().has("QSGDisposition"))
{
pcfParameters->set("QSGDisposition", form().get("QSGDisposition"));
}
if (form().has("ChannelType"))
{
pcfParameters->set("ChannelType", form().get("ChannelType"));
}
if (form().has("ChannelTable"))
{
pcfParameters->set("ChannelTable", form().get("ChannelTable"));
}
}
ChannelRemove command(*commandServer(), pcfParameters);
command.execute();
}
bool CSystemManager::getDevVersion(Poco::JSON::Object::Ptr& param, std::string& detail)
{
CConfigManager* config = CConfigManager::instance();
JSON::Object::Ptr pUpdate;
config->getConfig("Update", pUpdate);
if(pUpdate.isNull() || !pUpdate->has("infoPath"))
{
detail = "901";
return false;
}
std::string infoPath = pUpdate->getValue<std::string>("infoPath");
File file(infoPath);
if(!file.exists())
{
detail = "465";
return false;
}
Util::JSONConfiguration info;
std::string version;
std::string buildtime;
try
{
info.load(infoPath);
version = info.getString(UPDATE_VERSION_STR);
buildtime = info.getString(UPDATE_BUILDTIME_STR);
}
catch(Exception& e)
{
detail = "465";
warnf("%s, %d: Load device info file failed, %s", __FILE__, __LINE__, e.message().c_str());
return false;
}
if(param->has(REG_TOKEN_STR))
{
param->remove(REG_TOKEN_STR);
}
param->set(SYSTEM_VERSION_STR, version);
param->set(SYSTEM_BUILDTIME_STR, buildtime);
return true;
}
void AffinityZoneEditor::loadFromConfig(const Poco::JSON::Object::Ptr &config)
{
if (config->has("color"))
{
auto color = QString::fromStdString(config->getValue<std::string>("color"));
_colorPicker->blockSignals(true);
_colorPicker->setCurrentColor(QColor(color));
_colorPicker->blockSignals(false);
}
if (config->has("hostUri"))
{
auto uri = QString::fromStdString(config->getValue<std::string>("hostUri"));
this->selectThisUri(uri);
}
if (config->has("processName"))
{
auto name = QString::fromStdString(config->getValue<std::string>("processName"));
_processNameEdit->setText(name);
}
if (config->has("numThreads"))
{
_numThreadsSpin->setValue(config->getValue<int>("numThreads"));
}
if (config->has("priority"))
{
_prioritySpin->setValue(int(config->getValue<double>("priority")*100));
}
if (config->has("affinityMode") and config->has("affinityMask"))
{
auto mode = config->getValue<std::string>("affinityMode");
auto mask = config->getArray("affinityMask");
std::vector<size_t> selection;
for (size_t i = 0; i < mask->size(); i++) selection.push_back(mask->getElement<int>(i));
_cpuSelection->setup(mode, selection);
}
if (config->has("yieldMode"))
{
auto mode = QString::fromStdString(config->getValue<std::string>("yieldMode"));
for (int i = 0; i < _yieldModeBox->count(); i++)
{
if (_yieldModeBox->itemData(i).toString() == mode) _yieldModeBox->setCurrentIndex(i);
}
}
}
static std::vector<std::pair<std::string, std::string>> resolvePorts(
const Poco::JSON::Object::Ptr &topObj,
const std::string &blockId,
const std::string &portName,
const bool resolveSrc
)
{
assert(topObj);
std::vector<std::pair<std::string, std::string>> results;
const auto blocksObj = topObj->getObject("blocks");
assert(blocksObj);
if (not blocksObj->has(blockId)) return results;
const auto blockObj = blocksObj->getObject(blockId);
assert(blockObj);
if (not blockIsHier(blockObj))
{
results.push_back(std::make_pair(blockId, portName));
return results;
}
const auto connsArray = blockObj->getArray("connections");
for (size_t c_i = 0; c_i < connsArray->size(); c_i++)
{
const auto subConnObj = connsArray->getObject(c_i);
assert(subConnObj);
std::string subId, subName;
if (resolveSrc)
{
if (subConnObj->getValue<std::string>("dstId") != blockId) continue;
if (subConnObj->getValue<std::string>("dstName") != portName) continue;
subId = subConnObj->getValue<std::string>("srcId");
subName = subConnObj->getValue<std::string>("srcName");
}
else
{
if (subConnObj->getValue<std::string>("srcId") != blockId) continue;
if (subConnObj->getValue<std::string>("srcName") != portName) continue;
subId = subConnObj->getValue<std::string>("dstId");
subName = subConnObj->getValue<std::string>("dstName");
}
//ignore pass-through connections in this loop
if (subId != blockId) results.push_back(std::make_pair(subId, subName));
}
return results;
}
void addTask()
{
printf("\n>>>> Add task <<<<\n");
printf("Task option:");
int option;
int ret;
ret = 0;
ret = scanf("%d", &option);
printf("Hour:");
int hour;
ret = scanf("%d", &hour);
printf("Minute:");
int minute;
ret = scanf("%d", &minute);
printf("Weekday:");
int weekday = 0;
char str[9];
ret = scanf("%s", str);
unsigned short mask = 0x40;
for(int i = 0; i < 7; i++)
{
if(str[i] == '1')
weekday |= mask;
mask = mask >> 1;
}
printf("%x\n", weekday);
Poco::JSON::Object::Ptr pObj = new Poco::JSON::Object;
pObj->set("option", option);
pObj->set("hour", hour);
pObj->set("minute", minute);
pObj->set("weekday", weekday);
Poco::Int64 retval = task_manager->addTask(pObj);
printf("Add task result: %llu.\n", retval);
updateTasksList();
ret++;
getchar();
}
static Poco::JSON::Array::Ptr getConnectedPortInfos(
const Poco::JSON::Object::Ptr &topObj,
const std::string &blockId,
const bool enbFilter,
const bool isInput)
{
const auto connsArray = topObj->getArray("connections");
const auto blocksObj = topObj->getObject("blocks");
const auto blockObj = blocksObj->getObject(blockId);
//grab the raw ports info
Poco::JSON::Array::Ptr portsInfo(new Poco::JSON::Array());
if (isInput and blockObj->has("inputs")) portsInfo = blockObj->getArray("inputs");
if (not isInput and blockObj->has("outputs")) portsInfo = blockObj->getArray("outputs");
//no filtering? return ASAP
if (not enbFilter) return portsInfo;
Poco::JSON::Array::Ptr filteredPortsInfo(new Poco::JSON::Array());
for (size_t i = 0; i < portsInfo->size(); i++)
{
const auto portInfo = portsInfo->getObject(i);
for (size_t c_i = 0; c_i < connsArray->size(); c_i++)
{
const auto conn = connsArray->getObject(c_i);
if (
(not isInput and blockId == conn->getValue<std::string>("srcId") and portInfo->getValue<std::string>("name") == conn->getValue<std::string>("srcName")) or
(isInput and blockId == conn->getValue<std::string>("dstId") and portInfo->getValue<std::string>("name") == conn->getValue<std::string>("dstName"))
)
{
filteredPortsInfo->add(portInfo);
break;
}
}
}
return filteredPortsInfo;
}
bool BlockTreeWidget::blockDescMatchesFilter(const Poco::JSON::Object::Ptr &blockDesc)
{
if (_filter.isEmpty()) return true;
const auto path = blockDesc->get("path").extract<std::string>();
const auto name = blockDesc->get("name").extract<std::string>();
//construct a candidate string from path, name, categories, and keywords.
std::string candidate = path+name;
if (blockDesc->isArray("categories")) for (auto categoryObj : *blockDesc->getArray("categories"))
{
candidate += categoryObj.extract<std::string>();
}
if(blockDesc->isArray("keywords"))
{
const auto keywords = blockDesc->getArray("keywords");
for(auto keyword : *keywords) candidate += keyword.extract<std::string>();
}
//reject if filter string not found in candidate
candidate = Poco::toLower(candidate);
const auto searchToken = Poco::toLower(_filter.toStdString());
return (candidate.find(searchToken) != std::string::npos);
}
string ExposerConfig::extract_sessionid(string json_string) {
try
{
//Try to extract sessionid
Poco::JSON::Parser parser;
Poco::Dynamic::Var result = parser.parse(json_string);
Poco::JSON::Object::Ptr object = result.extract<Poco::JSON::Object::Ptr>();
string tmpsessionid = object->get("id");
ostringstream tmpmsg;
tmpmsg << " ===== Got a sessionid: " << tmpsessionid;
Log::log(Log::INFO, tmpmsg.str());
return tmpsessionid;
}
catch (Poco::Exception &ex)
{
ostringstream tmpmsg;
tmpmsg << "Exception when trying to read sessionid: " << ex.displayText();
Log::log(Log::ERROR, tmpmsg.str());
return "";
}
}
JNIEXPORT void Java_com_demo_pocodemo_MainActivity_JSONDemo(JNIEnv* env, jobject thiz) {
// smart pointer, so don't worry about cleaning up
Poco::JSON::Object::Ptr inner = new Poco::JSON::Object;
inner->set("some_number", 5);
inner->set("some_string", "xyz");
std::string key = "new_object";
Poco::JSON::Object::Ptr result = new Poco::JSON::Object;
result->set(key, inner);
printf("isObject: %i\n", result->isObject(key)); // true
printf("size of inner json obj : %i\n", inner->size()); // true
}
