2023-09-08 09:42:40 +00:00
|
|
|
|
#include "device_opt.h"
|
|
|
|
|
|
|
|
|
|
#include <hginclude/utils.h>
|
|
|
|
|
#include <huagao/hgscanner_error.h>
|
|
|
|
|
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
|
|
|
|
|
#include <lang/app_language.h>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// image-processing jsons ...
|
|
|
|
|
|
|
|
|
|
template<class T, class TC>
|
|
|
|
|
static void copy_simple_type(TC* dst, T& src)
|
|
|
|
|
{
|
|
|
|
|
*dst = src;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class T, class TC>
|
|
|
|
|
static bool refine_data_to_range(gb_json* jsn, void* value, void(*cp)(TC*, T&))
|
|
|
|
|
{
|
|
|
|
|
bool refined = false;
|
|
|
|
|
gb_json* range = nullptr;
|
|
|
|
|
|
|
|
|
|
jsn->get_value("range", range);
|
|
|
|
|
if (range)
|
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
T vl, vu, s;
|
|
|
|
|
if (range->get_value("min", vl))
|
|
|
|
|
{
|
|
|
|
|
if (*(TC*)value < vl)
|
|
|
|
|
{
|
|
|
|
|
cp((TC*)value, vl);
|
|
|
|
|
refined = true;
|
|
|
|
|
}
|
|
|
|
|
else if (range->get_value("max", vu))
|
|
|
|
|
{
|
|
|
|
|
if (*(TC*)value > vu)
|
|
|
|
|
{
|
|
|
|
|
cp((TC*)value, vu);
|
|
|
|
|
refined = true;
|
|
|
|
|
}
|
|
|
|
|
else if (range->get_value("step", s))
|
|
|
|
|
{
|
|
|
|
|
T cur(*(TC*)value);
|
|
|
|
|
|
|
|
|
|
vl = cur - vl;
|
|
|
|
|
vl /= s;
|
|
|
|
|
if (!IS_DOUBLE_EQUAL(vl, (int)vl))
|
|
|
|
|
{
|
|
|
|
|
vl += .5f;
|
|
|
|
|
vl = (int)vl * s;
|
|
|
|
|
if (vl > vu)
|
|
|
|
|
vl = vu;
|
|
|
|
|
cp((TC*)value, vl);
|
|
|
|
|
refined = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gb_json* val = range->first_child();
|
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
|
|
while (val)
|
|
|
|
|
{
|
|
|
|
|
if (val->value(vl))
|
|
|
|
|
{
|
|
|
|
|
if (*(TC*)value == vl)
|
|
|
|
|
{
|
|
|
|
|
found = true;
|
|
|
|
|
val->release();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
val->release();
|
|
|
|
|
val = range->next_child();
|
|
|
|
|
}
|
|
|
|
|
if (!found)
|
|
|
|
|
{
|
|
|
|
|
if (jsn->get_value("default", vl))
|
|
|
|
|
{
|
|
|
|
|
refined = true;
|
|
|
|
|
cp((TC*)value, vl);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
range->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return refined;
|
|
|
|
|
}
|
|
|
|
|
static bool refine_string_data(gb_json* jsn, void* value)
|
|
|
|
|
{
|
|
|
|
|
bool refined = false;
|
|
|
|
|
gb_json* range = nullptr;
|
|
|
|
|
std::string v((char*)value);
|
|
|
|
|
|
|
|
|
|
jsn->get_value("range", range);
|
|
|
|
|
if (range)
|
|
|
|
|
{
|
|
|
|
|
std::string vl(""), vu(""), s("");
|
|
|
|
|
if (range->get_value("min", vl))
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (v < vl)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
strcpy((char*)value, vl.c_str());
|
2023-09-08 09:42:40 +00:00
|
|
|
|
refined = true;
|
|
|
|
|
}
|
2023-09-09 10:09:20 +00:00
|
|
|
|
else if (range->get_value("max", vu))
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (v > vu)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
strcpy((char*)value, vu.c_str());
|
2023-09-08 09:42:40 +00:00
|
|
|
|
refined = true;
|
|
|
|
|
}
|
2023-09-09 10:09:20 +00:00
|
|
|
|
//else if (range->get_value("step", s))
|
|
|
|
|
//{
|
|
|
|
|
// T cur(*(TC*)value);
|
|
|
|
|
//
|
|
|
|
|
// vl = cur - vl;
|
|
|
|
|
// vl /= s;
|
|
|
|
|
// if (!IS_DOUBLE_EQUAL(vl, (int)vl))
|
|
|
|
|
// {
|
|
|
|
|
// vl += .5f;
|
|
|
|
|
// vl = (int)vl * s;
|
|
|
|
|
// if (vl > vu)
|
|
|
|
|
// vl = vu;
|
|
|
|
|
// cp((TC*)value, vl);
|
|
|
|
|
// refined = true;
|
|
|
|
|
// }
|
|
|
|
|
//}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gb_json* val = range->first_child();
|
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
|
|
while (val)
|
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (val->value(vl))
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (v == vl)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
|
|
|
|
found = true;
|
|
|
|
|
val->release();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
val->release();
|
|
|
|
|
val = range->next_child();
|
|
|
|
|
}
|
|
|
|
|
if (!found)
|
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (jsn->get_value("default", vl))
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
|
|
|
|
refined = true;
|
2023-09-09 10:09:20 +00:00
|
|
|
|
strcpy((char*)value, vl.c_str());
|
2023-09-08 09:42:40 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
range->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return refined;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class T>
|
|
|
|
|
static std::string get_real_value(gb_json* jsn, bool def_val)
|
|
|
|
|
{
|
|
|
|
|
T v;
|
|
|
|
|
|
|
|
|
|
jsn->get_value(def_val ? "default" : "cur", v);
|
|
|
|
|
|
|
|
|
|
return std::move(std::string((char*)&v, sizeof(v)));
|
|
|
|
|
}
|
|
|
|
|
template<class T>
|
|
|
|
|
static std::string get_real_string(gb_json* jsn, bool def_val)
|
|
|
|
|
{
|
|
|
|
|
T v;
|
|
|
|
|
|
|
|
|
|
jsn->get_value(def_val ? "default" : "cur", v);
|
|
|
|
|
|
|
|
|
|
return std::move(v);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static std::string get_real_value(gb_json* jsn, const char* type)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
bool v = false;
|
|
|
|
|
jsn->value(v);
|
|
|
|
|
|
|
|
|
|
return std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
int v = 0;
|
|
|
|
|
jsn->value(v);
|
|
|
|
|
|
|
|
|
|
return std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
double v = .0f;
|
|
|
|
|
jsn->value(v);
|
|
|
|
|
|
|
|
|
|
return std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
std::string v("");
|
|
|
|
|
jsn->value(v);
|
|
|
|
|
|
|
|
|
|
return std::move(v);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-13 03:20:51 +00:00
|
|
|
|
static struct
|
|
|
|
|
{
|
|
|
|
|
std::string name;
|
|
|
|
|
std::string title; // in UTF8
|
|
|
|
|
}g_known_group_with_sn[] = { {"base", "\xE5\x9F\xBA\xE6\x9C\xAC\xE8\xAE\xBE\xE7\xBD\xAE"}
|
|
|
|
|
, {"bright", "\xE4\xBA\xAE\xE5\xBA\xA6"}
|
|
|
|
|
, {"imgp", "\xE5\x9B\xBE\xE5\x83\x8F\xE5\xA4\x84\xE7\x90\x86"}
|
|
|
|
|
, {"feeder", "\xE9\x80\x81\xE7\xBA\xB8\xE6\x96\xB9\xE5\xBC\x8F\xE8\xAE\xBE\xE7\xBD\xAE"} // <20><><EFBFBD>ã<EFBFBD>\xE8\xAE\xBE\xE7\xBD\xAE
|
|
|
|
|
};
|
|
|
|
|
|
2023-09-08 09:42:40 +00:00
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// class device_opt ...
|
|
|
|
|
bool device_option::condition_value::set_value(gb_json* jsn, const char* type, device_option* parent) // jsn contains only ONE value or its object
|
|
|
|
|
{
|
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
|
|
clear();
|
|
|
|
|
if (jsn->is_leaf_node())
|
|
|
|
|
{
|
|
|
|
|
CONDVAL cv;
|
|
|
|
|
|
|
|
|
|
cv.logic = nullptr;
|
|
|
|
|
cv.value = get_real_value(jsn, type);
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
ret = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gb_json* item = jsn->first_child();
|
|
|
|
|
CONDVAL val0; // make the default value at last
|
|
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
|
val0.logic = nullptr;
|
|
|
|
|
val0.value = "";
|
|
|
|
|
|
|
|
|
|
while (item)
|
|
|
|
|
{
|
|
|
|
|
// "condition": value
|
|
|
|
|
std::string cond(item->key()), val("");
|
|
|
|
|
CONDVAL cv;
|
|
|
|
|
|
|
|
|
|
if (cond == "default")
|
|
|
|
|
{
|
|
|
|
|
val0.logic = nullptr;
|
|
|
|
|
val0.value = get_real_value(item, type);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int end = 0;
|
|
|
|
|
|
|
|
|
|
cv.logic = new simple_logic();
|
|
|
|
|
if (cv.logic->parse(cond.c_str(), &end, &device_option::init_condition, parent))
|
|
|
|
|
{
|
|
|
|
|
cv.value = get_real_value(item, type);
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
delete cv.logic;
|
|
|
|
|
item->release();
|
|
|
|
|
ret = false;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
item->release();
|
|
|
|
|
item = jsn->next_child();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!val0.value.empty())
|
|
|
|
|
vals_.push_back(val0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::range_value::set_value(gb_json* jsn, const char* type, device_option* parent) // jsn contains all range object
|
|
|
|
|
{
|
|
|
|
|
bool ret = true;
|
|
|
|
|
|
|
|
|
|
clear();
|
|
|
|
|
if (jsn->is_array())
|
|
|
|
|
{
|
|
|
|
|
gb_json* item = jsn->first_child();
|
|
|
|
|
while (item)
|
|
|
|
|
{
|
|
|
|
|
device_option::condition_value* v = new device_option::condition_value();
|
|
|
|
|
if (v->set_value(item, type, parent))
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(v);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
delete v;
|
|
|
|
|
item->release();
|
|
|
|
|
ret = false;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
item->release();
|
|
|
|
|
item = jsn->next_child();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
condition_value* cv = nullptr;
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
cv = device_option::to_condition_value<bool>(jsn, "min", type, parent);
|
|
|
|
|
ret = false;
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<bool>(jsn, "max", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<bool>(jsn, "step", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
ret = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
cv = device_option::to_condition_value<int>(jsn, "min", type, parent);
|
|
|
|
|
ret = false;
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<int>(jsn, "max", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<int>(jsn, "step", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
ret = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
cv = device_option::to_condition_value<double>(jsn, "min", type, parent);
|
|
|
|
|
ret = false;
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<double>(jsn, "max", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<double>(jsn, "step", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
ret = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
cv = device_option::to_condition_value<std::string>(jsn, "min", type, parent);
|
|
|
|
|
ret = false;
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<std::string>(jsn, "max", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
cv = device_option::to_condition_value<std::string>(jsn, "step", type, parent);
|
|
|
|
|
if (cv)
|
|
|
|
|
{
|
|
|
|
|
vals_.push_back(cv);
|
|
|
|
|
ret = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2023-09-21 03:23:38 +00:00
|
|
|
|
device_option::device_option(std::function<bool(int)> user_priv) : origin_(nullptr), now_(nullptr)
|
|
|
|
|
, user_(user_priv)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{}
|
|
|
|
|
device_option::~device_option()
|
|
|
|
|
{
|
|
|
|
|
clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::is_equal_b(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(bool*)val == *(bool*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_equal_i(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(int*)val == *(int*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_equal_f(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return IS_DOUBLE_EQUAL(*(double*)val, *(double*)v1);
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_equal_s(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return strcmp((char*)val, from_default_language((char*)v1)) == 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::is_less_b(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(bool*)val < *(bool*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_less_i(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(int*)val < *(int*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_less_f(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(double*)val < *(double*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_less_s(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return strcmp((char*)val, from_default_language((char*)v1)) < 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::is_great_b(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(bool*)val > *(bool*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_great_i(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(int*)val > *(int*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_great_f(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(double*)val > *(double*)v1;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_great_s(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return strcmp((char*)val, from_default_language((char*)v1)) > 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::is_between_b(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(bool*)val == *(bool*)v1 || *(bool*)val <= *(bool*)v2;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_between_i(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(int*)val >= *(int*)v1 && *(int*)val <= *(int*)v2;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_between_f(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return *(double*)val >= *(double*)v1 && *(double*)val <= *(double*)v2;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::is_between_s(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
return strcmp((char*)val, from_default_language((char*)v1)) >= 0 &&
|
|
|
|
|
strcmp((char*)val, from_default_language((char*)v2)) <= 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::is_opt_enabled(gb_json* opt, void* val, void* v1, void* v2)
|
|
|
|
|
{
|
|
|
|
|
bool en = true;
|
|
|
|
|
|
|
|
|
|
if (!opt->get_value("enabled", en))
|
|
|
|
|
en = true;
|
|
|
|
|
|
|
|
|
|
return en;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool device_option::get_equal(const char* type, bool(**f)(gb_json*, void*, void*, void*))
|
|
|
|
|
{
|
|
|
|
|
bool ret = true;
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_equal_b;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_equal_i;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_equal_f;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_equal_s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ret = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::get_less(const char* type, bool(**f)(gb_json*, void*, void*, void*))
|
|
|
|
|
{
|
|
|
|
|
bool ret = true;
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_less_b;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_less_i;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_less_f;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_less_s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ret = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::get_great(const char* type, bool(**f)(gb_json*, void*, void*, void*))
|
|
|
|
|
{
|
|
|
|
|
bool ret = true;
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_great_b;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_great_i;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_great_f;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_great_s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ret = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::get_between(const char* type, bool(**f)(gb_json*, void*, void*, void*))
|
|
|
|
|
{
|
|
|
|
|
bool ret = true;
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_between_b;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_between_i;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_between_f;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
*f = &device_option::is_between_s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ret = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string device_option::from_text_value(const char* type, const char* text_val)
|
|
|
|
|
{
|
|
|
|
|
std::string real_v("");
|
|
|
|
|
|
|
|
|
|
if (strcmp(type, JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
bool v = STRICMP(text_val, "true") == 0;
|
|
|
|
|
real_v = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
int v = atoi(text_val);
|
|
|
|
|
real_v = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
double v = atof(text_val);
|
|
|
|
|
real_v = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(type, JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
real_v = text_val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(real_v);
|
|
|
|
|
}
|
|
|
|
|
bool device_option::parse_simple_logic_expression(gb_json* root, const char* expr, std::string* name, EXPRCALC& calc)
|
|
|
|
|
{
|
|
|
|
|
const char* opers[] = { ">", "<", "!", "=", "." }, * tag = nullptr;
|
|
|
|
|
|
|
|
|
|
for (auto& v : opers)
|
|
|
|
|
{
|
|
|
|
|
tag = strstr(expr, v);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (tag)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!tag)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
std::string n(expr, tag - expr);
|
|
|
|
|
bool ret = true;
|
|
|
|
|
gb_json *child = nullptr;
|
|
|
|
|
|
|
|
|
|
if (name)
|
|
|
|
|
*name = n;
|
|
|
|
|
|
|
|
|
|
calc.name = n;
|
|
|
|
|
root->get_value(n.c_str(), child);
|
|
|
|
|
if (!child)
|
|
|
|
|
return false;
|
|
|
|
|
if (!child->get_value("type", n))
|
|
|
|
|
{
|
|
|
|
|
child->release();
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
child->release();
|
|
|
|
|
|
|
|
|
|
if (*tag == '>')
|
|
|
|
|
{
|
|
|
|
|
if (tag[1] == '=')
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_less(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = true;
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_great(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = false;
|
|
|
|
|
}
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else if (*tag == '<')
|
|
|
|
|
{
|
|
|
|
|
if (tag[1] == '=')
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_great(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = true;
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_less(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = false;
|
|
|
|
|
}
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else if (*tag == '!')
|
|
|
|
|
{
|
|
|
|
|
if (tag[1] == '=')
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_equal(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = true;
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else if (*tag == '=')
|
|
|
|
|
{
|
|
|
|
|
if (tag[1] == '=')
|
|
|
|
|
{
|
|
|
|
|
if (!device_option::get_equal(n.c_str(), &calc.compare))
|
|
|
|
|
return false;
|
|
|
|
|
calc.not_op = false;
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
tag++;
|
|
|
|
|
}
|
|
|
|
|
else if (*tag++ == '.')
|
|
|
|
|
{
|
|
|
|
|
calc.compare = &device_option::is_opt_enabled;
|
|
|
|
|
if (strcmp(tag, "enabled") == 0)
|
|
|
|
|
{
|
|
|
|
|
calc.not_op = false;
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(tag, "!enabled") == 0)
|
|
|
|
|
{
|
|
|
|
|
calc.not_op = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
tag = "";
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// value ...
|
|
|
|
|
if (*tag)
|
|
|
|
|
{
|
|
|
|
|
if (*tag == '[')
|
|
|
|
|
{
|
|
|
|
|
const char* next = strstr(tag++, ",");
|
|
|
|
|
if (next++ == nullptr)
|
|
|
|
|
{
|
|
|
|
|
ret = false;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
std::string v(tag, next - tag - 1);
|
|
|
|
|
calc.val1 = device_option::from_text_value(n.c_str(), v.c_str());
|
|
|
|
|
tag = strstr(next, "]");
|
|
|
|
|
if (!tag)
|
|
|
|
|
ret = false;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
v = std::string(next, tag - next);
|
|
|
|
|
calc.val2 = device_option::from_text_value(n.c_str(), v.c_str());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
calc.val1 = device_option::from_text_value(n.c_str(), tag);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
void device_option::init_condition(const char* expr, void* param)
|
|
|
|
|
{
|
|
|
|
|
if (((device_option*)param)->compare_.count(expr))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
std::string name("");
|
|
|
|
|
EXPRCALC calc;
|
|
|
|
|
|
|
|
|
|
if (device_option::parse_simple_logic_expression(((device_option*)param)->origin_, expr, &name, calc))
|
|
|
|
|
{
|
|
|
|
|
((device_option*)param)->compare_[expr] = calc;
|
|
|
|
|
|
|
|
|
|
if (std::find(((device_option*)param)->master_opts_.begin(), ((device_option*)param)->master_opts_.end(), name)
|
|
|
|
|
== ((device_option*)param)->master_opts_.end())
|
|
|
|
|
((device_option*)param)->master_opts_.push_back(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
bool device_option::calc_simple_logic_expression(const char* expr, void* param)
|
|
|
|
|
{
|
|
|
|
|
device_option* obj = (device_option*)param;
|
|
|
|
|
bool ret = true;
|
|
|
|
|
|
|
|
|
|
if (obj->compare_.count(expr))
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if(obj->now_)
|
|
|
|
|
obj->now_->get_value(obj->compare_[expr].name.c_str(), child);
|
|
|
|
|
else
|
|
|
|
|
obj->origin_->get_value(obj->compare_[expr].name.c_str(), child);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
if (child)
|
|
|
|
|
{
|
|
|
|
|
bool bv = false;
|
|
|
|
|
int nv = 0;
|
|
|
|
|
double dv = .0f;
|
|
|
|
|
std::string sv("");
|
|
|
|
|
void* val = nullptr;
|
|
|
|
|
|
|
|
|
|
child->get_value("type", sv);
|
|
|
|
|
if (strcmp(sv.c_str(), JSON_SANE_TYPE_BOOL) == 0)
|
|
|
|
|
{
|
|
|
|
|
sv = get_real_value<bool>(child, false);
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(sv.c_str(), JSON_SANE_TYPE_INT) == 0)
|
|
|
|
|
{
|
|
|
|
|
sv = get_real_value<int>(child, false);
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(sv.c_str(), JSON_SANE_TYPE_FIXED) == 0)
|
|
|
|
|
{
|
|
|
|
|
sv = get_real_value<double>(child, false);
|
|
|
|
|
}
|
|
|
|
|
else if (strcmp(sv.c_str(), JSON_SANE_TYPE_STRING) == 0)
|
|
|
|
|
{
|
|
|
|
|
child->get_value("cur", sv);
|
|
|
|
|
}
|
|
|
|
|
val = &sv[0];
|
2023-09-09 10:09:20 +00:00
|
|
|
|
ret = obj->compare_[expr].compare(child, val, &obj->compare_[expr].val1[0], &obj->compare_[expr].val2[0]) ^ obj->compare_[expr].not_op;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void device_option::clear(void)
|
|
|
|
|
{
|
|
|
|
|
if (origin_)
|
|
|
|
|
origin_->release();
|
|
|
|
|
if (now_)
|
|
|
|
|
now_->release();
|
|
|
|
|
origin_ = now_ = nullptr;
|
|
|
|
|
|
|
|
|
|
master_opts_.clear();
|
|
|
|
|
compare_.clear();
|
|
|
|
|
|
|
|
|
|
for (auto& v : slaver_)
|
|
|
|
|
delete v.second;
|
|
|
|
|
slaver_.clear();
|
|
|
|
|
|
|
|
|
|
for (auto& v : range_value_)
|
|
|
|
|
delete v.second;
|
|
|
|
|
range_value_.clear();
|
2023-09-13 08:07:13 +00:00
|
|
|
|
|
|
|
|
|
for (auto& v : init_value_)
|
|
|
|
|
delete v.second;
|
|
|
|
|
init_value_.clear();
|
2023-09-08 09:42:40 +00:00
|
|
|
|
}
|
2023-09-13 03:20:51 +00:00
|
|
|
|
gb_json* device_option::group_opt(const char* title)
|
|
|
|
|
{
|
|
|
|
|
gb_json* jsn = new gb_json();
|
|
|
|
|
|
|
|
|
|
jsn->set_value("title", title);
|
|
|
|
|
jsn->set_value("type", "group");
|
|
|
|
|
|
|
|
|
|
return jsn;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::arrange_raw_json(const char* txt)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> groups;
|
|
|
|
|
std::vector<gb_json*> ungroup;
|
|
|
|
|
std::map<std::string, std::vector<gb_json*>> ingroup;
|
|
|
|
|
gb_json* jsn = new gb_json(), *child = nullptr;
|
|
|
|
|
std::string text(txt), str("");
|
|
|
|
|
|
|
|
|
|
if (jsn->attach_text(&text[0]))
|
|
|
|
|
{
|
|
|
|
|
text.clear();
|
|
|
|
|
child = jsn->first_child();
|
|
|
|
|
while (child)
|
|
|
|
|
{
|
|
|
|
|
child->get_value("group", str);
|
|
|
|
|
if (str.empty())
|
|
|
|
|
ungroup.push_back(child);
|
|
|
|
|
else if (ingroup.count(str))
|
|
|
|
|
ingroup[str].push_back(child);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
std::vector<gb_json*> c;
|
|
|
|
|
c.push_back(child);
|
|
|
|
|
ingroup[str] = c;
|
|
|
|
|
}
|
|
|
|
|
child = jsn->next_child();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
jsn->release();
|
|
|
|
|
|
|
|
|
|
if (ungroup.size() || ingroup.size())
|
|
|
|
|
{
|
|
|
|
|
origin_ = new gb_json();
|
|
|
|
|
for (auto& v : ungroup)
|
|
|
|
|
{
|
|
|
|
|
origin_->set_value(v->key().c_str(), v);
|
|
|
|
|
v->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// named group ...
|
|
|
|
|
int grpind = 1;
|
|
|
|
|
|
|
|
|
|
for (auto& v : g_known_group_with_sn)
|
|
|
|
|
{
|
|
|
|
|
if (ingroup.count(v.name))
|
|
|
|
|
{
|
|
|
|
|
gb_json* grp = group_opt(v.title.c_str());
|
|
|
|
|
origin_->set_value(("grp-" + std::to_string(grpind++)).c_str(), grp);
|
|
|
|
|
grp->release();
|
|
|
|
|
|
|
|
|
|
for (auto& opt : ingroup[v.name])
|
|
|
|
|
{
|
|
|
|
|
origin_->set_value(opt->key().c_str(), opt);
|
|
|
|
|
opt->release();
|
|
|
|
|
}
|
|
|
|
|
ingroup.erase(v.name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (auto& v : ingroup)
|
|
|
|
|
{
|
|
|
|
|
gb_json* grp = group_opt(v.first.c_str());
|
|
|
|
|
origin_->set_value(("grp-" + std::to_string(grpind++)).c_str(), grp);
|
|
|
|
|
grp->release();
|
|
|
|
|
|
|
|
|
|
for (auto& opt : v.second)
|
|
|
|
|
{
|
|
|
|
|
origin_->set_value(opt->key().c_str(), opt);
|
|
|
|
|
opt->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return origin_ != nullptr;
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
void device_option::init_depends(gb_json* opt)
|
|
|
|
|
{
|
|
|
|
|
gb_json* range = nullptr;
|
|
|
|
|
std::string dpnd("");
|
|
|
|
|
|
|
|
|
|
if (opt->get_value("depend", dpnd) && !dpnd.empty())
|
|
|
|
|
{
|
|
|
|
|
simple_logic* logic = new simple_logic();
|
|
|
|
|
int pos = 0;
|
|
|
|
|
|
|
|
|
|
if (logic->parse(dpnd.c_str(), &pos, &device_option::init_condition, this))
|
|
|
|
|
slaver_[opt->key().c_str()] = logic;
|
|
|
|
|
else
|
|
|
|
|
delete logic;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// values ...
|
|
|
|
|
opt->get_value("range", range);
|
|
|
|
|
if (range)
|
|
|
|
|
{
|
|
|
|
|
range_value* val = new range_value();
|
|
|
|
|
|
|
|
|
|
opt->get_value("type", dpnd);
|
|
|
|
|
if (val->set_value(range, dpnd.c_str(), this))
|
2023-09-13 08:07:13 +00:00
|
|
|
|
range_value_[opt->key()] = val;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
else
|
|
|
|
|
delete val;
|
|
|
|
|
|
|
|
|
|
range->release();
|
|
|
|
|
}
|
2023-09-13 08:07:13 +00:00
|
|
|
|
|
|
|
|
|
// default:
|
|
|
|
|
range = nullptr;
|
|
|
|
|
opt->get_value("default", range);
|
|
|
|
|
opt->get_value("type", dpnd);
|
|
|
|
|
if (range)
|
|
|
|
|
{
|
2023-09-14 03:28:21 +00:00
|
|
|
|
condition_value* rv = new condition_value();
|
2023-09-13 08:07:13 +00:00
|
|
|
|
if (rv->set_value(range, dpnd.c_str(), this))
|
|
|
|
|
init_value_[opt->key()] = rv;
|
|
|
|
|
else
|
|
|
|
|
delete rv;
|
|
|
|
|
|
|
|
|
|
range->release();
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
}
|
|
|
|
|
gb_json* device_option::copy_opt(gb_json* from)
|
|
|
|
|
{
|
|
|
|
|
std::string text(from->to_string());
|
|
|
|
|
gb_json* to = new gb_json();
|
|
|
|
|
|
|
|
|
|
if (!to->attach_text(&text[0]))
|
|
|
|
|
{
|
|
|
|
|
to->release();
|
|
|
|
|
to = nullptr;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
std::string val("");
|
|
|
|
|
|
|
|
|
|
to->key() = from->key();
|
|
|
|
|
|
|
|
|
|
// 1: language changed ... (title, description, string-list)
|
|
|
|
|
if (to->get_value("title", val))
|
|
|
|
|
to->set_value("title", from_default_language(val.c_str()));
|
|
|
|
|
if (to->get_value("desc", val))
|
|
|
|
|
to->set_value("desc", from_default_language(val.c_str()));
|
|
|
|
|
|
|
|
|
|
// 2: enabled ...
|
|
|
|
|
if (slaver_.count(to->key()))
|
|
|
|
|
to->set_value("enabled", slaver_[to->key()]->value(&device_option::calc_simple_logic_expression, this));
|
|
|
|
|
|
2023-09-13 08:07:13 +00:00
|
|
|
|
// 3: default value ...
|
|
|
|
|
if (init_value_.count(to->key()))
|
|
|
|
|
{
|
2023-09-14 03:28:21 +00:00
|
|
|
|
std::string val(init_value_[to->key()]->value(&device_option::calc_simple_logic_expression, this));
|
|
|
|
|
std::string type("");
|
|
|
|
|
to->get_value("type", type);
|
|
|
|
|
|
|
|
|
|
if (type == JSON_SANE_TYPE_BOOL)
|
|
|
|
|
to->set_value("default", *(bool*)val.c_str());
|
|
|
|
|
else if(type == JSON_SANE_TYPE_INT)
|
|
|
|
|
to->set_value("default", *(int*)val.c_str());
|
|
|
|
|
else if(type == JSON_SANE_TYPE_FIXED)
|
|
|
|
|
to->set_value("default", *(double*)val.c_str());
|
|
|
|
|
else if(type == JSON_SANE_TYPE_STRING)
|
|
|
|
|
to->set_value("default", (const wchar_t*)val.c_str());
|
2023-09-13 08:07:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 4: range value ...
|
2023-09-08 09:42:40 +00:00
|
|
|
|
if (range_value_.count(to->key()))
|
|
|
|
|
{
|
|
|
|
|
gb_json* src = nullptr, * dst = nullptr;
|
|
|
|
|
from->get_value("range", src);
|
|
|
|
|
to->get_value("range", dst);
|
|
|
|
|
|
|
|
|
|
if (src && dst)
|
|
|
|
|
{
|
|
|
|
|
dst->clear(src->is_array());
|
2023-09-09 10:09:20 +00:00
|
|
|
|
dst->key() = src->key();
|
2023-09-08 09:42:40 +00:00
|
|
|
|
to->get_value("type", val);
|
|
|
|
|
if (val == JSON_SANE_TYPE_BOOL)
|
|
|
|
|
{
|
|
|
|
|
if (dst->is_array())
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
for (int i = 0; i < range_value_[to->key()]->count(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (!val.empty())
|
|
|
|
|
*dst += *(bool*)&val[0];
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("min", *(bool*)&val[0]);
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("max", *(bool*)&val[0]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (val == JSON_SANE_TYPE_INT)
|
|
|
|
|
{
|
|
|
|
|
if (dst->is_array())
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
for (int i = 0; i < range_value_[to->key()]->count(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (!val.empty())
|
|
|
|
|
*dst += *(int*)&val[0];
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("min", *(int*)&val[0]);
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("max", *(int*)&val[0]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (val == JSON_SANE_TYPE_FIXED)
|
|
|
|
|
{
|
|
|
|
|
if (dst->is_array())
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
for (int i = 0; i < range_value_[to->key()]->count(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (!val.empty())
|
|
|
|
|
*dst += *(double*)&val[0];
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("min", *(double*)&val[0]);
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("max", *(double*)&val[0]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (val == JSON_SANE_TYPE_STRING)
|
|
|
|
|
{
|
|
|
|
|
if (dst->is_array())
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
for(int i = 0; i < range_value_[to->key()]->count(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if(!val.empty())
|
|
|
|
|
*dst += from_default_language(val.c_str());
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
val = range_value_[to->key()]->first_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("min", from_default_language(val.c_str()));
|
|
|
|
|
val = range_value_[to->key()]->next_value(&device_option::calc_simple_logic_expression, this);
|
|
|
|
|
dst->set_value("max", from_default_language(val.c_str()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (src)
|
|
|
|
|
src->release();
|
|
|
|
|
if (dst)
|
|
|
|
|
dst->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return to;
|
|
|
|
|
}
|
2023-09-14 09:53:17 +00:00
|
|
|
|
bool device_option::to_now(bool init, bool* changed)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
|
|
|
|
if (!origin_)
|
|
|
|
|
return false;
|
|
|
|
|
|
2023-09-13 03:20:51 +00:00
|
|
|
|
gb_json* from = nullptr, * to = nullptr, * tmp = new gb_json();
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
|
|
|
|
from = origin_->first_child();
|
|
|
|
|
while (from)
|
|
|
|
|
{
|
|
|
|
|
std::string name(from->key());
|
|
|
|
|
|
|
|
|
|
if (init)
|
|
|
|
|
init_depends(from);
|
|
|
|
|
|
2023-09-21 03:23:38 +00:00
|
|
|
|
bool pub = true;
|
|
|
|
|
if (from->get_value("visible", pub) && !pub)
|
|
|
|
|
{
|
|
|
|
|
if (!user_ || !user_(USER_PRIVILEGE_DEVLOPER))
|
|
|
|
|
{
|
|
|
|
|
from->release();
|
|
|
|
|
from = origin_->next_child();
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-08 09:42:40 +00:00
|
|
|
|
to = copy_opt(from);
|
|
|
|
|
from->release();
|
|
|
|
|
if (to)
|
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
// copy cur value ...
|
2023-09-13 03:20:51 +00:00
|
|
|
|
if (now_)
|
2023-09-09 10:09:20 +00:00
|
|
|
|
{
|
|
|
|
|
gb_json* now = nullptr;
|
2023-09-13 03:20:51 +00:00
|
|
|
|
now_->get_value(to->key().c_str(), now);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
if (now)
|
|
|
|
|
{
|
|
|
|
|
std::string type("");
|
|
|
|
|
now->get_value("type", type);
|
|
|
|
|
if (type == JSON_SANE_TYPE_BOOL)
|
|
|
|
|
{
|
|
|
|
|
bool v = false;
|
|
|
|
|
now->get_value("cur", v);
|
2023-09-14 09:53:17 +00:00
|
|
|
|
refine_data_to_range<bool, bool>(to, &v, copy_simple_type<bool, bool>);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
to->set_value("cur", v);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_INT)
|
|
|
|
|
{
|
|
|
|
|
int v = 0;
|
|
|
|
|
now->get_value("cur", v);
|
2023-09-14 09:53:17 +00:00
|
|
|
|
refine_data_to_range<int, int>(to, &v, copy_simple_type<int, int>);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
to->set_value("cur", v);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_FIXED)
|
|
|
|
|
{
|
|
|
|
|
double v = .0f;
|
|
|
|
|
now->get_value("cur", v);
|
2023-09-14 09:53:17 +00:00
|
|
|
|
refine_data_to_range<double, double>(to, &v, copy_simple_type<double, double>);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
to->set_value("cur", v);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_STRING)
|
|
|
|
|
{
|
|
|
|
|
std::string v("");
|
2023-09-14 09:53:17 +00:00
|
|
|
|
int size = 0, s1 = 0;
|
|
|
|
|
char *vv = nullptr;
|
|
|
|
|
|
|
|
|
|
to->get_value("size", size);
|
|
|
|
|
now->get_value("size", s1);
|
|
|
|
|
if (size < s1)
|
|
|
|
|
size = s1;
|
|
|
|
|
vv = new char[size + 4];
|
|
|
|
|
memset(vv, 0, size + 4);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
now->get_value("cur", v);
|
2023-09-14 09:53:17 +00:00
|
|
|
|
strcpy(vv, v.c_str());
|
|
|
|
|
refine_string_data(to, vv);
|
|
|
|
|
to->set_value("cur", vv);
|
|
|
|
|
delete[] vv;
|
2023-09-09 10:09:20 +00:00
|
|
|
|
}
|
|
|
|
|
now->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-13 03:20:51 +00:00
|
|
|
|
|
|
|
|
|
tmp->set_value(name.c_str(), to);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
to->release();
|
|
|
|
|
|
|
|
|
|
from = origin_->next_child();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-09-13 03:20:51 +00:00
|
|
|
|
tmp->release();
|
|
|
|
|
tmp = nullptr;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-14 09:53:17 +00:00
|
|
|
|
if (changed)
|
|
|
|
|
{
|
|
|
|
|
if (!now_ || !tmp)
|
|
|
|
|
*changed = true;
|
|
|
|
|
else
|
|
|
|
|
*changed = *now_ != *tmp;
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-13 03:20:51 +00:00
|
|
|
|
if (now_)
|
|
|
|
|
now_->release();
|
|
|
|
|
now_ = tmp;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
|
|
|
|
return now_ != nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string device_option::option_value(gb_json* jsn, bool def_val)
|
|
|
|
|
{
|
|
|
|
|
std::string type(""), key(def_val ? "default" : "cur");
|
|
|
|
|
|
|
|
|
|
jsn->get_value("type", type);
|
|
|
|
|
if (type == "bool")
|
|
|
|
|
{
|
|
|
|
|
bool v = false;
|
|
|
|
|
jsn->get_value(key.c_str(), v);
|
|
|
|
|
type = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (type == "int")
|
|
|
|
|
{
|
|
|
|
|
int v = 0;
|
|
|
|
|
jsn->get_value(key.c_str(), v);
|
|
|
|
|
type = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (type == "float")
|
|
|
|
|
{
|
|
|
|
|
double v = .0f;
|
|
|
|
|
jsn->get_value(key.c_str(), v);
|
|
|
|
|
type = std::string((char*)&v, sizeof(v));
|
|
|
|
|
}
|
|
|
|
|
else if (type == "string")
|
|
|
|
|
{
|
|
|
|
|
if (!jsn->get_value(key.c_str(), type))
|
|
|
|
|
type = "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(type);
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-13 03:20:51 +00:00
|
|
|
|
std::string device_option::trans_group(const char* utf8, bool to_title)
|
|
|
|
|
{
|
|
|
|
|
if (to_title)
|
|
|
|
|
{
|
|
|
|
|
for (auto& v : g_known_group_with_sn)
|
|
|
|
|
{
|
|
|
|
|
if (v.name == utf8)
|
|
|
|
|
return v.title;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (auto& v : g_known_group_with_sn)
|
|
|
|
|
{
|
|
|
|
|
if (v.title == utf8)
|
|
|
|
|
return v.name;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return utf8;
|
|
|
|
|
}
|
|
|
|
|
std::string device_option::get_group(int ind, bool title)
|
|
|
|
|
{
|
|
|
|
|
if (ind >= 0 && ind < _countof(g_known_group_with_sn))
|
|
|
|
|
return title ? g_known_group_with_sn[ind].title : g_known_group_with_sn[ind].name;
|
|
|
|
|
else
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-08 09:42:40 +00:00
|
|
|
|
bool device_option::init(const char* opt_json)
|
|
|
|
|
{
|
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
|
|
clear();
|
2023-09-13 03:20:51 +00:00
|
|
|
|
if (arrange_raw_json(opt_json))
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-14 09:53:17 +00:00
|
|
|
|
ret = to_now(true, nullptr);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
if (!ret)
|
|
|
|
|
clear();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bool device_option::refine_data(const char* name, void* value)
|
|
|
|
|
{
|
|
|
|
|
bool refined = false;
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
|
|
|
|
now_->get_value(name, child);
|
|
|
|
|
if (child)
|
|
|
|
|
{
|
|
|
|
|
std::string type("");
|
|
|
|
|
child->get_value("type", type);
|
|
|
|
|
if (type == JSON_SANE_TYPE_BOOL)
|
|
|
|
|
{
|
|
|
|
|
refined = refine_data_to_range<bool, bool>(child, value, copy_simple_type<bool, bool>);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_INT)
|
|
|
|
|
{
|
|
|
|
|
refined = refine_data_to_range<int, int>(child, value, copy_simple_type<int, int>);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_FIXED)
|
|
|
|
|
{
|
|
|
|
|
refined = refine_data_to_range<double, double>(child, value, copy_simple_type<double, double>);
|
|
|
|
|
}
|
|
|
|
|
else if (type == JSON_SANE_TYPE_STRING)
|
|
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
|
refined = refine_string_data(child, value);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return refined;
|
|
|
|
|
}
|
|
|
|
|
int device_option::update_data(const char* name, void* value)
|
|
|
|
|
{
|
|
|
|
|
if (!name)
|
|
|
|
|
{
|
2023-09-14 09:53:17 +00:00
|
|
|
|
to_now(false, nullptr);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
|
|
|
|
return SCANNER_ERR_RELOAD_OPT_PARAM;
|
|
|
|
|
}
|
|
|
|
|
else if(now_)
|
|
|
|
|
{
|
|
|
|
|
std::string type("");
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
now_->get_value(name, child);
|
|
|
|
|
if (child)
|
|
|
|
|
{
|
2023-09-15 09:53:13 +00:00
|
|
|
|
std::string pre(device_option::option_value(child, false));
|
|
|
|
|
bool changed = false;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
child->get_value("type", type);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
if (type == JSON_SANE_TYPE_BOOL)
|
2023-09-15 09:53:13 +00:00
|
|
|
|
{
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->set_value("cur", *(bool*)value);
|
2023-09-15 09:53:13 +00:00
|
|
|
|
changed = *(bool*)value != *(bool*)pre.c_str();
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
else if (type == JSON_SANE_TYPE_INT)
|
2023-09-15 09:53:13 +00:00
|
|
|
|
{
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->set_value("cur", *(int*)value);
|
2023-09-15 09:53:13 +00:00
|
|
|
|
changed = *(int*)value != *(int*)pre.c_str();
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
else if (type == JSON_SANE_TYPE_FIXED)
|
2023-09-15 09:53:13 +00:00
|
|
|
|
{
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->set_value("cur", *(double*)value);
|
2023-09-15 09:53:13 +00:00
|
|
|
|
changed = IS_DOUBLE_EQUAL(*(double*)value, *(double*)pre.c_str());
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
else if (type == JSON_SANE_TYPE_STRING)
|
2023-09-15 09:53:13 +00:00
|
|
|
|
{
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->set_value("cur", (char*)value);
|
2023-09-15 09:53:13 +00:00
|
|
|
|
changed = pre != (char*)value;
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->release();
|
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
if (changed && // value has changed
|
|
|
|
|
std::find(master_opts_.begin(), master_opts_.end(), name) != master_opts_.end()) // can affect others
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
2023-09-15 09:53:13 +00:00
|
|
|
|
changed = false;
|
2023-09-14 09:53:17 +00:00
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
changed = false;
|
|
|
|
|
to_now(false, &changed);
|
|
|
|
|
} while (changed);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
|
|
|
|
return SCANNER_ERR_RELOAD_OPT_PARAM;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return SCANNER_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
int device_option::count(void)
|
|
|
|
|
{
|
|
|
|
|
gb_json* jsn = now_ ? now_ : origin_;
|
|
|
|
|
|
|
|
|
|
if (jsn)
|
|
|
|
|
return jsn->children();
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
std::string device_option::get_name_by_sane_id(int sane_ind)
|
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
|
|
|
|
gb_json* jsn = now_ ? now_ : origin_;
|
|
|
|
|
|
|
|
|
|
if (sane_ind > 0 && sane_ind - 1 < jsn->children())
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = now_->child(sane_ind - 1);
|
|
|
|
|
child->get_value("name", value);
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|
2023-09-08 09:42:40 +00:00
|
|
|
|
std::string device_option::get_option_value_type(const char* name)
|
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
2023-09-15 09:53:13 +00:00
|
|
|
|
gb_json* jsn = now_ ? now_ : origin_;
|
2023-09-08 09:42:40 +00:00
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
if (jsn)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
jsn->get_value(name, child);
|
2023-09-08 09:42:40 +00:00
|
|
|
|
if (child)
|
|
|
|
|
{
|
|
|
|
|
child->get_value("type", value);
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|
2023-09-15 09:53:13 +00:00
|
|
|
|
std::string device_option::get_option_value(const char* name, int type, int* size)
|
2023-09-08 09:42:40 +00:00
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
|
|
|
|
|
|
|
|
|
if (now_)
|
|
|
|
|
{
|
|
|
|
|
if (!name)
|
|
|
|
|
{
|
|
|
|
|
value = now_->to_string();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
|
|
|
|
now_->get_value(name, child);
|
|
|
|
|
if (child)
|
|
|
|
|
{
|
|
|
|
|
if (type == OPT_VAL_JSON)
|
|
|
|
|
value = child->to_string();
|
|
|
|
|
else
|
|
|
|
|
value = device_option::option_value(child, type == OPT_VAL_DEFAULT);
|
|
|
|
|
|
2023-09-15 09:53:13 +00:00
|
|
|
|
if (size)
|
|
|
|
|
{
|
|
|
|
|
int n = 0;
|
|
|
|
|
child->get_value("size", n);
|
|
|
|
|
*size = n;
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-08 09:42:40 +00:00
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|
2023-09-15 09:53:13 +00:00
|
|
|
|
std::string device_option::get_option_field_string(const char* name, const char* key)
|
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
|
|
|
|
gb_json* jsn = now_ ? now_ : origin_;
|
|
|
|
|
|
|
|
|
|
if (jsn)
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = nullptr;
|
|
|
|
|
|
|
|
|
|
jsn->get_value(name, child);
|
|
|
|
|
if (child)
|
|
|
|
|
{
|
|
|
|
|
child->get_value(key, value);
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|
|
|
|
|
std::string device_option::get_option_value_type(int sane_ind)
|
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
|
|
|
|
gb_json* jsn = now_ ? now_ : origin_;
|
|
|
|
|
|
|
|
|
|
if (sane_ind > 0 && sane_ind - 1 < jsn->children())
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = now_->child(sane_ind - 1);
|
|
|
|
|
child->get_value("type", value);
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|
|
|
|
|
std::string device_option::get_option_value(int sane_ind, int type, int* size)
|
|
|
|
|
{
|
|
|
|
|
std::string value("");
|
|
|
|
|
|
|
|
|
|
if (now_)
|
|
|
|
|
{
|
|
|
|
|
if (sane_ind <= 0)
|
|
|
|
|
{
|
|
|
|
|
value = now_->to_string();
|
|
|
|
|
}
|
|
|
|
|
else if(sane_ind - 1 < now_->children())
|
|
|
|
|
{
|
|
|
|
|
gb_json* child = now_->child(sane_ind - 1);
|
|
|
|
|
|
|
|
|
|
if (type == OPT_VAL_JSON)
|
|
|
|
|
value = child->to_string();
|
|
|
|
|
else
|
|
|
|
|
value = device_option::option_value(child, type == OPT_VAL_DEFAULT);
|
|
|
|
|
|
|
|
|
|
if (size)
|
|
|
|
|
{
|
|
|
|
|
int n = 0;
|
|
|
|
|
child->get_value("size", n);
|
|
|
|
|
*size = n;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
child->release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::move(value);
|
|
|
|
|
}
|