text: /**
  	* \file PnlWdbeModCtrMNCommand_blks.cpp
  	* job handler for job PnlWdbeModCtrMNCommand (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 PnlWdbeModCtrMNCommand::VecVDo
   ******************************************************************************/
  
  uint PnlWdbeModCtrMNCommand::VecVDo::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "butviewclick") return BUTVIEWCLICK;
  	if (s == "butaddclick") return BUTADDCLICK;
  	if (s == "butsubclick") return BUTSUBCLICK;
  	if (s == "butrefreshclick") return BUTREFRESHCLICK;
  
  	return(0);
  };
  
  string PnlWdbeModCtrMNCommand::VecVDo::getSref(
  			const uint ix
  		) {
  	if (ix == BUTVIEWCLICK) return("ButViewClick");
  	if (ix == BUTADDCLICK) return("ButAddClick");
  	if (ix == BUTSUBCLICK) return("ButSubClick");
  	if (ix == BUTREFRESHCLICK) return("ButRefreshClick");
  
  	return("");
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::ContInf
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::ContInf::ContInf(
  			const uint numFCsiQst
  		) :
  			Block()
  		{
  	this->numFCsiQst = numFCsiQst;
  
  	mask = {NUMFCSIQST};
  };
  
  void PnlWdbeModCtrMNCommand::ContInf::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "ContInfWdbeModCtrMNCommand";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["numFCsiQst"] = numFCsiQst;
  };
  
  void PnlWdbeModCtrMNCommand::ContInf::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "ContInfWdbeModCtrMNCommand";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ci";
  	else itemtag = "ContitemInfWdbeModCtrMNCommand";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "numFCsiQst", numFCsiQst);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::ContInf::comm(
  			const ContInf* comp
  		) {
  	set<uint> items;
  
  	if (numFCsiQst == comp->numFCsiQst) insert(items, NUMFCSIQST);
  
  	return(items);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::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 PnlWdbeModCtrMNCommand::StatApp
   ******************************************************************************/
  
  void PnlWdbeModCtrMNCommand::StatApp::writeJSON(
  			Json::Value& sup
  			, string difftag
  			, const uint ixWdbeVExpstate
  		) {
  	if (difftag.length() == 0) difftag = "StatAppWdbeModCtrMNCommand";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["srefIxWdbeVExpstate"] = VecWdbeVExpstate::getSref(ixWdbeVExpstate);
  };
  
  void PnlWdbeModCtrMNCommand::StatApp::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  			, const uint ixWdbeVExpstate
  		) {
  	if (difftag.length() == 0) difftag = "StatAppWdbeModCtrMNCommand";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StatitemAppWdbeModCtrMNCommand";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeStringAttr(wr, itemtag, "sref", "srefIxWdbeVExpstate", VecWdbeVExpstate::getSref(ixWdbeVExpstate));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::StatShr
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::StatShr::StatShr(
  			const bool ButViewAvail
  			, const bool ButViewActive
  			, const bool ButAddAvail
  			, const bool ButSubAvail
  			, const bool ButSubActive
  		) :
  			Block()
  		{
  	this->ButViewAvail = ButViewAvail;
  	this->ButViewActive = ButViewActive;
  	this->ButAddAvail = ButAddAvail;
  	this->ButSubAvail = ButSubAvail;
  	this->ButSubActive = ButSubActive;
  
  	mask = {BUTVIEWAVAIL, BUTVIEWACTIVE, BUTADDAVAIL, BUTSUBAVAIL, BUTSUBACTIVE};
  };
  
  void PnlWdbeModCtrMNCommand::StatShr::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "StatShrWdbeModCtrMNCommand";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["ButViewAvail"] = ButViewAvail;
  	me["ButViewActive"] = ButViewActive;
  	me["ButAddAvail"] = ButAddAvail;
  	me["ButSubAvail"] = ButSubAvail;
  	me["ButSubActive"] = ButSubActive;
  };
  
  void PnlWdbeModCtrMNCommand::StatShr::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "StatShrWdbeModCtrMNCommand";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StatitemShrWdbeModCtrMNCommand";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeBoolAttr(wr, itemtag, "sref", "ButViewAvail", ButViewAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButViewActive", ButViewActive);
  		writeBoolAttr(wr, itemtag, "sref", "ButAddAvail", ButAddAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButSubAvail", ButSubAvail);
  		writeBoolAttr(wr, itemtag, "sref", "ButSubActive", ButSubActive);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::StatShr::comm(
  			const StatShr* comp
  		) {
  	set<uint> items;
  
  	if (ButViewAvail == comp->ButViewAvail) insert(items, BUTVIEWAVAIL);
  	if (ButViewActive == comp->ButViewActive) insert(items, BUTVIEWACTIVE);
  	if (ButAddAvail == comp->ButAddAvail) insert(items, BUTADDAVAIL);
  	if (ButSubAvail == comp->ButSubAvail) insert(items, BUTSUBAVAIL);
  	if (ButSubActive == comp->ButSubActive) insert(items, BUTSUBACTIVE);
  
  	return(items);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::StatShr::diff(
  			const StatShr* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {BUTVIEWAVAIL, BUTVIEWACTIVE, BUTADDAVAIL, BUTSUBAVAIL, BUTSUBACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::StgIac
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::StgIac::StgIac(
  			const uint TcoMrefWidth
  			, const uint TcoIvrWidth
  			, const uint TcoRvrWidth
  		) :
  			Block()
  		{
  	this->TcoMrefWidth = TcoMrefWidth;
  	this->TcoIvrWidth = TcoIvrWidth;
  	this->TcoRvrWidth = TcoRvrWidth;
  	mask = {TCOMREFWIDTH, TCOIVRWIDTH, TCORVRWIDTH};
  };
  
  bool PnlWdbeModCtrMNCommand::StgIac::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["StgIacWdbeModCtrMNCommand"];
  
  	basefound = (me != Json::nullValue);
  
  	if (basefound) {
  		if (me.isMember("TcoMrefWidth")) {TcoMrefWidth = me["TcoMrefWidth"].asUInt(); add(TCOMREFWIDTH);};
  		if (me.isMember("TcoIvrWidth")) {TcoIvrWidth = me["TcoIvrWidth"].asUInt(); add(TCOIVRWIDTH);};
  		if (me.isMember("TcoRvrWidth")) {TcoRvrWidth = me["TcoRvrWidth"].asUInt(); add(TCORVRWIDTH);};
  	};
  
  	return basefound;
  };
  
  bool PnlWdbeModCtrMNCommand::StgIac::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StgIacWdbeModCtrMNCommand");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StgitemIacWdbeModCtrMNCommand";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoMrefWidth", TcoMrefWidth)) add(TCOMREFWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoIvrWidth", TcoIvrWidth)) add(TCOIVRWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoRvrWidth", TcoRvrWidth)) add(TCORVRWIDTH);
  	};
  
  	return basefound;
  };
  
  void PnlWdbeModCtrMNCommand::StgIac::writeJSON(
  			Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "StgIacWdbeModCtrMNCommand";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	me["TcoMrefWidth"] = TcoMrefWidth;
  	me["TcoIvrWidth"] = TcoIvrWidth;
  	me["TcoRvrWidth"] = TcoRvrWidth;
  };
  
  void PnlWdbeModCtrMNCommand::StgIac::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "StgIacWdbeModCtrMNCommand";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StgitemIacWdbeModCtrMNCommand";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "TcoMrefWidth", TcoMrefWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoIvrWidth", TcoIvrWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoRvrWidth", TcoRvrWidth);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::StgIac::comm(
  			const StgIac* comp
  		) {
  	set<uint> items;
  
  	if (TcoMrefWidth == comp->TcoMrefWidth) insert(items, TCOMREFWIDTH);
  	if (TcoIvrWidth == comp->TcoIvrWidth) insert(items, TCOIVRWIDTH);
  	if (TcoRvrWidth == comp->TcoRvrWidth) insert(items, TCORVRWIDTH);
  
  	return(items);
  };
  
  set<uint> PnlWdbeModCtrMNCommand::StgIac::diff(
  			const StgIac* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {TCOMREFWIDTH, TCOIVRWIDTH, TCORVRWIDTH};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::Tag
   ******************************************************************************/
  
  void PnlWdbeModCtrMNCommand::Tag::writeJSON(
  			const uint ixWdbeVLocale
  			, Json::Value& sup
  			, string difftag
  		) {
  	if (difftag.length() == 0) difftag = "TagWdbeModCtrMNCommand";
  
  	Json::Value& me = sup[difftag] = Json::Value(Json::objectValue);
  
  	if (ixWdbeVLocale == VecWdbeVLocale::ENUS) {
  		me["Cpt"] = "Invoked commands";
  		me["TcoMref"] = "Command";
  		me["TcoIvr"] = "Invocation request signal";
  		me["TcoRvr"] = "Revocation request signal";
  	};
  	me["TxtRecord1"] = StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::REC, ixWdbeVLocale));
  	me["TxtRecord2"] = StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::EMPLONG, ixWdbeVLocale));
  	me["Trs"] = StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::GOTO, ixWdbeVLocale)) + " ...";
  	me["TxtShowing1"] = VecWdbeVTag::getTitle(VecWdbeVTag::SHOWSHORT, ixWdbeVLocale);
  	me["TxtShowing2"] = VecWdbeVTag::getTitle(VecWdbeVTag::EMPSHORT, ixWdbeVLocale);
  };
  
  void PnlWdbeModCtrMNCommand::Tag::writeXML(
  			const uint ixWdbeVLocale
  			, xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "TagWdbeModCtrMNCommand";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ti";
  	else itemtag = "TagitemWdbeModCtrMNCommand";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		if (ixWdbeVLocale == VecWdbeVLocale::ENUS) {
  			writeStringAttr(wr, itemtag, "sref", "Cpt", "Invoked commands");
  			writeStringAttr(wr, itemtag, "sref", "TcoMref", "Command");
  			writeStringAttr(wr, itemtag, "sref", "TcoIvr", "Invocation request signal");
  			writeStringAttr(wr, itemtag, "sref", "TcoRvr", "Revocation request signal");
  		};
  		writeStringAttr(wr, itemtag, "sref", "TxtRecord1", StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::REC, ixWdbeVLocale)));
  		writeStringAttr(wr, itemtag, "sref", "TxtRecord2", StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::EMPLONG, ixWdbeVLocale)));
  		writeStringAttr(wr, itemtag, "sref", "Trs", StrMod::cap(VecWdbeVTag::getTitle(VecWdbeVTag::GOTO, ixWdbeVLocale)) + " ...");
  		writeStringAttr(wr, itemtag, "sref", "TxtShowing1", VecWdbeVTag::getTitle(VecWdbeVTag::SHOWSHORT, ixWdbeVLocale));
  		writeStringAttr(wr, itemtag, "sref", "TxtShowing2", VecWdbeVTag::getTitle(VecWdbeVTag::EMPSHORT, ixWdbeVLocale));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::DpchAppData
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::DpchAppData::DpchAppData() :
  			DpchAppWdbe(VecWdbeVDpch::DPCHAPPWDBEMODCTRMNCOMMANDDATA)
  		{
  };
  
  string PnlWdbeModCtrMNCommand::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 PnlWdbeModCtrMNCommand::DpchAppData::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["DpchAppWdbeModCtrMNCommandData"];
  
  	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 = QryWdbeModCtrMNCommand::StgIac();
  	};
  };
  
  void PnlWdbeModCtrMNCommand::DpchAppData::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	string scrJref;
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchAppWdbeModCtrMNCommandData");
  	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 = QryWdbeModCtrMNCommand::StgIac();
  	};
  };
  
  /******************************************************************************
   class PnlWdbeModCtrMNCommand::DpchAppDo
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::DpchAppDo::DpchAppDo() :
  			DpchAppWdbe(VecWdbeVDpch::DPCHAPPWDBEMODCTRMNCOMMANDDO)
  		{
  	ixVDo = 0;
  };
  
  string PnlWdbeModCtrMNCommand::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 PnlWdbeModCtrMNCommand::DpchAppDo::readJSON(
  			Json::Value& sup
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	Json::Value& me = sup;
  	if (addbasetag) me = sup["DpchAppWdbeModCtrMNCommandDo"];
  
  	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 PnlWdbeModCtrMNCommand::DpchAppDo::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	string scrJref;
  	string srefIxVDo;
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchAppWdbeModCtrMNCommandDo");
  	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 PnlWdbeModCtrMNCommand::DpchEngData
   ******************************************************************************/
  
  PnlWdbeModCtrMNCommand::DpchEngData::DpchEngData(
  			const ubigint jref
  			, ContInf* continf
  			, Feed* feedFCsiQst
  			, StatShr* statshr
  			, StgIac* stgiac
  			, ListWdbeQModCtrMNCommand* rst
  			, QryWdbeModCtrMNCommand::StatShr* statshrqry
  			, QryWdbeModCtrMNCommand::StgIac* stgiacqry
  			, const set<uint>& mask
  		) :
  			DpchEngWdbe(VecWdbeVDpch::DPCHENGWDBEMODCTRMNCOMMANDDATA, 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 PnlWdbeModCtrMNCommand::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 PnlWdbeModCtrMNCommand::DpchEngData::merge(
  			DpchEngWdbe* 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 PnlWdbeModCtrMNCommand::DpchEngData::writeJSON(
  			const uint ixWdbeVLocale
  			, Json::Value& sup
  		) {
  	Json::Value& me = sup["DpchEngWdbeModCtrMNCommandData"] = 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(ixWdbeVLocale, me);
  	if (has(RST)) rst.writeJSON(me);
  	if (has(STATAPPQRY)) QryWdbeModCtrMNCommand::StatApp::writeJSON(me);
  	if (has(STATSHRQRY)) statshrqry.writeJSON(me);
  	if (has(STGIACQRY)) stgiacqry.writeJSON(me);
  };
  
  void PnlWdbeModCtrMNCommand::DpchEngData::writeXML(
  			const uint ixWdbeVLocale
  			, xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchEngWdbeModCtrMNCommandData");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wdbe");
  		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(ixWdbeVLocale, wr);
  		if (has(RST)) rst.writeXML(wr);
  		if (has(STATAPPQRY)) QryWdbeModCtrMNCommand::StatApp::writeXML(wr);
  		if (has(STATSHRQRY)) statshrqry.writeXML(wr);
  		if (has(STGIACQRY)) stgiacqry.writeXML(wr);
  	xmlTextWriterEndElement(wr);
  };
  