1573 lines
33 KiB
C++
1573 lines
33 KiB
C++
#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>
|
||
#include <string.h>
|
||
#include <algorithm>
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// image-processing jsons ...
|
||
|
||
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))
|
||
{
|
||
if (v < vl)
|
||
{
|
||
strcpy((char*)value, vl.c_str());
|
||
refined = true;
|
||
}
|
||
else if (range->get_value("max", vu))
|
||
{
|
||
if (v > vu)
|
||
{
|
||
strcpy((char*)value, vu.c_str());
|
||
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 (v == vl)
|
||
{
|
||
found = true;
|
||
val->release();
|
||
break;
|
||
}
|
||
}
|
||
val->release();
|
||
val = range->next_child();
|
||
}
|
||
if (!found)
|
||
{
|
||
if (jsn->get_value("default", vl))
|
||
{
|
||
refined = true;
|
||
strcpy((char*)value, vl.c_str());
|
||
}
|
||
}
|
||
}
|
||
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 "";
|
||
}
|
||
|
||
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
|
||
};
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// 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)
|
||
{
|
||
// consistant value, and type is name ...
|
||
CONDVAL cv;
|
||
|
||
cv.logic = nullptr;
|
||
cv.value = type;
|
||
vals_.push_back(cv);
|
||
parent_ = parent;
|
||
|
||
return true;
|
||
}
|
||
|
||
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;
|
||
}
|
||
std::string device_option::condition_value::value(bool(*compare)(const char*, void*), void* param)
|
||
{
|
||
if (parent_)
|
||
return parent_->get_option_value(vals_[0].value.c_str(), OPT_VAL_CURRENT);
|
||
|
||
for (auto& v : vals_)
|
||
{
|
||
if (!v.logic)
|
||
return v.value;
|
||
else if (v.logic->value(compare, param))
|
||
return v.value;
|
||
}
|
||
|
||
return "";
|
||
}
|
||
bool device_option::range_value::set_value(gb_json* jsn, const char* type, device_option* parent) // jsn contains all range object
|
||
{
|
||
bool ret = true;
|
||
|
||
parent->depend_opts_[jsn->key()];
|
||
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;
|
||
}
|
||
|
||
|
||
device_option::device_option(std::function<bool(int)> user_priv) : origin_(nullptr), now_(nullptr)
|
||
, user_(user_priv)
|
||
{}
|
||
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);
|
||
if (tag)
|
||
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;
|
||
|
||
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);
|
||
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];
|
||
ret = obj->compare_[expr].compare(child, val, &obj->compare_[expr].val1[0], &obj->compare_[expr].val2[0]) ^ obj->compare_[expr].not_op;
|
||
|
||
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();
|
||
|
||
for (auto& v : init_value_)
|
||
delete v.second;
|
||
init_value_.clear();
|
||
|
||
for (auto& v : support_value_)
|
||
delete v.second;
|
||
support_value_.clear();
|
||
|
||
depend_opts_.clear();
|
||
}
|
||
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;
|
||
}
|
||
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))
|
||
range_value_[opt->key()] = val;
|
||
else
|
||
delete val;
|
||
|
||
range->release();
|
||
}
|
||
|
||
// default:
|
||
range = nullptr;
|
||
opt->get_value("default", range);
|
||
opt->get_value("type", dpnd);
|
||
if (range)
|
||
{
|
||
condition_value* rv = new condition_value();
|
||
if (rv->set_value(range, dpnd.c_str(), this))
|
||
init_value_[opt->key()] = rv;
|
||
else
|
||
delete rv;
|
||
|
||
range->release();
|
||
}
|
||
|
||
// visible
|
||
range = nullptr;
|
||
opt->get_value("visible", range);
|
||
if(range)
|
||
{
|
||
condition_value* v = new condition_value();
|
||
if (v->set_value(range, JSON_SANE_TYPE_INT, this))
|
||
support_value_[opt->key()] = v;
|
||
else
|
||
delete v;
|
||
}
|
||
}
|
||
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));
|
||
|
||
// 3: default value ...
|
||
if (init_value_.count(to->key()))
|
||
{
|
||
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());
|
||
}
|
||
|
||
// 4: range value ...
|
||
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());
|
||
dst->key() = src->key();
|
||
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;
|
||
}
|
||
int device_option::visibility(gb_json* jsn)
|
||
{
|
||
int visb = OPT_VISIBLE_ALL;
|
||
|
||
if (!jsn->get_value("visible", visb))
|
||
{
|
||
if (support_value_.count(jsn->key()))
|
||
{
|
||
std::string val(support_value_[jsn->key()]->value(&device_option::calc_simple_logic_expression, this));
|
||
visb = *(int*)&val[0];
|
||
}
|
||
}
|
||
|
||
return visb;
|
||
}
|
||
bool device_option::to_now(bool init, bool* changed)
|
||
{
|
||
if (!origin_)
|
||
return false;
|
||
|
||
gb_json* from = nullptr, * to = nullptr, * tmp = new gb_json();
|
||
|
||
from = origin_->first_child();
|
||
while (from)
|
||
{
|
||
std::string name(from->key());
|
||
|
||
if (init)
|
||
init_depends(from);
|
||
|
||
int pub = visibility(from);
|
||
if (pub == OPT_VISIBLE_HIDE || pub == OPT_VISIBLE_NOT_SUPPORT)
|
||
{
|
||
if (pub == OPT_VISIBLE_NOT_SUPPORT || !user_ || !user_(USER_PRIVILEGE_DEVLOPER))
|
||
{
|
||
from->release();
|
||
from = origin_->next_child();
|
||
continue;
|
||
}
|
||
}
|
||
|
||
to = copy_opt(from);
|
||
from->release();
|
||
if (to)
|
||
{
|
||
// copy cur value ...
|
||
if (now_)
|
||
{
|
||
gb_json* now = nullptr;
|
||
now_->get_value(to->key().c_str(), now);
|
||
if (now)
|
||
{
|
||
std::string type("");
|
||
now->get_value("type", type);
|
||
if (type == JSON_SANE_TYPE_BOOL)
|
||
{
|
||
bool v = false;
|
||
now->get_value("cur", v);
|
||
refine_data_to_range<bool>(to, &v);
|
||
to->set_value("cur", v);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_INT)
|
||
{
|
||
int v = 0;
|
||
now->get_value("cur", v);
|
||
refine_data_to_range<int>(to, &v);
|
||
to->set_value("cur", v);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_FIXED)
|
||
{
|
||
double v = .0f;
|
||
now->get_value("cur", v);
|
||
refine_data_to_range<double>(to, &v);
|
||
to->set_value("cur", v);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_STRING)
|
||
{
|
||
std::string v("");
|
||
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);
|
||
now->get_value("cur", v);
|
||
strcpy(vv, v.c_str());
|
||
refine_string_data(to, vv);
|
||
to->set_value("cur", vv);
|
||
delete[] vv;
|
||
}
|
||
now->release();
|
||
}
|
||
}
|
||
|
||
|
||
tmp->set_value(name.c_str(), to);
|
||
to->release();
|
||
|
||
from = origin_->next_child();
|
||
}
|
||
else
|
||
{
|
||
tmp->release();
|
||
tmp = nullptr;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (changed)
|
||
{
|
||
if (!now_ || !tmp)
|
||
*changed = true;
|
||
else
|
||
*changed = *now_ != *tmp;
|
||
}
|
||
|
||
if (now_)
|
||
now_->release();
|
||
now_ = tmp;
|
||
|
||
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);
|
||
}
|
||
|
||
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 "";
|
||
}
|
||
|
||
bool device_option::init(const char* opt_json)
|
||
{
|
||
bool ret = false;
|
||
|
||
clear();
|
||
if (arrange_raw_json(opt_json))
|
||
{
|
||
ret = to_now(true, nullptr);
|
||
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>(child, value);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_INT)
|
||
{
|
||
refined = refine_data_to_range<int>(child, value);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_FIXED)
|
||
{
|
||
refined = refine_data_to_range<double>(child, value);
|
||
}
|
||
else if (type == JSON_SANE_TYPE_STRING)
|
||
{
|
||
refined = refine_string_data(child, value);
|
||
}
|
||
|
||
child->release();
|
||
}
|
||
|
||
return refined;
|
||
}
|
||
int device_option::update_data(const char* name, void* value)
|
||
{
|
||
if (!name)
|
||
{
|
||
to_now(false, nullptr);
|
||
|
||
return SCANNER_ERR_RELOAD_OPT_PARAM;
|
||
}
|
||
else if(now_)
|
||
{
|
||
std::string type("");
|
||
gb_json* child = nullptr;
|
||
|
||
|
||
now_->get_value(name, child);
|
||
if (child)
|
||
{
|
||
std::string pre(device_option::option_value(child, false));
|
||
bool changed = false;
|
||
|
||
child->get_value("type", type);
|
||
if (type == JSON_SANE_TYPE_BOOL)
|
||
{
|
||
child->set_value("cur", *(bool*)value);
|
||
changed = *(bool*)value != *(bool*)pre.c_str();
|
||
}
|
||
else if (type == JSON_SANE_TYPE_INT)
|
||
{
|
||
child->set_value("cur", *(int*)value);
|
||
changed = *(int*)value != *(int*)pre.c_str();
|
||
}
|
||
else if (type == JSON_SANE_TYPE_FIXED)
|
||
{
|
||
child->set_value("cur", *(double*)value);
|
||
changed = !IS_DOUBLE_EQUAL(*(double*)value, *(double*)pre.c_str());
|
||
}
|
||
else if (type == JSON_SANE_TYPE_STRING)
|
||
{
|
||
child->set_value("cur", (char*)value);
|
||
changed = pre != (char*)value;
|
||
}
|
||
child->release();
|
||
|
||
if (changed && // value has changed
|
||
std::find(master_opts_.begin(), master_opts_.end(), name) != master_opts_.end()) // can affect others
|
||
{
|
||
changed = false;
|
||
|
||
do
|
||
{
|
||
changed = false;
|
||
to_now(false, &changed);
|
||
} while (changed);
|
||
|
||
return SCANNER_ERR_RELOAD_OPT_PARAM;
|
||
}
|
||
}
|
||
}
|
||
|
||
return SCANNER_ERR_OK;
|
||
}
|
||
|
||
int device_option::count(void)
|
||
{
|
||
gb_json* jsn = now_ ? now_ : origin_;
|
||
|
||
if (jsn)
|
||
return jsn->children();
|
||
else
|
||
return 0;
|
||
}
|
||
bool device_option::is_auto_restore_default(const char* name)
|
||
{
|
||
gb_json* jsn = now_ ? now_ : origin_,
|
||
* child = nullptr;
|
||
bool support = true;
|
||
|
||
jsn->get_value(name, child);
|
||
if (child)
|
||
{
|
||
if (!child->get_value("auto", support))
|
||
support = true;
|
||
|
||
child->release();
|
||
}
|
||
|
||
return support;
|
||
}
|
||
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);
|
||
value = child->key();
|
||
child->release();
|
||
}
|
||
|
||
return std::move(value);
|
||
}
|
||
std::string device_option::get_option_value_type(const char* name)
|
||
{
|
||
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("type", value);
|
||
child->release();
|
||
}
|
||
}
|
||
|
||
return std::move(value);
|
||
}
|
||
std::string device_option::get_option_value(const char* name, int type, int* size)
|
||
{
|
||
std::string value("");
|
||
gb_json* jsn = now_ ? now_ : origin_;
|
||
|
||
if (jsn)
|
||
{
|
||
if (!name)
|
||
{
|
||
value = jsn->to_string();
|
||
}
|
||
else
|
||
{
|
||
gb_json* child = nullptr;
|
||
|
||
jsn->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);
|
||
|
||
if (size)
|
||
{
|
||
int n = 0;
|
||
child->get_value("size", n);
|
||
*size = n;
|
||
}
|
||
|
||
child->release();
|
||
}
|
||
}
|
||
}
|
||
|
||
return std::move(value);
|
||
}
|
||
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);
|
||
}
|