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)
@@ -411,22 +425,25 @@ void JsonObject::setServer(ServerType type, const host& list)
 	{
 
 	case JsonObject::WORKLIST:
-		typeName = "worklist";
+        typeName = "worklist";
-		break;
+        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";
+        mMppsHost = list;
         break;
-	default:
-		break;
 	}
 	setJsonString(typeName.toStdString().c_str(), "ae", list.ae.toStdString().c_str(), false);
 	setJsonString(typeName.toStdString().c_str(), "ip", list.ip.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,29 +3,29 @@
 
 //#include <QObject>
 #include <QString>
-class QStringList;
+#include <QStringList>
 class QTranslator;
 
 #include <QString>
 struct host {
-	QString name;
+    QString name;
-	QString ae;
+    QString ae;
-	QString ip;
+    QString ip;
-	QString port;
+    QString port;
-	//QString isDefault;
+    //QString isDefault;
 };
 
 struct IpAddr {
     bool dhcp;
-	QString ip;
+    QString ip;
-	QString mask;
+    QString mask;
     QString gateway;
 };
 struct IpRoute
 {
-	QString des;
+    QString des;
-	QString gw;
+    QString gw;
-	QString mask;
+    QString mask;
 };
 
 
@@ -33,65 +33,62 @@ class JsonObject
 {
 public:
 
-	static JsonObject* Instance()
+    static JsonObject* Instance()
-	{
+    {
-		static JsonObject obj;
+        static JsonObject obj;
-		return &obj;
+        return &obj;
-	}
+    }
-	enum ServerType
+    enum ServerType
-	{
+    {
         WORKLIST, PACS, LOCAL, RECON, MPPS
-	};
+    };
 
-	//
+    //
-	QString storageAlarmSize();
+    QString storageAlarmSize();
-	// 
+    //
-	//for login
+    //for login
-	void setDefaultUser(const QString& str);
+    void setDefaultUser(const QString& str);
-	QString defaultUser();
+    QString defaultUser();
 
 
-	QStringList language();
+    QStringList languageList();
-	void setDefaultLanguage(const QString& str);
+    void setDefaultLanguage(const QString& str);
-	QString defaultLanguage();
+    QString defaultLanguage();
 
-	QString institutionName();
+    QString institutionName();
-	void setInstitutionName(const QString& str);
+    void setInstitutionName(const QString& str);
 
-	QString institutionAddr();
+    QString institutionAddr();
-	void setInstitutionAddr(const QString& str);
+    void setInstitutionAddr(const QString& str);
 
-	int lockerCount();
+    int getLockScreenTime();
-	QString lockScreenTimeout();
+    void setLockScreenTime(int aTime);
-	void setLockScreenTimeout(const QString& str);
 
 
-	QStringList protocals();
+    QStringList protocals();
-	QString defaultProtocal();
+    QString defaultProtocal();
-	void setDefaultProtocal(const QString& str);
+    void setDefaultProtocal(const QString& str);
 
     QStringList lockScreenTimes();
-    QString defaultLockScreenTime();
-    void setDefaultLockScreenTime(const QString& str);
 
-	QStringList worklistFilters();
+    QStringList worklistFilters();
-	QString defaultFilter();
+    QString defaultFilter();
-	void setDefaultFilter(const QString& str);
+    void setDefaultFilter(const QString& str);
 
-	host getServer(ServerType type);
+    host getServer(ServerType type);
-	void setServer(ServerType type, const host& list);
+    void setServer(ServerType type, const host& list);
 
-	//for network manager
+    //for network manager
 
-	QString passWord();
+    QString passWord();
-	void setPassword(const QString& pwd);
+    void setPassword(const QString& pwd);
 
-	QString interfaceName();
+    QString interfaceName();
-	void setInterfaceName(const QString& name);
+    void setInterfaceName(const QString& name);
 
-	bool isDHCP();
+    bool isDHCP();
     bool isDmsSimulator();
-	void autoDHCP(bool);
+    void autoDHCP(bool);
 
     bool getScanConfirm();
     void setScanConfirm(bool val);
@@ -108,46 +105,83 @@ public:
     const char* getEmptyScanID();
     void setEmptyScanID(const char* id);
 
-	IpAddr getDefaultIpAddr();
+    IpAddr getDefaultIpAddr();
-	void setDefaultIpAddr(const IpAddr& addr);
+    void setDefaultIpAddr(const IpAddr& addr);
 
-	QList<QStringList> getIpAddrList();
+    QList<QStringList> getIpAddrList();
-	void setIpAddrList(const QList<QStringList>& list);
+    void setIpAddrList(const QList<QStringList>& list);
 
-	QString getDefaultGateway();
+    QString getDefaultGateway();
-	void setDefaultGateway(const QString& gw);
+    void setDefaultGateway(const QString& gw);
 
-	QList<QStringList> getIpRouteList();
+    QList<QStringList> getIpRouteList();
-	void setIpRouteList(const QList<QStringList>& list);
+    void setIpRouteList(const QList<QStringList>& list);
 
-	QStringList getScreenSaverInfomation();
+    QStringList getScreenSaverInfomation();
     int getOperationLogExpireDays();
     int getPatientListExpireDays();
 
 
 private:
-	void  setJsonString(const char* catergory, const char* stringName, const char* stringValue, bool save = true);
+    void  setJsonString(const char* catergory, const char* stringName, const char* stringValue, bool save = true);
-	char* getJsonString(const char* catergory, const char* stringName);
+    char* getJsonString(const char* catergory, const char* stringName);
 
-	void setBool(const char* catergory, const char* stringName,bool val, bool save = true);
+    void setBool(const char* catergory, const char* stringName,bool val, bool save = true);
     bool getBool(const char* catergory, const char* stringName);
 
-	char* getArrayNode(const char* catergory, const char* stringName, int index, const char* id);
+    char* getArrayNode(const char* catergory, const char* stringName, int index, const char* id);
-	void setArrayNode(const char* catergory, const char* stringName, int index, const char* id, const char* stringValue);
+    void setArrayNode(const char* catergory, const char* stringName, int index, const char* id, const char* stringValue);
-	int getArraySize(const char* catergory, const char* stringName);
+    int getArraySize(const char* catergory, const char* stringName);
 
 
-	bool loadcfg();
+    bool loadcfg();
-	bool loadcfgDefault();
+    bool loadcfgDefault();
-	bool savecfg();
+    void init();
+    bool savecfg();
+
+    JsonObject();
+    ~JsonObject();
+
+    void* json_root = nullptr;
+    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;
 
-	JsonObject();
-	~JsonObject();
 
-	void* json_root = nullptr;
-	bool m_bLoaded = false;
 
-	QString tmp_psw;
 };
 
 #endif // JSONOBJECT_H