Refactory jsonobject to load in memory.

src/json/jsonobject.cpp

@@ -13,14 +13,93 @@ const char* strProductFileNameDefault = "./cfgs/usct-product";
 JsonObject::JsonObject()
 {
 	loadcfg();
-
+    init();
 }
+
 JsonObject::~JsonObject()
 {
 	savecfg();
-
-
 }
+
+void JsonObject::init()
+{
+    char* defaultUser = getJsonString("login", "defaultUser");
+    mDefaultUser = defaultUser;
+
+    cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "protocol");
+    cJSON* second = cJSON_GetObjectItem(first, "lists");
+    if(nullptr != first && nullptr!= second)
+    {
+        std::string protocals = second->valuestring;
+        mProtocalList = QString::fromLocal8Bit(QByteArray::fromRawData(protocals.c_str(), protocals.size())).split(";");
+    }
+
+    mDefaultProtocal = getJsonString("protocol", "default");
+
+    first = cJSON_GetObjectItem((cJSON*)json_root, "general");
+    second = cJSON_GetObjectItem(first, "lockScreenTimes");
+    if(nullptr != first && nullptr!= second)
+    {
+         std::string times = second->valuestring;
+         mLockScreenTimeList = QString::fromLocal8Bit(QByteArray::fromRawData(times.c_str(), times.size())).split(";");
+    }
+
+    first = cJSON_GetObjectItem((cJSON*)json_root, "general");
+    second = cJSON_GetObjectItem(first, "language");
+    if(nullptr != first && nullptr!= second)
+    {
+         std::string lagunage = second->valuestring;
+         mLanguageList = QString::fromLocal8Bit(QByteArray::fromRawData(lagunage.c_str(), lagunage.size())).split(";");
+    }
+
+    mDefaultLanguage = getJsonString("general", "defaultlanguage");
+    mInstitutionName = getJsonString("general", "institutionName");
+    mInstitutionAddr = getJsonString("general", "institutionAddr");
+    mLockScreenTime = QString(getJsonString("general", "lockscreen")).toInt();
+    mStorageAlarmSize = getJsonString("storagepolicy", "mininum");
+    mInterfaceName = QString(getJsonString("address", "device"));
+    mDhcp = QVariant(QString(getJsonString("address", "dhcp"))).toBool();
+    mGateway = QString(getJsonString("routing", "defaultgateway"));
+    mScanConfirm = getBool("general","ScanConfirm");
+    mCompleteNotify = getBool("general","CompleteNotify");
+    mAnonymousMode = getBool("general","AnonymousMode");
+    mScreenSaverMode = getBool("screensaver","open");
+    mScreenSaverInfoList = QString(getJsonString("screensaver", "content")).split(";");
+    mDmsSimulator = getBool("dms","simulator");
+    mOperationLogExpireDays = QString(getJsonString("operatorlog", "expire")).toInt();
+    mPatientListExpireDays = QString(getJsonString("patientlist", "expire")).toInt();
+
+    mWorklistHost.ae = QString(getJsonString("worklist", "ae"));
+    mWorklistHost.ip = QString(getJsonString("worklist", "ip"));
+    mWorklistHost.name = QString(getJsonString("worklist", "name"));
+    mWorklistHost.port = QString(getJsonString("worklist", "port"));
+
+    mPacsHost.ae = QString(getJsonString("pacs", "ae"));
+    mPacsHost.ip = QString(getJsonString("pacs", "ip"));
+    mPacsHost.name = QString(getJsonString("pacs", "name"));
+    mPacsHost.port = QString(getJsonString("pacs", "port"));
+
+    mLocalHost.ae = QString(getJsonString("address", "ae"));
+    mLocalHost.ip = QString(getJsonString("address", "ip"));
+    mLocalHost.name = QString(getJsonString("address", "name"));
+    mLocalHost.port = QString(getJsonString("address", "port"));
+
+    mReconHost.ae = QString(getJsonString("recon", "ae"));
+    mReconHost.ip = QString(getJsonString("recon", "ip"));
+    mReconHost.name = QString(getJsonString("recon", "name"));
+    mReconHost.port = QString(getJsonString("recon", "port"));
+
+    mMppsHost.ae = QString(getJsonString("mpps", "ae"));
+    mMppsHost.ip = QString(getJsonString("mpps", "ip"));
+    mMppsHost.name = QString(getJsonString("mpps", "name"));
+    mMppsHost.port = QString(getJsonString("mpps", "port"));
+
+    mDefaultIpAddress.ip = QString(getJsonString("address", "ip"));
+    mDefaultIpAddress.mask = QString(getJsonString("address", "mask"));
+    mDefaultIpAddress.gateway = QString(getJsonString("address", "gateway"));
+    mDefaultIpAddress.dhcp = getBool("address","dhcp");
+}
+
 void JsonObject::setJsonString(const char* catergory, const char* stringName, const char* stringValue, bool save)
 {
 	if (!loadcfg())
@@ -145,65 +224,32 @@ int JsonObject::getArraySize(const char* catergory, const char* stringName)
 void JsonObject::setDefaultUser(const QString& str)
 {
 	setJsonString("login", "defaultUser", str.toStdString().c_str());
+    mDefaultUser = str;
 }
 QString JsonObject::defaultUser()
 {
-	char* str = getJsonString("login", "defaultUser");
+    return mDefaultUser;
-	return QString(str);
+
 }
 QStringList JsonObject::protocals()
 {
-	if (!loadcfg())
+    return mProtocalList;
-		return QStringList();
-
-	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "protocol");
-	if (!first) return QStringList();
-
-	cJSON* second = cJSON_GetObjectItem(first, "lists");
-	std::string lans = second->valuestring;
-
-
-	QString str = QString::fromLocal8Bit(QByteArray::fromRawData(lans.c_str(), lans.size()));
-	return str.split(";");
-
 }
 
 QString JsonObject::defaultProtocal()
 {
-	char* str = getJsonString("protocol", "default");
+    return mDefaultProtocal;
-	return QString(str);
 }
 
 void JsonObject::setDefaultProtocal(const QString& str)
 {
 	setJsonString("protocol", "default", str.toStdString().c_str());
+    mDefaultProtocal = str;
 }
 
 QStringList JsonObject::lockScreenTimes()
 {
-    if (!loadcfg())
+    return mLockScreenTimeList;
-        return QStringList();
-
-    cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "general");
-    if (!first) return QStringList();
-
-    cJSON* second = cJSON_GetObjectItem(first, "lockScreenTimes");
-    if (!second) return QStringList();
-
-    std::string times = second->valuestring;
-    QString str = QString::fromLocal8Bit(QByteArray::fromRawData(times.c_str(), times.size()));
-    return str.split(";");
-}
-
-QString JsonObject::defaultLockScreenTime()
-{
-    char* str = getJsonString("general", "defaultLockScreenTime");
-    return QString(str);
-}
-
-void JsonObject::setDefaultLockScreenTime(const QString& str)
-{
-    setJsonString("general", "defaultLockScreenTime", str.toStdString().c_str());
 }
 
 QString JsonObject::defaultFilter()
@@ -211,10 +257,12 @@ QString JsonObject::defaultFilter()
 	char* str = getJsonString("worklistfilter", "default");
 	return QString(str);
 }
+
 void JsonObject::setDefaultFilter(const QString& str)
 {
 	setJsonString("worklistfilter", "default", str.toStdString().c_str());
 }
+
 QStringList JsonObject::worklistFilters()
 {
 	if (!loadcfg())
@@ -232,79 +280,57 @@ QStringList JsonObject::worklistFilters()
 
 }
 
-
+QStringList JsonObject::languageList()
-
-QStringList JsonObject::language()
 {
-	if (!loadcfg())
+    return mLanguageList;
-		return QStringList();
-
-	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "general");
-	if (!first) return QStringList();
-
-	cJSON* second = cJSON_GetObjectItem(first, "language");
-	if (!second) return QStringList();
-
-	std::string lans = second->valuestring;
-	QString str = QString::fromLocal8Bit(QByteArray::fromRawData(lans.c_str(), lans.size()));
-	return str.split(";");
-
 }
 
 void JsonObject::setDefaultLanguage(const QString& str)
 {
 	setJsonString("general", "defaultlanguage", str.toStdString().c_str());
+    mDefaultLanguage = str;
 }
 
 QString JsonObject::defaultLanguage()
 {
-	char* str = getJsonString("general", "defaultlanguage");
+    return mDefaultLanguage;
-	return QString(str);
 }
 
 QString JsonObject::institutionName()
 {
-	char* str = getJsonString("general", "institutionName");
+    return mInstitutionName;
-	return QString(str);
 }
 void JsonObject::setInstitutionName(const QString& str)
 {
 	setJsonString("general", "institutionName", str.toStdString().c_str());
+    mInstitutionName = str;
 }
 
 QString JsonObject::institutionAddr()
 {
-	char* str = getJsonString("general", "institutionAddr");
+    return mInstitutionAddr;
-	return QString(str);
 }
 
 void JsonObject::setInstitutionAddr(const QString& str)
 {
 	setJsonString("general", "institutionAddr", str.toStdString().c_str());
+    mInstitutionAddr = str;
 }
 
-int JsonObject::lockerCount()
+int JsonObject::getLockScreenTime()
 {
-	char* str = getJsonString("general", "lockscreen");
+    return mLockScreenTime;
-	int interval = QString(str).toInt() * 1000;
-	return interval;
 }
 
-QString JsonObject::lockScreenTimeout()
+void JsonObject::setLockScreenTime(int aTime)
 {
-	char* str = getJsonString("general", "lockscreen");
+     setJsonString("general", "lockscreen", QString::number(aTime).toStdString().c_str());
-	return QString(str);
+     mLockScreenTime = aTime;
-}
-
-void JsonObject::setLockScreenTimeout(const QString& str)
-{
-	setJsonString("general", "lockscreen", str.toStdString().c_str());
 }
 
 QString JsonObject::storageAlarmSize()
 {
-	char* str = getJsonString("storagepolicy", "mininum");
+    return mStorageAlarmSize;
-	return QString(str);
 }
 
 bool JsonObject::loadcfg()
@@ -380,28 +406,16 @@ host JsonObject::getServer(ServerType type)
 	{
 
 	case JsonObject::WORKLIST:
-		typeName = "worklist";
+        return mWorklistHost;
-		break;
 	case JsonObject::PACS:
-		typeName = "pacs";
+        return mPacsHost;
-		break;
 	case JsonObject::LOCAL:
-		typeName = "address";
+        return mLocalHost;
-		break;
 	case JsonObject::RECON:
-		typeName = "recon";
+        return mReconHost;
-		break;
     case JsonObject::MPPS:
-        typeName = "mpps";
+        return mMppsHost;
-	default:
-		break;
 	}
-	host list;
-	list.ae = QString(getJsonString(typeName.toStdString().c_str(), "ae"));
-	list.ip = QString(getJsonString(typeName.toStdString().c_str(), "ip"));
-	list.name = QString(getJsonString(typeName.toStdString().c_str(), "name"));
-	list.port = QString(getJsonString(typeName.toStdString().c_str(), "port"));
-	return list;
 }
 
 void JsonObject::setServer(ServerType type, const host& list)
@@ -412,20 +426,23 @@ void JsonObject::setServer(ServerType type, const host& list)
 
 	case JsonObject::WORKLIST:
         typeName = "worklist";
+        mWorklistHost = list;
         break;
 	case JsonObject::PACS:
 		typeName = "pacs";
+        mPacsHost = list;
 		break;
 	case JsonObject::LOCAL:
 		typeName = "address";
+        mLocalHost = list;
 		break;
 	case JsonObject::RECON:
 		typeName = "recon";
+        mReconHost = list;
 		break;
     case JsonObject::MPPS:
         typeName = "mpps";
-        break;
+        mMppsHost = list;
-	default:
         break;
 	}
 	setJsonString(typeName.toStdString().c_str(), "ae", list.ae.toStdString().c_str(), false);
@@ -439,7 +456,7 @@ void JsonObject::setServer(ServerType type, const host& list)
 
 QString JsonObject::interfaceName()
 {
-	return QString(getJsonString("address", "device"));
+    return mInterfaceName;
 }
 
 QString JsonObject::passWord()
@@ -449,35 +466,29 @@ QString JsonObject::passWord()
 
 void JsonObject::setPassword(const QString& pwd)
 {
-
 	tmp_psw = pwd;
 }
 void JsonObject::setInterfaceName(const QString& name)
 {
 	setJsonString("address", "device", name.toStdString().c_str());
+    mInterfaceName = name;
 }
 
 bool JsonObject::isDHCP()
 {
-	QVariant tempValue = QString(getJsonString("address", "dhcp"));
+    return mDhcp;
-	return tempValue.toBool();
 }
 
 void JsonObject::autoDHCP(bool ena)
 {
 	QString str = QVariant(ena).toString();
 	setJsonString("address", "dhcp", str.toStdString().c_str());
+    mDhcp = ena;
 }
 
 IpAddr JsonObject::getDefaultIpAddr()
 {
-	IpAddr obj;
+    return mDefaultIpAddress;
-	//lhost.ip = IPConfig::getDeviceIP();
-	obj.ip = QString(getJsonString("address", "ip"));
-	obj.mask = QString(getJsonString("address", "mask"));
-    obj.gateway = QString(getJsonString("address", "gateway"));
-    obj.dhcp = getBool("address","dhcp");
-	return obj;
 }
 
 void JsonObject::setDefaultIpAddr(const IpAddr& addr)
@@ -486,6 +497,7 @@ void JsonObject::setDefaultIpAddr(const IpAddr& addr)
 	setJsonString("address", "mask", addr.mask.toStdString().c_str());
     setJsonString("address", "gateway", addr.ip.toStdString().c_str());
     setBool("address","dhcp", addr.dhcp, true);
+    mDefaultIpAddress = addr;
 }
 
 QList<QStringList> JsonObject::getIpAddrList()
@@ -516,12 +528,13 @@ void JsonObject::setIpAddrList(const QList<QStringList>& list)
 
 QString JsonObject::getDefaultGateway()
 {
-	return QString(getJsonString("routing", "defaultgateway"));
+    return mGateway;
 }
 
 void JsonObject::setDefaultGateway(const QString& gw)
 {
 	setJsonString("routing", "defaultgateway", gw.toStdString().c_str());
+    mGateway = gw;
 }
 
 QList<QStringList> JsonObject::getIpRouteList()
@@ -560,58 +573,61 @@ const char *JsonObject::getEmptyScanID() {
 }
 
 bool JsonObject::getScanConfirm() {
-    return getBool("general","ScanConfirm");
+    return mScanConfirm;
 }
 
 void JsonObject::setScanConfirm(bool val) {
     setBool("general","ScanConfirm", val, true);
+    mScanConfirm = val;
 }
 
 bool JsonObject::getCompleteNotify() {
-    return getBool("general","CompleteNotify");
+    return mCompleteNotify;
 }
 
 void JsonObject::setCompleteNotify(bool val) {
     setBool("general","CompleteNotify", val, true);
+    mCompleteNotify = val;
 }
 
 bool JsonObject::getAnonymousMode()
 {
-    return getBool("general","AnonymousMode");
+    return mAnonymousMode;
 }
 
 void JsonObject::setAnonymousMode(bool val)
 {
     setBool("general","AnonymousMode", val, true);
+    mAnonymousMode = val;
 }
 
 bool JsonObject::getScreenSaverMode()
 {
-    return getBool("screensaver","open");
+    return mScreenSaverMode;
 }
 
 void JsonObject::setScreenSaverMode(bool aIsOpen)
 {
     setBool("screensaver","open", aIsOpen, true);
+    mScreenSaverMode = aIsOpen;
 }
 
 QStringList JsonObject::getScreenSaverInfomation()
 {
-    return QString(getJsonString("screensaver", "content")).split(";");
+    return mScreenSaverInfoList;
 }
 
-
 bool JsonObject::isDmsSimulator()
 {
-    return getBool("dms","simulator");
+    return mDmsSimulator;
 }
 
 int JsonObject::getOperationLogExpireDays()
 {
-    return QString(getJsonString("operatorlog", "expire")).toInt();
+    return mOperationLogExpireDays;
 }
 
 int JsonObject::getPatientListExpireDays()
 {
-    return QString(getJsonString("patientlist", "expire")).toInt();
+    return mPatientListExpireDays;
 }

src/json/jsonobject.h

@@ -3,7 +3,7 @@
 
 //#include <QObject>
 #include <QString>
-class QStringList;
+#include <QStringList>
 class QTranslator;
 
 #include <QString>
@@ -51,7 +51,7 @@ public:
     QString defaultUser();
 
 
-	QStringList language();
+    QStringList languageList();
     void setDefaultLanguage(const QString& str);
     QString defaultLanguage();
 
@@ -61,9 +61,8 @@ public:
     QString institutionAddr();
     void setInstitutionAddr(const QString& str);
 
-	int lockerCount();
+    int getLockScreenTime();
-	QString lockScreenTimeout();
+    void setLockScreenTime(int aTime);
-	void setLockScreenTimeout(const QString& str);
 
 
     QStringList protocals();
@@ -71,8 +70,6 @@ public:
     void setDefaultProtocal(const QString& str);
 
     QStringList lockScreenTimes();
-    QString defaultLockScreenTime();
-    void setDefaultLockScreenTime(const QString& str);
 
     QStringList worklistFilters();
     QString defaultFilter();
@@ -139,6 +136,7 @@ private:
 
     bool loadcfg();
     bool loadcfgDefault();
+    void init();
     bool savecfg();
 
     JsonObject();
@@ -148,6 +146,42 @@ private:
     bool m_bLoaded = false;
 
     QString tmp_psw;
+
+    QString mStorageAlarmSize;
+    QString mDefaultUser;
+    QString mDefaultLanguage;
+    QString mInstitutionName;
+    QString mInstitutionAddr;
+    QString mDefaultProtocal;
+    QString mInterfaceName;
+    QString mGateway;
+
+
+    QStringList mLockScreenTimeList;
+    QStringList mProtocalList;
+    QStringList mLanguageList;
+    QStringList mScreenSaverInfoList;
+
+    int mLockScreenTime;
+    int mOperationLogExpireDays;
+    int mPatientListExpireDays;
+
+    host mWorklistHost;
+    host mPacsHost;
+    host mLocalHost;
+    host mReconHost;
+    host mMppsHost;
+    IpAddr mDefaultIpAddress;
+
+    bool mDhcp;
+    bool mDmsSimulator;
+    bool mScanConfirm;
+    bool mCompleteNotify;
+    bool mAnonymousMode;
+    bool mScreenSaverMode;
+
+
+
 };
 
 #endif // JSONOBJECT_H