text: /**
  	* \file DlgWznmVerGenjtr.cpp
  	* API code for job DlgWznmVerGenjtr (implementation)
  	* \copyright (C) 2016-2020 MPSI Technologies GmbH
  	* \author Alexander Wirthmueller (auto-generation)
  	* \date created: 5 Dec 2020
  	*/
  // IP header --- ABOVE
  
  #include "DlgWznmVerGenjtr.h"
  
  using namespace std;
  using namespace Sbecore;
  using namespace Xmlio;
  
  /******************************************************************************
   class DlgWznmVerGenjtr::VecVDit
   ******************************************************************************/
  
  uint DlgWznmVerGenjtr::VecVDit::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "gjt") return GJT;
  	if (s == "lfi") return LFI;
  
  	return(0);
  };
  
  string DlgWznmVerGenjtr::VecVDit::getSref(
  			const uint ix
  		) {
  	if (ix == GJT) return("Gjt");
  	if (ix == LFI) return("Lfi");
  
  	return("");
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::VecVDo
   ******************************************************************************/
  
  uint DlgWznmVerGenjtr::VecVDo::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "butdneclick") return BUTDNECLICK;
  
  	return(0);
  };
  
  string DlgWznmVerGenjtr::VecVDo::getSref(
  			const uint ix
  		) {
  	if (ix == BUTDNECLICK) return("ButDneClick");
  
  	return("");
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::VecVDoGjt
   ******************************************************************************/
  
  uint DlgWznmVerGenjtr::VecVDoGjt::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "butrunclick") return BUTRUNCLICK;
  	if (s == "butstoclick") return BUTSTOCLICK;
  
  	return(0);
  };
  
  string DlgWznmVerGenjtr::VecVDoGjt::getSref(
  			const uint ix
  		) {
  	if (ix == BUTRUNCLICK) return("ButRunClick");
  	if (ix == BUTSTOCLICK) return("ButStoClick");
  
  	return("");
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::VecVSge
   ******************************************************************************/
  
  uint DlgWznmVerGenjtr::VecVSge::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "idle") return IDLE;
  	if (s == "alrger") return ALRGER;
  	if (s == "genqtb") return GENQTB;
  	if (s == "genjob") return GENJOB;
  	if (s == "gencall") return GENCALL;
  	if (s == "genctp") return GENCTP;
  	if (s == "asmlfi") return ASMLFI;
  	if (s == "fail") return FAIL;
  	if (s == "done") return DONE;
  
  	return(0);
  };
  
  string DlgWznmVerGenjtr::VecVSge::getSref(
  			const uint ix
  		) {
  	if (ix == IDLE) return("idle");
  	if (ix == ALRGER) return("alrger");
  	if (ix == GENQTB) return("genqtb");
  	if (ix == GENJOB) return("genjob");
  	if (ix == GENCALL) return("gencall");
  	if (ix == GENCTP) return("genctp");
  	if (ix == ASMLFI) return("asmlfi");
  	if (ix == FAIL) return("fail");
  	if (ix == DONE) return("done");
  
  	return("");
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::ContIac
   ******************************************************************************/
  
  DlgWznmVerGenjtr::ContIac::ContIac(
  			const uint numFDse
  		) :
  			Block()
  		{
  	this->numFDse = numFDse;
  
  	mask = {NUMFDSE};
  };
  
  bool DlgWznmVerGenjtr::ContIac::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContIacDlgWznmVerGenjtr");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemIacDlgWznmVerGenjtr";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "numFDse", numFDse)) add(NUMFDSE);
  	};
  
  	return basefound;
  };
  
  void DlgWznmVerGenjtr::ContIac::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "ContIacDlgWznmVerGenjtr";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ci";
  	else itemtag = "ContitemIacDlgWznmVerGenjtr";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "numFDse", numFDse);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> DlgWznmVerGenjtr::ContIac::comm(
  			const ContIac* comp
  		) {
  	set<uint> items;
  
  	if (numFDse == comp->numFDse) insert(items, NUMFDSE);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::ContIac::diff(
  			const ContIac* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {NUMFDSE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::ContInf
   ******************************************************************************/
  
  DlgWznmVerGenjtr::ContInf::ContInf(
  			const uint numFSge
  		) :
  			Block()
  		{
  	this->numFSge = numFSge;
  
  	mask = {NUMFSGE};
  };
  
  bool DlgWznmVerGenjtr::ContInf::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContInfDlgWznmVerGenjtr");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemInfDlgWznmVerGenjtr";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "numFSge", numFSge)) add(NUMFSGE);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::ContInf::comm(
  			const ContInf* comp
  		) {
  	set<uint> items;
  
  	if (numFSge == comp->numFSge) insert(items, NUMFSGE);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::ContInf::diff(
  			const ContInf* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {NUMFSGE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::ContInfGjt
   ******************************************************************************/
  
  DlgWznmVerGenjtr::ContInfGjt::ContInfGjt(
  			const string& TxtPrg
  		) :
  			Block()
  		{
  	this->TxtPrg = TxtPrg;
  
  	mask = {TXTPRG};
  };
  
  bool DlgWznmVerGenjtr::ContInfGjt::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContInfDlgWznmVerGenjtrGjt");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemInfDlgWznmVerGenjtrGjt";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "TxtPrg", TxtPrg)) add(TXTPRG);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::ContInfGjt::comm(
  			const ContInfGjt* comp
  		) {
  	set<uint> items;
  
  	if (TxtPrg == comp->TxtPrg) insert(items, TXTPRG);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::ContInfGjt::diff(
  			const ContInfGjt* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {TXTPRG};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::ContInfLfi
   ******************************************************************************/
  
  DlgWznmVerGenjtr::ContInfLfi::ContInfLfi(
  			const string& Dld
  		) :
  			Block()
  		{
  	this->Dld = Dld;
  
  	mask = {DLD};
  };
  
  bool DlgWznmVerGenjtr::ContInfLfi::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContInfDlgWznmVerGenjtrLfi");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemInfDlgWznmVerGenjtrLfi";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "Dld", Dld)) add(DLD);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::ContInfLfi::comm(
  			const ContInfLfi* comp
  		) {
  	set<uint> items;
  
  	if (Dld == comp->Dld) insert(items, DLD);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::ContInfLfi::diff(
  			const ContInfLfi* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {DLD};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::StatApp
   ******************************************************************************/
  
  DlgWznmVerGenjtr::StatApp::StatApp(
  			const bool initdone
  			, const string& shortMenu
  		) :
  			Block()
  		{
  	this->initdone = initdone;
  	this->shortMenu = shortMenu;
  
  	mask = {INITDONE, SHORTMENU};
  };
  
  bool DlgWznmVerGenjtr::StatApp::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StatAppDlgWznmVerGenjtr");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StatitemAppDlgWznmVerGenjtr";
  
  	if (basefound) {
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "initdone", initdone)) add(INITDONE);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "shortMenu", shortMenu)) add(SHORTMENU);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::StatApp::comm(
  			const StatApp* comp
  		) {
  	set<uint> items;
  
  	if (initdone == comp->initdone) insert(items, INITDONE);
  	if (shortMenu == comp->shortMenu) insert(items, SHORTMENU);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::StatApp::diff(
  			const StatApp* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {INITDONE, SHORTMENU};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::StatShr
   ******************************************************************************/
  
  DlgWznmVerGenjtr::StatShr::StatShr(
  			const bool ButDneActive
  		) :
  			Block()
  		{
  	this->ButDneActive = ButDneActive;
  
  	mask = {BUTDNEACTIVE};
  };
  
  bool DlgWznmVerGenjtr::StatShr::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StatShrDlgWznmVerGenjtr");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StatitemShrDlgWznmVerGenjtr";
  
  	if (basefound) {
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "ButDneActive", ButDneActive)) add(BUTDNEACTIVE);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::StatShr::comm(
  			const StatShr* comp
  		) {
  	set<uint> items;
  
  	if (ButDneActive == comp->ButDneActive) insert(items, BUTDNEACTIVE);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::StatShr::diff(
  			const StatShr* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {BUTDNEACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::StatShrGjt
   ******************************************************************************/
  
  DlgWznmVerGenjtr::StatShrGjt::StatShrGjt(
  			const bool ButRunActive
  			, const bool ButStoActive
  		) :
  			Block()
  		{
  	this->ButRunActive = ButRunActive;
  	this->ButStoActive = ButStoActive;
  
  	mask = {BUTRUNACTIVE, BUTSTOACTIVE};
  };
  
  bool DlgWznmVerGenjtr::StatShrGjt::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StatShrDlgWznmVerGenjtrGjt");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StatitemShrDlgWznmVerGenjtrGjt";
  
  	if (basefound) {
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "ButRunActive", ButRunActive)) add(BUTRUNACTIVE);
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "ButStoActive", ButStoActive)) add(BUTSTOACTIVE);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::StatShrGjt::comm(
  			const StatShrGjt* comp
  		) {
  	set<uint> items;
  
  	if (ButRunActive == comp->ButRunActive) insert(items, BUTRUNACTIVE);
  	if (ButStoActive == comp->ButStoActive) insert(items, BUTSTOACTIVE);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::StatShrGjt::diff(
  			const StatShrGjt* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {BUTRUNACTIVE, BUTSTOACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::StatShrLfi
   ******************************************************************************/
  
  DlgWznmVerGenjtr::StatShrLfi::StatShrLfi(
  			const bool DldActive
  		) :
  			Block()
  		{
  	this->DldActive = DldActive;
  
  	mask = {DLDACTIVE};
  };
  
  bool DlgWznmVerGenjtr::StatShrLfi::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StatShrDlgWznmVerGenjtrLfi");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StatitemShrDlgWznmVerGenjtrLfi";
  
  	if (basefound) {
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "DldActive", DldActive)) add(DLDACTIVE);
  	};
  
  	return basefound;
  };
  
  set<uint> DlgWznmVerGenjtr::StatShrLfi::comm(
  			const StatShrLfi* comp
  		) {
  	set<uint> items;
  
  	if (DldActive == comp->DldActive) insert(items, DLDACTIVE);
  
  	return(items);
  };
  
  set<uint> DlgWznmVerGenjtr::StatShrLfi::diff(
  			const StatShrLfi* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {DLDACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::Tag
   ******************************************************************************/
  
  DlgWznmVerGenjtr::Tag::Tag(
  			const string& Cpt
  			, const string& ButDne
  		) :
  			Block()
  		{
  	this->Cpt = Cpt;
  	this->ButDne = ButDne;
  
  	mask = {CPT, BUTDNE};
  };
  
  bool DlgWznmVerGenjtr::Tag::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "TagDlgWznmVerGenjtr");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "TagitemDlgWznmVerGenjtr";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "Cpt", Cpt)) add(CPT);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "ButDne", ButDne)) add(BUTDNE);
  	};
  
  	return basefound;
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::TagGjt
   ******************************************************************************/
  
  DlgWznmVerGenjtr::TagGjt::TagGjt(
  			const string& CptPrg
  			, const string& ButRun
  			, const string& ButSto
  		) :
  			Block()
  		{
  	this->CptPrg = CptPrg;
  	this->ButRun = ButRun;
  	this->ButSto = ButSto;
  
  	mask = {CPTPRG, BUTRUN, BUTSTO};
  };
  
  bool DlgWznmVerGenjtr::TagGjt::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "TagDlgWznmVerGenjtrGjt");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "TagitemDlgWznmVerGenjtrGjt";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "CptPrg", CptPrg)) add(CPTPRG);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "ButRun", ButRun)) add(BUTRUN);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "ButSto", ButSto)) add(BUTSTO);
  	};
  
  	return basefound;
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::TagLfi
   ******************************************************************************/
  
  DlgWznmVerGenjtr::TagLfi::TagLfi(
  			const string& Dld
  		) :
  			Block()
  		{
  	this->Dld = Dld;
  
  	mask = {DLD};
  };
  
  bool DlgWznmVerGenjtr::TagLfi::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "TagDlgWznmVerGenjtrLfi");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "TagitemDlgWznmVerGenjtrLfi";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "Dld", Dld)) add(DLD);
  	};
  
  	return basefound;
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::DpchAppData
   ******************************************************************************/
  
  DlgWznmVerGenjtr::DpchAppData::DpchAppData(
  			const string& scrJref
  			, ContIac* contiac
  			, const set<uint>& mask
  		) :
  			DpchAppWznm(VecWznmVDpch::DPCHAPPDLGWZNMVERGENJTRDATA, scrJref)
  		{
  	if (find(mask, ALL)) this->mask = {SCRJREF, CONTIAC};
  	else this->mask = mask;
  
  		if (find(this->mask, CONTIAC) && contiac) this->contiac = *contiac;
  };
  
  string DlgWznmVerGenjtr::DpchAppData::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(SCRJREF)) ss.push_back("scrJref");
  	if (has(CONTIAC)) ss.push_back("contiac");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void DlgWznmVerGenjtr::DpchAppData::writeXML(
  			xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchAppDlgWznmVerGenjtrData");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wznm");
  		if (has(SCRJREF)) writeString(wr, "scrJref", scrJref);
  		if (has(CONTIAC)) contiac.writeXML(wr);
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::DpchAppDo
   ******************************************************************************/
  
  DlgWznmVerGenjtr::DpchAppDo::DpchAppDo(
  			const string& scrJref
  			, const uint ixVDo
  			, const uint ixVDoGjt
  			, const set<uint>& mask
  		) :
  			DpchAppWznm(VecWznmVDpch::DPCHAPPDLGWZNMVERGENJTRDO, scrJref)
  		{
  	if (find(mask, ALL)) this->mask = {SCRJREF, IXVDO, IXVDOGJT};
  	else this->mask = mask;
  
  	this->ixVDo = ixVDo;
  	this->ixVDoGjt = ixVDoGjt;
  };
  
  string DlgWznmVerGenjtr::DpchAppDo::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(SCRJREF)) ss.push_back("scrJref");
  	if (has(IXVDO)) ss.push_back("ixVDo");
  	if (has(IXVDOGJT)) ss.push_back("ixVDoGjt");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void DlgWznmVerGenjtr::DpchAppDo::writeXML(
  			xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchAppDlgWznmVerGenjtrDo");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wznm");
  		if (has(SCRJREF)) writeString(wr, "scrJref", scrJref);
  		if (has(IXVDO)) writeString(wr, "srefIxVDo", VecVDo::getSref(ixVDo));
  		if (has(IXVDOGJT)) writeString(wr, "srefIxVDoGjt", VecVDoGjt::getSref(ixVDoGjt));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class DlgWznmVerGenjtr::DpchEngData
   ******************************************************************************/
  
  DlgWznmVerGenjtr::DpchEngData::DpchEngData() :
  			DpchEngWznm(VecWznmVDpch::DPCHENGDLGWZNMVERGENJTRDATA)
  		{
  	feedFDse.tag = "FeedFDse";
  	feedFSge.tag = "FeedFSge";
  };
  
  string DlgWznmVerGenjtr::DpchEngData::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(SCRJREF)) ss.push_back("scrJref");
  	if (has(CONTIAC)) ss.push_back("contiac");
  	if (has(CONTINF)) ss.push_back("continf");
  	if (has(CONTINFGJT)) ss.push_back("continfgjt");
  	if (has(CONTINFLFI)) ss.push_back("continflfi");
  	if (has(FEEDFDSE)) ss.push_back("feedFDse");
  	if (has(FEEDFSGE)) ss.push_back("feedFSge");
  	if (has(STATAPP)) ss.push_back("statapp");
  	if (has(STATSHR)) ss.push_back("statshr");
  	if (has(STATSHRGJT)) ss.push_back("statshrgjt");
  	if (has(STATSHRLFI)) ss.push_back("statshrlfi");
  	if (has(TAG)) ss.push_back("tag");
  	if (has(TAGGJT)) ss.push_back("taggjt");
  	if (has(TAGLFI)) ss.push_back("taglfi");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void DlgWznmVerGenjtr::DpchEngData::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchEngDlgWznmVerGenjtrData");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	if (basefound) {
  		if (extractStringUclc(docctx, basexpath, "scrJref", "", scrJref)) add(SCRJREF);
  		if (contiac.readXML(docctx, basexpath, true)) add(CONTIAC);
  		if (continf.readXML(docctx, basexpath, true)) add(CONTINF);
  		if (continfgjt.readXML(docctx, basexpath, true)) add(CONTINFGJT);
  		if (continflfi.readXML(docctx, basexpath, true)) add(CONTINFLFI);
  		if (feedFDse.readXML(docctx, basexpath, true)) add(FEEDFDSE);
  		if (feedFSge.readXML(docctx, basexpath, true)) add(FEEDFSGE);
  		if (statapp.readXML(docctx, basexpath, true)) add(STATAPP);
  		if (statshr.readXML(docctx, basexpath, true)) add(STATSHR);
  		if (statshrgjt.readXML(docctx, basexpath, true)) add(STATSHRGJT);
  		if (statshrlfi.readXML(docctx, basexpath, true)) add(STATSHRLFI);
  		if (tag.readXML(docctx, basexpath, true)) add(TAG);
  		if (taggjt.readXML(docctx, basexpath, true)) add(TAGGJT);
  		if (taglfi.readXML(docctx, basexpath, true)) add(TAGLFI);
  	} else {
  		contiac = ContIac();
  		continf = ContInf();
  		continfgjt = ContInfGjt();
  		continflfi = ContInfLfi();
  		feedFDse.clear();
  		feedFSge.clear();
  		statapp = StatApp();
  		statshr = StatShr();
  		statshrgjt = StatShrGjt();
  		statshrlfi = StatShrLfi();
  		tag = Tag();
  		taggjt = TagGjt();
  		taglfi = TagLfi();
  	};
  };
  