text: /**
  	* \file PnlWzskFilList.cpp
  	* API code for job PnlWzskFilList (implementation)
  	* \copyright (C) 2016-2020 MPSI Technologies GmbH
  	* \author Emily Johnson (auto-generation)
  	* \date created: 5 Dec 2020
  	*/
  // IP header --- ABOVE
  
  #include "PnlWzskFilList.h"
  
  using namespace std;
  using namespace Sbecore;
  using namespace Xmlio;
  
  /******************************************************************************
   class PnlWzskFilList::VecVDo
   ******************************************************************************/
  
  uint PnlWzskFilList::VecVDo::getIx(
  			const string& sref
  		) {
  	string s = StrMod::lc(sref);
  
  	if (s == "butminimizeclick") return BUTMINIMIZECLICK;
  	if (s == "butregularizeclick") return BUTREGULARIZECLICK;
  	if (s == "butnewclick") return BUTNEWCLICK;
  	if (s == "butdeleteclick") return BUTDELETECLICK;
  	if (s == "butfilterclick") return BUTFILTERCLICK;
  	if (s == "butrefreshclick") return BUTREFRESHCLICK;
  
  	return(0);
  };
  
  string PnlWzskFilList::VecVDo::getSref(
  			const uint ix
  		) {
  	if (ix == BUTMINIMIZECLICK) return("ButMinimizeClick");
  	if (ix == BUTREGULARIZECLICK) return("ButRegularizeClick");
  	if (ix == BUTNEWCLICK) return("ButNewClick");
  	if (ix == BUTDELETECLICK) return("ButDeleteClick");
  	if (ix == BUTFILTERCLICK) return("ButFilterClick");
  	if (ix == BUTREFRESHCLICK) return("ButRefreshClick");
  
  	return("");
  };
  
  /******************************************************************************
   class PnlWzskFilList::ContIac
   ******************************************************************************/
  
  PnlWzskFilList::ContIac::ContIac(
  			const uint numFTos
  		) :
  			Block()
  		{
  	this->numFTos = numFTos;
  
  	mask = {NUMFTOS};
  };
  
  bool PnlWzskFilList::ContIac::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContIacWzskFilList");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemIacWzskFilList";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "numFTos", numFTos)) add(NUMFTOS);
  	};
  
  	return basefound;
  };
  
  void PnlWzskFilList::ContIac::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "ContIacWzskFilList";
  
  	string itemtag;
  	if (shorttags) itemtag = "Ci";
  	else itemtag = "ContitemIacWzskFilList";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "numFTos", numFTos);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWzskFilList::ContIac::comm(
  			const ContIac* comp
  		) {
  	set<uint> items;
  
  	if (numFTos == comp->numFTos) insert(items, NUMFTOS);
  
  	return(items);
  };
  
  set<uint> PnlWzskFilList::ContIac::diff(
  			const ContIac* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {NUMFTOS};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWzskFilList::ContInf
   ******************************************************************************/
  
  PnlWzskFilList::ContInf::ContInf(
  			const string& TxtFor
  			, const string& TxtPre
  			, const bool ButFilterOn
  			, const uint numFCsiQst
  		) :
  			Block()
  		{
  	this->TxtFor = TxtFor;
  	this->TxtPre = TxtPre;
  	this->ButFilterOn = ButFilterOn;
  	this->numFCsiQst = numFCsiQst;
  
  	mask = {TXTFOR, TXTPRE, BUTFILTERON, NUMFCSIQST};
  };
  
  bool PnlWzskFilList::ContInf::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "ContInfWzskFilList");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "ContitemInfWzskFilList";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "TxtFor", TxtFor)) add(TXTFOR);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "TxtPre", TxtPre)) add(TXTPRE);
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "ButFilterOn", ButFilterOn)) add(BUTFILTERON);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Ci", "sref", "numFCsiQst", numFCsiQst)) add(NUMFCSIQST);
  	};
  
  	return basefound;
  };
  
  set<uint> PnlWzskFilList::ContInf::comm(
  			const ContInf* comp
  		) {
  	set<uint> items;
  
  	if (TxtFor == comp->TxtFor) insert(items, TXTFOR);
  	if (TxtPre == comp->TxtPre) insert(items, TXTPRE);
  	if (ButFilterOn == comp->ButFilterOn) insert(items, BUTFILTERON);
  	if (numFCsiQst == comp->numFCsiQst) insert(items, NUMFCSIQST);
  
  	return(items);
  };
  
  set<uint> PnlWzskFilList::ContInf::diff(
  			const ContInf* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {TXTFOR, TXTPRE, BUTFILTERON, NUMFCSIQST};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWzskFilList::StatShr
   ******************************************************************************/
  
  PnlWzskFilList::StatShr::StatShr(
  			const uint ixWzskVExpstate
  			, const bool ButDeleteActive
  		) :
  			Block()
  		{
  	this->ixWzskVExpstate = ixWzskVExpstate;
  	this->ButDeleteActive = ButDeleteActive;
  
  	mask = {IXWZSKVEXPSTATE, BUTDELETEACTIVE};
  };
  
  bool PnlWzskFilList::StatShr::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	string srefIxWzskVExpstate;
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StatShrWzskFilList");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StatitemShrWzskFilList";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "srefIxWzskVExpstate", srefIxWzskVExpstate)) {
  			ixWzskVExpstate = VecWzskVExpstate::getIx(srefIxWzskVExpstate);
  			add(IXWZSKVEXPSTATE);
  		};
  		if (extractBoolAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "ButDeleteActive", ButDeleteActive)) add(BUTDELETEACTIVE);
  	};
  
  	return basefound;
  };
  
  set<uint> PnlWzskFilList::StatShr::comm(
  			const StatShr* comp
  		) {
  	set<uint> items;
  
  	if (ixWzskVExpstate == comp->ixWzskVExpstate) insert(items, IXWZSKVEXPSTATE);
  	if (ButDeleteActive == comp->ButDeleteActive) insert(items, BUTDELETEACTIVE);
  
  	return(items);
  };
  
  set<uint> PnlWzskFilList::StatShr::diff(
  			const StatShr* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {IXWZSKVEXPSTATE, BUTDELETEACTIVE};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWzskFilList::StgIac
   ******************************************************************************/
  
  PnlWzskFilList::StgIac::StgIac(
  			const uint TcoGrpWidth
  			, const uint TcoOwnWidth
  			, const uint TcoFnmWidth
  			, const uint TcoRetWidth
  			, const uint TcoReuWidth
  			, const uint TcoCntWidth
  			, const uint TcoMimWidth
  			, const uint TcoSizWidth
  		) :
  			Block()
  		{
  	this->TcoGrpWidth = TcoGrpWidth;
  	this->TcoOwnWidth = TcoOwnWidth;
  	this->TcoFnmWidth = TcoFnmWidth;
  	this->TcoRetWidth = TcoRetWidth;
  	this->TcoReuWidth = TcoReuWidth;
  	this->TcoCntWidth = TcoCntWidth;
  	this->TcoMimWidth = TcoMimWidth;
  	this->TcoSizWidth = TcoSizWidth;
  
  	mask = {TCOGRPWIDTH, TCOOWNWIDTH, TCOFNMWIDTH, TCORETWIDTH, TCOREUWIDTH, TCOCNTWIDTH, TCOMIMWIDTH, TCOSIZWIDTH};
  };
  
  bool PnlWzskFilList::StgIac::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "StgIacWzskFilList");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "StgitemIacWzskFilList";
  
  	if (basefound) {
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoGrpWidth", TcoGrpWidth)) add(TCOGRPWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoOwnWidth", TcoOwnWidth)) add(TCOOWNWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoFnmWidth", TcoFnmWidth)) add(TCOFNMWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoRetWidth", TcoRetWidth)) add(TCORETWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoReuWidth", TcoReuWidth)) add(TCOREUWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoCntWidth", TcoCntWidth)) add(TCOCNTWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoMimWidth", TcoMimWidth)) add(TCOMIMWIDTH);
  		if (extractUintAttrUclc(docctx, basexpath, itemtag, "Si", "sref", "TcoSizWidth", TcoSizWidth)) add(TCOSIZWIDTH);
  	};
  
  	return basefound;
  };
  
  void PnlWzskFilList::StgIac::writeXML(
  			xmlTextWriter* wr
  			, string difftag
  			, bool shorttags
  		) {
  	if (difftag.length() == 0) difftag = "StgIacWzskFilList";
  
  	string itemtag;
  	if (shorttags) itemtag = "Si";
  	else itemtag = "StgitemIacWzskFilList";
  
  	xmlTextWriterStartElement(wr, BAD_CAST difftag.c_str());
  		writeUintAttr(wr, itemtag, "sref", "TcoGrpWidth", TcoGrpWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoOwnWidth", TcoOwnWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoFnmWidth", TcoFnmWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoRetWidth", TcoRetWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoReuWidth", TcoReuWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoCntWidth", TcoCntWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoMimWidth", TcoMimWidth);
  		writeUintAttr(wr, itemtag, "sref", "TcoSizWidth", TcoSizWidth);
  	xmlTextWriterEndElement(wr);
  };
  
  set<uint> PnlWzskFilList::StgIac::comm(
  			const StgIac* comp
  		) {
  	set<uint> items;
  
  	if (TcoGrpWidth == comp->TcoGrpWidth) insert(items, TCOGRPWIDTH);
  	if (TcoOwnWidth == comp->TcoOwnWidth) insert(items, TCOOWNWIDTH);
  	if (TcoFnmWidth == comp->TcoFnmWidth) insert(items, TCOFNMWIDTH);
  	if (TcoRetWidth == comp->TcoRetWidth) insert(items, TCORETWIDTH);
  	if (TcoReuWidth == comp->TcoReuWidth) insert(items, TCOREUWIDTH);
  	if (TcoCntWidth == comp->TcoCntWidth) insert(items, TCOCNTWIDTH);
  	if (TcoMimWidth == comp->TcoMimWidth) insert(items, TCOMIMWIDTH);
  	if (TcoSizWidth == comp->TcoSizWidth) insert(items, TCOSIZWIDTH);
  
  	return(items);
  };
  
  set<uint> PnlWzskFilList::StgIac::diff(
  			const StgIac* comp
  		) {
  	set<uint> commitems;
  	set<uint> diffitems;
  
  	commitems = comm(comp);
  
  	diffitems = {TCOGRPWIDTH, TCOOWNWIDTH, TCOFNMWIDTH, TCORETWIDTH, TCOREUWIDTH, TCOCNTWIDTH, TCOMIMWIDTH, TCOSIZWIDTH};
  	for (auto it = commitems.begin(); it != commitems.end(); it++) diffitems.erase(*it);
  
  	return(diffitems);
  };
  
  /******************************************************************************
   class PnlWzskFilList::Tag
   ******************************************************************************/
  
  PnlWzskFilList::Tag::Tag(
  			const string& Cpt
  			, const string& TxtFor
  			, const string& TxtRecord1
  			, const string& TxtRecord2
  			, const string& Trs
  			, const string& TxtShowing1
  			, const string& TxtShowing2
  			, const string& TcoGrp
  			, const string& TcoOwn
  			, const string& TcoFnm
  			, const string& TcoRet
  			, const string& TcoReu
  			, const string& TcoCnt
  			, const string& TcoMim
  			, const string& TcoSiz
  		) :
  			Block()
  		{
  	this->Cpt = Cpt;
  	this->TxtFor = TxtFor;
  	this->TxtRecord1 = TxtRecord1;
  	this->TxtRecord2 = TxtRecord2;
  	this->Trs = Trs;
  	this->TxtShowing1 = TxtShowing1;
  	this->TxtShowing2 = TxtShowing2;
  	this->TcoGrp = TcoGrp;
  	this->TcoOwn = TcoOwn;
  	this->TcoFnm = TcoFnm;
  	this->TcoRet = TcoRet;
  	this->TcoReu = TcoReu;
  	this->TcoCnt = TcoCnt;
  	this->TcoMim = TcoMim;
  	this->TcoSiz = TcoSiz;
  
  	mask = {CPT, TXTFOR, TXTRECORD1, TXTRECORD2, TRS, TXTSHOWING1, TXTSHOWING2, TCOGRP, TCOOWN, TCOFNM, TCORET, TCOREU, TCOCNT, TCOMIM, TCOSIZ};
  };
  
  bool PnlWzskFilList::Tag::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "TagWzskFilList");
  	else
  		basefound = checkXPath(docctx, basexpath);
  
  	string itemtag = "TagitemWzskFilList";
  
  	if (basefound) {
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "Cpt", Cpt)) add(CPT);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TxtFor", TxtFor)) add(TXTFOR);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TxtRecord1", TxtRecord1)) add(TXTRECORD1);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TxtRecord2", TxtRecord2)) add(TXTRECORD2);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "Trs", Trs)) add(TRS);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TxtShowing1", TxtShowing1)) add(TXTSHOWING1);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TxtShowing2", TxtShowing2)) add(TXTSHOWING2);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoGrp", TcoGrp)) add(TCOGRP);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoOwn", TcoOwn)) add(TCOOWN);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoFnm", TcoFnm)) add(TCOFNM);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoRet", TcoRet)) add(TCORET);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoReu", TcoReu)) add(TCOREU);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoCnt", TcoCnt)) add(TCOCNT);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoMim", TcoMim)) add(TCOMIM);
  		if (extractStringAttrUclc(docctx, basexpath, itemtag, "Ti", "sref", "TcoSiz", TcoSiz)) add(TCOSIZ);
  	};
  
  	return basefound;
  };
  
  /******************************************************************************
   class PnlWzskFilList::DpchAppData
   ******************************************************************************/
  
  PnlWzskFilList::DpchAppData::DpchAppData(
  			const string& scrJref
  			, ContIac* contiac
  			, StgIac* stgiac
  			, QryWzskFilList::StgIac* stgiacqry
  			, const set<uint>& mask
  		) :
  			DpchAppWzsk(VecWzskVDpch::DPCHAPPWZSKFILLISTDATA, scrJref)
  		{
  	if (find(mask, ALL)) this->mask = {SCRJREF, CONTIAC, STGIAC, STGIACQRY};
  	else this->mask = mask;
  
  		if (find(this->mask, CONTIAC) && contiac) this->contiac = *contiac;
  		if (find(this->mask, STGIAC) && stgiac) this->stgiac = *stgiac;
  		if (find(this->mask, STGIACQRY) && stgiacqry) this->stgiacqry = *stgiacqry;
  };
  
  string PnlWzskFilList::DpchAppData::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(SCRJREF)) ss.push_back("scrJref");
  	if (has(CONTIAC)) ss.push_back("contiac");
  	if (has(STGIAC)) ss.push_back("stgiac");
  	if (has(STGIACQRY)) ss.push_back("stgiacqry");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void PnlWzskFilList::DpchAppData::writeXML(
  			xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchAppWzskFilListData");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wzsk");
  		if (has(SCRJREF)) writeString(wr, "scrJref", scrJref);
  		if (has(CONTIAC)) contiac.writeXML(wr);
  		if (has(STGIAC)) stgiac.writeXML(wr);
  		if (has(STGIACQRY)) stgiacqry.writeXML(wr);
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWzskFilList::DpchAppDo
   ******************************************************************************/
  
  PnlWzskFilList::DpchAppDo::DpchAppDo(
  			const string& scrJref
  			, const uint ixVDo
  			, const set<uint>& mask
  		) :
  			DpchAppWzsk(VecWzskVDpch::DPCHAPPWZSKFILLISTDO, scrJref)
  		{
  	if (find(mask, ALL)) this->mask = {SCRJREF, IXVDO};
  	else this->mask = mask;
  
  	this->ixVDo = ixVDo;
  };
  
  string PnlWzskFilList::DpchAppDo::getSrefsMask() {
  	vector<string> ss;
  	string srefs;
  
  	if (has(SCRJREF)) ss.push_back("scrJref");
  	if (has(IXVDO)) ss.push_back("ixVDo");
  
  	StrMod::vectorToString(ss, srefs);
  
  	return(srefs);
  };
  
  void PnlWzskFilList::DpchAppDo::writeXML(
  			xmlTextWriter* wr
  		) {
  	xmlTextWriterStartElement(wr, BAD_CAST "DpchAppWzskFilListDo");
  	xmlTextWriterWriteAttribute(wr, BAD_CAST "xmlns", BAD_CAST "http://www.mpsitech.com/wzsk");
  		if (has(SCRJREF)) writeString(wr, "scrJref", scrJref);
  		if (has(IXVDO)) writeString(wr, "srefIxVDo", VecVDo::getSref(ixVDo));
  	xmlTextWriterEndElement(wr);
  };
  
  /******************************************************************************
   class PnlWzskFilList::DpchEngData
   ******************************************************************************/
  
  PnlWzskFilList::DpchEngData::DpchEngData() :
  			DpchEngWzsk(VecWzskVDpch::DPCHENGWZSKFILLISTDATA)
  		{
  	feedFCsiQst.tag = "FeedFCsiQst";
  	feedFTos.tag = "FeedFTos";
  };
  
  string PnlWzskFilList::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(FEEDFCSIQST)) ss.push_back("feedFCsiQst");
  	if (has(FEEDFTOS)) ss.push_back("feedFTos");
  	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 PnlWzskFilList::DpchEngData::readXML(
  			xmlXPathContext* docctx
  			, string basexpath
  			, bool addbasetag
  		) {
  	clear();
  
  	bool basefound;
  
  	if (addbasetag)
  		basefound = checkUclcXPaths(docctx, basexpath, basexpath, "DpchEngWzskFilListData");
  	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 (feedFCsiQst.readXML(docctx, basexpath, true)) add(FEEDFCSIQST);
  		if (feedFTos.readXML(docctx, basexpath, true)) add(FEEDFTOS);
  		if (statshr.readXML(docctx, basexpath, true)) add(STATSHR);
  		if (stgiac.readXML(docctx, basexpath, true)) add(STGIAC);
  		if (tag.readXML(docctx, basexpath, true)) add(TAG);
  		if (rst.readXML(docctx, basexpath, true)) add(RST);
  		if (statappqry.readXML(docctx, basexpath, true)) add(STATAPPQRY);
  		if (statshrqry.readXML(docctx, basexpath, true)) add(STATSHRQRY);
  		if (stgiacqry.readXML(docctx, basexpath, true)) add(STGIACQRY);
  	} else {
  		contiac = ContIac();
  		continf = ContInf();
  		feedFCsiQst.clear();
  		feedFTos.clear();
  		statshr = StatShr();
  		stgiac = StgIac();
  		tag = Tag();
  		rst.clear();
  		statappqry = QryWzskFilList::StatApp();
  		statshrqry = QryWzskFilList::StatShr();
  		stgiacqry = QryWzskFilList::StgIac();
  	};
  };
  