text: /**
  	* \file PnlWznmCarHk1NControl_blks.cpp
  	* job handler for job PnlWznmCarHk1NControl (implementation of blocks)
  	* \copyright (C) 2016-2020 MPSI Technologies GmbH
  	* \author Alexander Wirthmueller (auto-generation)
  	* \date created: 28 Nov 2020
  	*/
  // IP header --- ABOVE
  
  using namespace std;
  using namespace Sbecore;
  using namespace Xmlio;
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::VecVDo
   ******************************************************************************/
  
  uint PnlWznmCarHk1NControl::VecVDo::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "butupclick") return BUTUPCLICK;
  	if (s == "butdownclick") return BUTDOWNCLICK;
  	if (s == "butviewclick") return BUTVIEWCLICK;
  	if (s == "butnewclick") return BUTNEWCLICK;
  	if (s == "butdeleteclick") return BUTDELETECLICK;
  	if (s == "butrefreshclick") return BUTREFRESHCLICK;
  
  	return(0);
  };
  
  string PnlWznmCarHk1NControl::VecVDo::getSref(
  			const uint ix
  		) {
  	if (ix == BUTUPCLICK) return("ButUpClick");
  	if (ix == BUTDOWNCLICK) return("ButDownClick");
  	if (ix == BUTVIEWCLICK) return("ButViewClick");
  	if (ix == BUTNEWCLICK) return("ButNewClick");
  	if (ix == BUTDELETECLICK) return("ButDeleteClick");
  	if (ix == BUTREFRESHCLICK) return("ButRefreshClick");
  
  	return("");
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::ContInf
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::ContInf::ContInf(
  			const uint numFCsiQst
  		) :
  			Block()
  		{
  	this->numFCsiQst = numFCsiQst;
  
  	mask = {NUMFCSIQST};
  };
  
  void PnlWznmCarHk1NControl::ContInf::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "ContInfWznmCarHk1NControl";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["numFCsiQst"] = numFCsiQst;
  };
  
  void PnlWznmCarHk1NControl::ContInf::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "ContInfWznmCarHk1NControl";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ci";
  	else itemtag = "ContitemInfWznmCarHk1NControl";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "numFCsiQst", numFCsiQst);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWznmCarHk1NControl::ContInf::comm(
  			const ContInf* comp
  		) {
  	set<uint> items;
  
  	if (numFCsiQst == comp->numFCsiQst) insert(items, NUMFCSIQST);
  
  	return(items);
  };
  
  set<uint> PnlWznmCarHk1NControl::ContInf::diff(
  			const ContInf* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {NUMFCSIQST};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::StatApp
   ******************************************************************************/
  
  void PnlWznmCarHk1NControl::StatApp::writeJSON(
  			Json::Value& sup
  			, string difftag
  			, const uint ixWznmVExpstate
  		) {
  	if (difftag.length() == 0) difftag = "StatAppWznmCarHk1NControl";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["srefIxWznmVExpstate"] = VecWznmVExpstate::getSref(ixWznmVExpstate);
  };
  
  void PnlWznmCarHk1NControl::StatApp::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  			, const uint ixWznmVExpstate
  		) {
  	if (difftag.length() == 0) difftag = "StatAppWznmCarHk1NControl";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StatitemAppWznmCarHk1NControl";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeStringAttr(wr, itemtag, "sref", "srefIxWznmVExpstate", VecWznmVExpstate::getSref(ixWznmVExpstate));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::StatShr
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::StatShr::StatShr(
  			const bool ButUpAvail
  			, const bool ButUpActive
  			, const bool ButDownAvail
  			, const bool ButDownActive
  			, const bool ButViewAvail
  			, const bool ButViewActive
  			, const bool ButNewAvail
  			, const bool ButDeleteAvail
  			, const bool ButDeleteActive
  		) :
  			Block()
  		{
  	this->ButUpAvail = ButUpAvail;
  	this->ButUpActive = ButUpActive;
  	this->ButDownAvail = ButDownAvail;
  	this->ButDownActive = ButDownActive;
  	this->ButViewAvail = ButViewAvail;
  	this->ButViewActive = ButViewActive;
  	this->ButNewAvail = ButNewAvail;
  	this->ButDeleteAvail = ButDeleteAvail;
  	this->ButDeleteActive = ButDeleteActive;
  
  	mask = {BUTUPAVAIL, BUTUPACTIVE, BUTDOWNAVAIL, BUTDOWNACTIVE, BUTVIEWAVAIL, BUTVIEWACTIVE, BUTNEWAVAIL, BUTDELETEAVAIL, BUTDELETEACTIVE};
  };
  
  void PnlWznmCarHk1NControl::StatShr::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "StatShrWznmCarHk1NControl";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["ButUpAvail"] = ButUpAvail;
  	me["ButUpActive"] = ButUpActive;
  	me["ButDownAvail"] = ButDownAvail;
  	me["ButDownActive"] = ButDownActive;
  	me["ButViewAvail"] = ButViewAvail;
  	me["ButViewActive"] = ButViewActive;
  	me["ButNewAvail"] = ButNewAvail;
  	me["ButDeleteAvail"] = ButDeleteAvail;
  	me["ButDeleteActive"] = ButDeleteActive;
  };
  
  void PnlWznmCarHk1NControl::StatShr::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "StatShrWznmCarHk1NControl";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StatitemShrWznmCarHk1NControl";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeBoolAttr(wr, itemtag, "sref", "ButUpAvail", ButUpAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButUpActive", ButUpActive);
  		writeBoolAttr(wr, itemtag, "sref", "ButDownAvail", ButDownAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButDownActive", ButDownActive);
  		writeBoolAttr(wr, itemtag, "sref", "ButViewAvail", ButViewAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButViewActive", ButViewActive);
  		writeBoolAttr(wr, itemtag, "sref", "ButNewAvail", ButNewAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButDeleteAvail", ButDeleteAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButDeleteActive", ButDeleteActive);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWznmCarHk1NControl::StatShr::comm(
  			const StatShr* comp
  		) {
  	set<uint> items;
  
  	if (ButUpAvail == comp->ButUpAvail) insert(items, BUTUPAVAIL);
  	if (ButUpActive == comp->ButUpActive) insert(items, BUTUPACTIVE);
  	if (ButDownAvail == comp->ButDownAvail) insert(items, BUTDOWNAVAIL);
  	if (ButDownActive == comp->ButDownActive) insert(items, BUTDOWNACTIVE);
  	if (ButViewAvail == comp->ButViewAvail) insert(items, BUTVIEWAVAIL);
  	if (ButViewActive == comp->ButViewActive) insert(items, BUTVIEWACTIVE);
  	if (ButNewAvail == comp->ButNewAvail) insert(items, BUTNEWAVAIL);
  	if (ButDeleteAvail == comp->ButDeleteAvail) insert(items, BUTDELETEAVAIL);
  	if (ButDeleteActive == comp->ButDeleteActive) insert(items, BUTDELETEACTIVE);
  
  	return(items);
  };
  
  set<uint> PnlWznmCarHk1NControl::StatShr::diff(
  			const StatShr* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {BUTUPAVAIL, BUTUPACTIVE, BUTDOWNAVAIL, BUTDOWNACTIVE, BUTVIEWAVAIL, BUTVIEWACTIVE, BUTNEWAVAIL, BUTDELETEAVAIL, BUTDELETEACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::StgIac
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::StgIac::StgIac(
  			const uint TcoRefWidth
  		) :
  			Block()
  		{
  	this->TcoRefWidth = TcoRefWidth;
  	mask = {TCOREFWIDTH};
  };
  
  bool PnlWznmCarHk1NControl::StgIac::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["StgIacWznmCarHk1NControl"];
  
  	basefound = (me != Json::nullValue);
  
  	if (basefound) {
  		if (me.isMember("TcoRefWidth")) {TcoRefWidth = me["TcoRefWidth"].asUInt(); add(TCOREFWIDTH);};
  	};
  
  	return basefound;
  };
  
  bool PnlWznmCarHk1NControl::StgIac::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StgIacWznmCarHk1NControl");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StgitemIacWznmCarHk1NControl";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoRefWidth", TcoRefWidth)) add(TCOREFWIDTH);
  	};
  
  	return basefound;
  };
  
  void PnlWznmCarHk1NControl::StgIac::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "StgIacWznmCarHk1NControl";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["TcoRefWidth"] = TcoRefWidth;
  };
  
  void PnlWznmCarHk1NControl::StgIac::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "StgIacWznmCarHk1NControl";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StgitemIacWznmCarHk1NControl";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "TcoRefWidth", TcoRefWidth);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWznmCarHk1NControl::StgIac::comm(
  			const StgIac* comp
  		) {
  	set<uint> items;
  
  	if (TcoRefWidth == comp->TcoRefWidth) insert(items, TCOREFWIDTH);
  
  	return(items);
  };
  
  set<uint> PnlWznmCarHk1NControl::StgIac::diff(
  			const StgIac* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {TCOREFWIDTH};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::Tag
   ******************************************************************************/
  
  void PnlWznmCarHk1NControl::Tag::writeJSON(
  			const uint ixWznmVLocale
  			, Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "TagWznmCarHk1NControl";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	if (ixWznmVLocale == VecWznmVLocale::ENUS) {
  		me["Cpt"] = "Controls";
  		me["TcoRef"] = "Control";
  	};
  	me["TxtRecord1"] = StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::REC, ixWznmVLocale));
  	me["TxtRecord2"] = StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::EMPLONG, ixWznmVLocale));
  	me["Trs"] = StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::GOTO, ixWznmVLocale)) + " ...";
  	me["TxtShowing1"] = VecWznmVTag::getTitle(VecWznmVTag::SHOWSHORT, ixWznmVLocale);
  	me["TxtShowing2"] = VecWznmVTag::getTitle(VecWznmVTag::EMPSHORT, ixWznmVLocale);
  };
  
  void PnlWznmCarHk1NControl::Tag::writeXML(
  			const uint ixWznmVLocale
  			, xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "TagWznmCarHk1NControl";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ti";
  	else itemtag = "TagitemWznmCarHk1NControl";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		if (ixWznmVLocale == VecWznmVLocale::ENUS) {
  			writeStringAttr(wr, itemtag, "sref", "Cpt", "Controls");
  			writeStringAttr(wr, itemtag, "sref", "TcoRef", "Control");
  		};
  		writeStringAttr(wr, itemtag, "sref", "TxtRecord1", StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::REC, ixWznmVLocale)));
  		writeStringAttr(wr, itemtag, "sref", "TxtRecord2", StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::EMPLONG, ixWznmVLocale)));
  		writeStringAttr(wr, itemtag, "sref", "Trs", StrMod::cap(VecWznmVTag::getTitle(VecWznmVTag::GOTO, ixWznmVLocale)) + " ...");
  		writeStringAttr(wr, itemtag, "sref", "TxtShowing1", VecWznmVTag::getTitle(VecWznmVTag::SHOWSHORT, ixWznmVLocale));
  		writeStringAttr(wr, itemtag, "sref", "TxtShowing2", VecWznmVTag::getTitle(VecWznmVTag::EMPSHORT, ixWznmVLocale));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::DpchAppData
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::DpchAppData::DpchAppData() :
  			DpchAppWznm(VecWznmVDpch::DPCHAPPWZNMCARHK1NCONTROLDATA)
  		{
  };
  
  string PnlWznmCarHk1NControl::DpchAppData::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(JREF)) ss.push_back("jref");
  	if (has(STGIAC)) ss.push_back("stgiac");
  	if (has(STGIACQRY)) ss.push_back("stgiacqry");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void PnlWznmCarHk1NControl::DpchAppData::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["DpchAppWznmCarHk1NControlData"];
  
  	basefound = (me != Json::nullValue);
  
  	if (basefound) {
  		if (me.isMember("scrJref")) {jref = Scr::descramble(me["scrJref"].asString()); add(JREF);};
  		if (stgiac.readJSON(me, true)) add(STGIAC);
  		if (stgiacqry.readJSON(me, true)) add(STGIACQRY);
  	} else {
  		stgiac = StgIac();
  		stgiacqry = QryWznmCarHk1NControl::StgIac();
  	};
  };
  
  void PnlWznmCarHk1NControl::DpchAppData::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	string scrJref;
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchAppWznmCarHk1NControlData");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	if (basefound) {
  		if (extractStringUclc(docctx, basexpath, "scrJref", "", scrJref)) {
  			jref = Scr::descramble(scrJref);
  			add(JREF);
  		};
  		if (stgiac.readXML(docctx, basexpath, true)) add(STGIAC);
  		if (stgiacqry.readXML(docctx, basexpath, true)) add(STGIACQRY);
  	} else {
  		stgiac = StgIac();
  		stgiacqry = QryWznmCarHk1NControl::StgIac();
  	};
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::DpchAppDo
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::DpchAppDo::DpchAppDo() :
  			DpchAppWznm(VecWznmVDpch::DPCHAPPWZNMCARHK1NCONTROLDO)
  		{
  	ixVDo = 0;
  };
  
  string PnlWznmCarHk1NControl::DpchAppDo::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(JREF)) ss.push_back("jref");
  	if (has(IXVDO)) ss.push_back("ixVDo");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void PnlWznmCarHk1NControl::DpchAppDo::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["DpchAppWznmCarHk1NControlDo"];
  
  	basefound = (me != Json::nullValue);
  
  	if (basefound) {
  		if (me.isMember("scrJref")) {jref = Scr::descramble(me["scrJref"].asString()); add(JREF);};
  		if (me.isMember("srefIxVDo")) {ixVDo = VecVDo::getIx(me["srefIxVDo"].asString()); add(IXVDO);};
  	} else {
  	};
  };
  
  void PnlWznmCarHk1NControl::DpchAppDo::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	string scrJref;
  	string srefIxVDo;
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchAppWznmCarHk1NControlDo");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	if (basefound) {
  		if (extractStringUclc(docctx, basexpath, "scrJref", "", scrJref)) {
  			jref = Scr::descramble(scrJref);
  			add(JREF);
  		};
  		if (extractStringUclc(docctx, basexpath, "srefIxVDo", "", srefIxVDo)) {
  			ixVDo = VecVDo::getIx(srefIxVDo);
  			add(IXVDO);
  		};
  	} else {
  	};
  };
  
  /******************************************************************************
   class PnlWznmCarHk1NControl::DpchEngData
   ******************************************************************************/
  
  PnlWznmCarHk1NControl::DpchEngData::DpchEngData(
  			const ubigint jref
  			, ContInf* continf
  			, Feed* feedFCsiQst
  			, StatShr* statshr
  			, StgIac* stgiac
  			, ListWznmQCarHk1NControl* rst
  			, QryWznmCarHk1NControl::StatShr* statshrqry
  			, QryWznmCarHk1NControl::StgIac* stgiacqry
  			, const set<uint>& mask
  		) :
  			DpchEngWznm(VecWznmVDpch::DPCHENGWZNMCARHK1NCONTROLDATA, jref)
  		{
  	if (find(mask, ALL)) this->mask = {JREF, CONTINF, FEEDFCSIQST, STATAPP, STATSHR, STGIAC, TAG, RST, STATAPPQRY, STATSHRQRY, STGIACQRY};
  	else this->mask = mask;
  
  	if (find(this->mask, CONTINF) && continf) this->continf = *continf;
  	if (find(this->mask, FEEDFCSIQST) && feedFCsiQst) this->feedFCsiQst = *feedFCsiQst;
  	if (find(this->mask, STATSHR) && statshr) this->statshr = *statshr;
  	if (find(this->mask, STGIAC) && stgiac) this->stgiac = *stgiac;
  	if (find(this->mask, RST) && rst) this->rst = *rst;
  	if (find(this->mask, STATSHRQRY) && statshrqry) this->statshrqry = *statshrqry;
  	if (find(this->mask, STGIACQRY) && stgiacqry) this->stgiacqry = *stgiacqry;
  };
  
  string PnlWznmCarHk1NControl::DpchEngData::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(JREF)) ss.push_back("jref");
  	if (has(CONTINF)) ss.push_back("continf");
  	if (has(FEEDFCSIQST)) ss.push_back("feedFCsiQst");
  	if (has(STATAPP)) ss.push_back("statapp");
  	if (has(STATSHR)) ss.push_back("statshr");
  	if (has(STGIAC)) ss.push_back("stgiac");
  	if (has(TAG)) ss.push_back("tag");
  	if (has(RST)) ss.push_back("rst");
  	if (has(STATAPPQRY)) ss.push_back("statappqry");
  	if (has(STATSHRQRY)) ss.push_back("statshrqry");
  	if (has(STGIACQRY)) ss.push_back("stgiacqry");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void PnlWznmCarHk1NControl::DpchEngData::merge(
  			DpchEngWznm* dpcheng
  		) {
  	DpchEngData* src = (DpchEngData*) dpcheng;
  
  	if (src->has(JREF)) {jref = src->jref; add(JREF);};
  	if (src->has(CONTINF)) {continf = src->continf; add(CONTINF);};
  	if (src->has(FEEDFCSIQST)) {feedFCsiQst = src->feedFCsiQst; add(FEEDFCSIQST);};
  	if (src->has(STATAPP)) add(STATAPP);
  	if (src->has(STATSHR)) {statshr = src->statshr; add(STATSHR);};
  	if (src->has(STGIAC)) {stgiac = src->stgiac; add(STGIAC);};
  	if (src->has(TAG)) add(TAG);
  	if (src->has(RST)) {rst = src->rst; add(RST);};
  	if (src->has(STATAPPQRY)) add(STATAPPQRY);
  	if (src->has(STATSHRQRY)) {statshrqry = src->statshrqry; add(STATSHRQRY);};
  	if (src->has(STGIACQRY)) {stgiacqry = src->stgiacqry; add(STGIACQRY);};
  };
  
  void PnlWznmCarHk1NControl::DpchEngData::writeJSON(
  			const uint ixWznmVLocale
  			, Json::Value& sup
  		) {
  	Json::Value& me = sup["DpchEngWznmCarHk1NControlData"] = Json::Value(Json::objectValue);
  
  	if (has(JREF)) me["scrJref"] = Scr::scramble(jref);
  	if (has(CONTINF)) continf.writeJSON(me);
  	if (has(FEEDFCSIQST)) feedFCsiQst.writeJSON(me);
  	if (has(STATAPP)) StatApp::writeJSON(me);
  	if (has(STATSHR)) statshr.writeJSON(me);
  	if (has(STGIAC)) stgiac.writeJSON(me);
  	if (has(TAG)) Tag::writeJSON(ixWznmVLocale, me);
  	if (has(RST)) rst.writeJSON(me);
  	if (has(STATAPPQRY)) QryWznmCarHk1NControl::StatApp::writeJSON(me);
  	if (has(STATSHRQRY)) statshrqry.writeJSON(me);
  	if (has(STGIACQRY)) stgiacqry.writeJSON(me);
  };
  
  void PnlWznmCarHk1NControl::DpchEngData::writeXML(
  			const uint ixWznmVLocale
  			, xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchEngWznmCarHk1NControlData");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wznm");
  		if (has(JREF)) writeString(wr, "scrJref", Scr::scramble(jref));
  		if (has(CONTINF)) continf.writeXML(wr);
  		if (has(FEEDFCSIQST)) feedFCsiQst.writeXML(wr);
  		if (has(STATAPP)) StatApp::writeXML(wr);
  		if (has(STATSHR)) statshr.writeXML(wr);
  		if (has(STGIAC)) stgiac.writeXML(wr);
  		if (has(TAG)) Tag::writeXML(ixWznmVLocale, wr);
  		if (has(RST)) rst.writeXML(wr);
  		if (has(STATAPPQRY)) QryWznmCarHk1NControl::StatApp::writeXML(wr);
  		if (has(STATSHRQRY)) statshrqry.writeXML(wr);
  		if (has(STGIACQRY)) stgiacqry.writeXML(wr);
  	xmlTextWriterEndElement(wr);
  };
  