// Version:		2019.8.5  10:14:49

// File: T_WPD_DATA.cpp

#include "T_WPD_DATA.h"

T_WPD_DATA::T_WPD_DATA(){
//  initialise all membervariables
	initial();
}
T_WPD_DATA::~T_WPD_DATA(){
}
void T_WPD_DATA::initial(){
//  initialise all membervariables
	set_entId((char*)"");
	set_pre_entId((char*)"");
	set_pre_entIdZi(-1);
	set_WPDX_NAME(0,(char*)"");
	set_WPDX_NAMEZi(0,-1);
	set_WPDX_NAME(1,(char*)"");
	set_WPDX_NAMEZi(1,-1);
	set_WPDX_NAME(2,(char*)"");
	set_WPDX_NAMEZi(2,-1);
	set_WPDX_NAME(3,(char*)"");
	set_WPDX_NAMEZi(3,-1);
	set_WPDX_NAME(4,(char*)"");
	set_WPDX_NAMEZi(4,-1);
	set_WPDX_NAME(5,(char*)"");
	set_WPDX_NAMEZi(5,-1);
	set_WPDX(0,0.0);
	set_WPDXZi(0,-1);
	set_WPDX(1,0.0);
	set_WPDXZi(1,-1);
	set_WPDX(2,0.0);
	set_WPDXZi(2,-1);
	set_WPDX(3,0.0);
	set_WPDXZi(3,-1);
	set_WPDX(4,0.0);
	set_WPDXZi(4,-1);
	set_WPDX(5,0.0);
	set_WPDXZi(5,-1);
	set_toc((char*)"");
	set_tocZi(-1);
	set_toc((char*)"");
	set_tomZi(-1);
	set_mop((char*)"");
	set_mopZi(-1);
	set_mou((char*)"");
	set_mouZi(-1);
// initialies Primary key members
	set_k_entId((char*)"");
}
T_WPD_DATA::T_WPD_DATA(const char* arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

char* T_WPD_DATA:: execute(const char* sql , long* count){
	return( db.execute( sql , count ) );
}

char* T_WPD_DATA:: dbCommit(){
	return( db.dbCommit( ) );
}

char* T_WPD_DATA:: dbRollback(){
	return( db.dbRollback( ) );
}

char* T_WPD_DATA::readDB(){
	// DB Trace is off
	return( db.readDB(*this) );
}

char* T_WPD_DATA::updateDB(){
	// DB Trace is off
	return( db.updateDB(*this) );
}

char* T_WPD_DATA::insertDB(){
	// DB Trace is off
	return( db.insertDB(*this) );
}

char* T_WPD_DATA::deleteDB(){
	// DB Trace is off
	return( db.deleteDB(*this) );
}

char* T_WPD_DATA::deleteDB(const char * where, long* count){
	// DB Trace is off
	return( db.deleteDB( where , count ) );
}

char* T_WPD_DATA::openSetDB(const char * where,const char* order){
	// DB Trace is off
	return( db.openSetDB( where , order ) );
}

char* T_WPD_DATA::countDB(const char * where, long* count){
	// DB Trace is off
	return( db.countDB( where , count ) );
}

char* T_WPD_DATA::getSetDB(){
	// DB Trace is off
	return( db.getSetDB(*this) );
}

char* T_WPD_DATA::closeSetDB(){
	// DB Trace is off
	return( db.closeSetDB() );
}

char* T_WPD_DATA::storeDB(){
	char* ret = NULL;
	setKeysFromRecord();
	ret=db.updateDB(*this);
	if(ret != NULL){
		ret=db.insertDB(*this);
		if(ret != NULL){
			dbAccess = false;
			return(ret);
		}
	}
	return(ret);
}

//	 public methode setPrimKey T_WPD_DATA
//
//	this methode stores the unique key attributes
//
void T_WPD_DATA::setPrimKey( const char* arg1 ){
	strncpy( (char*)c_k_entId , arg1 , sizeof(c_k_entId) );
	c_k_entId[sizeof(c_k_entId)-1] = '\0';
} // end of methode

void T_WPD_DATA::initInsertKeys( const char* arg1 ){
	setPrimKey (  arg1);
	strncpy( (char*)c_entId , arg1 , sizeof(c_entId) );
	c_entId[sizeof(c_entId)-1] = '\0';
} // end of methode
void T_WPD_DATA::setKeysFromRecord(){
	set_k_entId( entId() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_WPD_DATA T_WPD_DATA::operator+(const T_WPD_DATA &inst) const{
	T_WPD_DATA ptrT_WPD_DATA(*this);
//----------------------------------------------------------
	ptrT_WPD_DATA.set_entId(inst.entId());
//----------------------------------------------------------
	if(inst.pre_entIdZi() != -1){
		ptrT_WPD_DATA.set_pre_entId(inst.pre_entId());
		ptrT_WPD_DATA.set_pre_entIdZi(inst.pre_entIdZi());
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(0) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(0,inst.WPDX_NAME(0));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(0,inst.WPDX_NAMEZi(0));
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(1) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(1,inst.WPDX_NAME(1));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(1,inst.WPDX_NAMEZi(1));
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(2) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(2,inst.WPDX_NAME(2));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(2,inst.WPDX_NAMEZi(2));
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(3) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(3,inst.WPDX_NAME(3));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(3,inst.WPDX_NAMEZi(3));
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(4) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(4,inst.WPDX_NAME(4));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(4,inst.WPDX_NAMEZi(4));
	}
//----------------------------------------------------------
	if(inst.WPDX_NAMEZi(5) != -1){
		ptrT_WPD_DATA.set_WPDX_NAME(5,inst.WPDX_NAME(5));
		ptrT_WPD_DATA.set_WPDX_NAMEZi(5,inst.WPDX_NAMEZi(5));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(0) != -1){
		ptrT_WPD_DATA.set_WPDX(0,inst.WPDX(0));
		ptrT_WPD_DATA.set_WPDXZi(0,inst.WPDXZi(0));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(1) != -1){
		ptrT_WPD_DATA.set_WPDX(1,inst.WPDX(1));
		ptrT_WPD_DATA.set_WPDXZi(1,inst.WPDXZi(1));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(2) != -1){
		ptrT_WPD_DATA.set_WPDX(2,inst.WPDX(2));
		ptrT_WPD_DATA.set_WPDXZi(2,inst.WPDXZi(2));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(3) != -1){
		ptrT_WPD_DATA.set_WPDX(3,inst.WPDX(3));
		ptrT_WPD_DATA.set_WPDXZi(3,inst.WPDXZi(3));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(4) != -1){
		ptrT_WPD_DATA.set_WPDX(4,inst.WPDX(4));
		ptrT_WPD_DATA.set_WPDXZi(4,inst.WPDXZi(4));
	}
//----------------------------------------------------------
	if(inst.WPDXZi(5) != -1){
		ptrT_WPD_DATA.set_WPDX(5,inst.WPDX(5));
		ptrT_WPD_DATA.set_WPDXZi(5,inst.WPDXZi(5));
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_WPD_DATA.set_toc(inst.toc());
		ptrT_WPD_DATA.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_WPD_DATA.set_tom(inst.tom());
		ptrT_WPD_DATA.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_WPD_DATA.set_mop(inst.mop());
		ptrT_WPD_DATA.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_WPD_DATA.set_mou(inst.mou());
		ptrT_WPD_DATA.set_mouZi(inst.mouZi());
	}
	return (ptrT_WPD_DATA);
}

//
//O P E R A T O R  = 
//===================
//
const T_WPD_DATA& T_WPD_DATA::operator=(const T_WPD_DATA &inst){
//----------------------------------------------------------
	this->set_entId(inst.entId());
//----------------------------------------------------------
	this->set_pre_entId(inst.pre_entId());
	this->set_pre_entIdZi(inst.pre_entIdZi());
//----------------------------------------------------------
	this->set_WPDX_NAME(0,inst.WPDX_NAME(0));
	this->set_WPDX_NAMEZi(0,inst.WPDX_NAMEZi(0));
//----------------------------------------------------------
	this->set_WPDX_NAME(1,inst.WPDX_NAME(1));
	this->set_WPDX_NAMEZi(1,inst.WPDX_NAMEZi(1));
//----------------------------------------------------------
	this->set_WPDX_NAME(2,inst.WPDX_NAME(2));
	this->set_WPDX_NAMEZi(2,inst.WPDX_NAMEZi(2));
//----------------------------------------------------------
	this->set_WPDX_NAME(3,inst.WPDX_NAME(3));
	this->set_WPDX_NAMEZi(3,inst.WPDX_NAMEZi(3));
//----------------------------------------------------------
	this->set_WPDX_NAME(4,inst.WPDX_NAME(4));
	this->set_WPDX_NAMEZi(4,inst.WPDX_NAMEZi(4));
//----------------------------------------------------------
	this->set_WPDX_NAME(5,inst.WPDX_NAME(5));
	this->set_WPDX_NAMEZi(5,inst.WPDX_NAMEZi(5));
//----------------------------------------------------------
	this->set_WPDX(0,inst.WPDX(0));
	this->set_WPDXZi(0,inst.WPDXZi(0));
//----------------------------------------------------------
	this->set_WPDX(1,inst.WPDX(1));
	this->set_WPDXZi(1,inst.WPDXZi(1));
//----------------------------------------------------------
	this->set_WPDX(2,inst.WPDX(2));
	this->set_WPDXZi(2,inst.WPDXZi(2));
//----------------------------------------------------------
	this->set_WPDX(3,inst.WPDX(3));
	this->set_WPDXZi(3,inst.WPDXZi(3));
//----------------------------------------------------------
	this->set_WPDX(4,inst.WPDX(4));
	this->set_WPDXZi(4,inst.WPDXZi(4));
//----------------------------------------------------------
	this->set_WPDX(5,inst.WPDX(5));
	this->set_WPDXZi(5,inst.WPDXZi(5));
//----------------------------------------------------------
	this->set_toc(inst.toc());
	this->set_tocZi(inst.tocZi());
//----------------------------------------------------------
	this->set_tom(inst.tom());
	this->set_tomZi(inst.tomZi());
//----------------------------------------------------------
	this->set_mop(inst.mop());
	this->set_mopZi(inst.mopZi());
//----------------------------------------------------------
	this->set_mou(inst.mou());
	this->set_mouZi(inst.mouZi());
	return (*this);
}
//
//C O P Y - C O N S T R U C T O R
//===================
//
T_WPD_DATA::T_WPD_DATA(const T_WPD_DATA &inst){
//----------------------------------------------------------
	this->set_entId(inst.entId());
//----------------------------------------------------------
	this->set_pre_entId(inst.pre_entId());
	this->set_pre_entIdZi(inst.pre_entIdZi());
//----------------------------------------------------------
	this->set_WPDX_NAME(0,inst.WPDX_NAME(0));
	this->set_WPDX_NAMEZi(0,inst.WPDX_NAMEZi(0));
//----------------------------------------------------------
	this->set_WPDX_NAME(1,inst.WPDX_NAME(1));
	this->set_WPDX_NAMEZi(1,inst.WPDX_NAMEZi(1));
//----------------------------------------------------------
	this->set_WPDX_NAME(2,inst.WPDX_NAME(2));
	this->set_WPDX_NAMEZi(2,inst.WPDX_NAMEZi(2));
//----------------------------------------------------------
	this->set_WPDX_NAME(3,inst.WPDX_NAME(3));
	this->set_WPDX_NAMEZi(3,inst.WPDX_NAMEZi(3));
//----------------------------------------------------------
	this->set_WPDX_NAME(4,inst.WPDX_NAME(4));
	this->set_WPDX_NAMEZi(4,inst.WPDX_NAMEZi(4));
//----------------------------------------------------------
	this->set_WPDX_NAME(5,inst.WPDX_NAME(5));
	this->set_WPDX_NAMEZi(5,inst.WPDX_NAMEZi(5));
//----------------------------------------------------------
	this->set_WPDX(0,inst.WPDX(0));
	this->set_WPDXZi(0,inst.WPDXZi(0));
//----------------------------------------------------------
	this->set_WPDX(1,inst.WPDX(1));
	this->set_WPDXZi(1,inst.WPDXZi(1));
//----------------------------------------------------------
	this->set_WPDX(2,inst.WPDX(2));
	this->set_WPDXZi(2,inst.WPDXZi(2));
//----------------------------------------------------------
	this->set_WPDX(3,inst.WPDX(3));
	this->set_WPDXZi(3,inst.WPDXZi(3));
//----------------------------------------------------------
	this->set_WPDX(4,inst.WPDX(4));
	this->set_WPDXZi(4,inst.WPDXZi(4));
//----------------------------------------------------------
	this->set_WPDX(5,inst.WPDX(5));
	this->set_WPDXZi(5,inst.WPDXZi(5));
//----------------------------------------------------------
	this->set_toc(inst.toc());
	this->set_tocZi(inst.tocZi());
//----------------------------------------------------------
	this->set_tom(inst.tom());
	this->set_tomZi(inst.tomZi());
//----------------------------------------------------------
	this->set_mop(inst.mop());
	this->set_mopZi(inst.mopZi());
//----------------------------------------------------------
	this->set_mou(inst.mou());
	this->set_mouZi(inst.mouZi());
}
char* T_WPD_DATA::entId() const{
	return((char*)c_entId );
}


void T_WPD_DATA::set_entId( const char* arg ){ 
	strncpy((char*)c_entId , arg , sizeof(c_entId));
	c_entId[sizeof(c_entId)-1] = '\0';
	return;
}


char* T_WPD_DATA::pre_entId() const{
	return((char*)c_pre_entId );
}

short T_WPD_DATA::pre_entIdZi() const{
	return( s_pre_entIdZi);
}

void T_WPD_DATA::set_pre_entId( const char* arg ){ 
	strncpy((char*)c_pre_entId , arg , sizeof(c_pre_entId));
	c_pre_entId[sizeof(c_pre_entId)-1] = '\0';
	s_pre_entIdZi=  0;
	return;
}

void T_WPD_DATA::set_pre_entIdZi( short arg ) {
	s_pre_entIdZi =  arg;
}

int T_WPD_DATA::WPDX_NAMEArraySize(){
	return(6);
}

char* T_WPD_DATA::WPDX_NAME(int colInd) const{
	return((char*)c_WPDX_NAME[colInd] );
}

short T_WPD_DATA::WPDX_NAMEZi(int colInd) const{
	return( s_WPDX_NAMEZi[colInd]);
}

void T_WPD_DATA::set_WPDX_NAME( int colInd, const char* arg ){ 
	strncpy((char*)c_WPDX_NAME[colInd] , arg , sizeof(c_WPDX_NAME[colInd]));
	c_WPDX_NAME[colInd][sizeof(c_WPDX_NAME[colInd])-1] = '\0';
	s_WPDX_NAMEZi[colInd]=  0;
	return;
}

void T_WPD_DATA::set_WPDX_NAMEZi( int colInd, short arg ) {
	s_WPDX_NAMEZi[colInd] =  arg;
}

int T_WPD_DATA::WPDXArraySize(){
	return(6);
}

double T_WPD_DATA::WPDX(int colInd) const{
	return((double)d_WPDX[colInd] );
}

short T_WPD_DATA::WPDXZi(int colInd) const{
	return( s_WPDXZi[colInd]);
}

void T_WPD_DATA::set_WPDX( int colInd, double arg ){ 
	d_WPDX[colInd] = arg;
	s_WPDXZi[colInd]=  0;
	return;
}

void T_WPD_DATA::set_WPDXZi( int colInd, short arg ) {
	s_WPDXZi[colInd] =  arg;
}

char* T_WPD_DATA::toc() const{
	return((char*)c_toc );
}

short T_WPD_DATA::tocZi() const{
	return( s_tocZi);
}

void T_WPD_DATA::set_toc( char* arg ){
	strncpy((char*)c_toc , arg , sizeof(c_toc));
	c_toc[sizeof(c_toc)-1] = '\0';
	s_tocZi=  0;
	return;
}

void T_WPD_DATA::set_tocZi( short arg ){
	s_tocZi =  arg;
}

char* T_WPD_DATA::tom() const{
	return((char*)c_tom );
}

short T_WPD_DATA::tomZi() const{
	return( s_tomZi);
}

void T_WPD_DATA::set_tom( char* arg ){
	strncpy((char*)c_tom , arg , sizeof(c_tom));
	c_tom[sizeof(c_tom)-1] = '\0';
	s_tomZi=  0;
	return;
}

void T_WPD_DATA::set_tomZi( short arg ){
	s_tomZi =  arg;
}

char* T_WPD_DATA::mop() const{
	return((char*)c_mop );
}

short T_WPD_DATA::mopZi() const{
	return( s_mopZi);
}

void T_WPD_DATA::set_mop( char* arg ){
	strncpy((char*)c_mop , arg , sizeof(c_mop));
	c_mop[sizeof(c_mop)-1] = '\0';
	s_mopZi=  0;
	return;
}

void T_WPD_DATA::set_mopZi( short arg ){
	s_mopZi =  arg;
}

char* T_WPD_DATA::mou() const{
	return((char*)c_mou );
}

short T_WPD_DATA::mouZi() const{
	return( s_mouZi);
}

void T_WPD_DATA::set_mou( char* arg ){
	strncpy((char*)c_mou , arg , sizeof(c_mou));
	c_mou[sizeof(c_mou)-1] = '\0';
	s_mouZi=  0;
	return;
}

void T_WPD_DATA::set_mouZi( short arg ){
	s_mouZi =  arg;
}

// methodes for Primary key
char* T_WPD_DATA::k_entId(){
	return((char*)c_k_entId );
}

void T_WPD_DATA::set_k_entId( char* arg ){
	strncpy((char*)c_k_entId , arg , sizeof(c_k_entId));
	c_k_entId[sizeof(c_k_entId)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_WPD_DATA::fillStructure(){
	strncpy ( structTable.entId , entId(),sizeof(structTable.entId));
	strncpy ( structTable.pre_entId , pre_entId(),sizeof(structTable.pre_entId));
	strncpy ( structTable.WPDX_NAME[0] , WPDX_NAME(0),sizeof(structTable.WPDX_NAME[0]));
	strncpy ( structTable.WPDX_NAME[1] , WPDX_NAME(1),sizeof(structTable.WPDX_NAME[1]));
	strncpy ( structTable.WPDX_NAME[2] , WPDX_NAME(2),sizeof(structTable.WPDX_NAME[2]));
	strncpy ( structTable.WPDX_NAME[3] , WPDX_NAME(3),sizeof(structTable.WPDX_NAME[3]));
	strncpy ( structTable.WPDX_NAME[4] , WPDX_NAME(4),sizeof(structTable.WPDX_NAME[4]));
	strncpy ( structTable.WPDX_NAME[5] , WPDX_NAME(5),sizeof(structTable.WPDX_NAME[5]));
	structTable.WPDX[0] = WPDX(0);
	structTable.WPDX[1] = WPDX(1);
	structTable.WPDX[2] = WPDX(2);
	structTable.WPDX[3] = WPDX(3);
	structTable.WPDX[4] = WPDX(4);
	structTable.WPDX[5] = WPDX(5);
	strncpy ( structTable.toc , toc(),sizeof(structTable.toc));
	strncpy ( structTable.tom , tom(),sizeof(structTable.tom));
	strncpy ( structTable.mop , mop(),sizeof(structTable.mop));
	strncpy ( structTable.mou , mou(),sizeof(structTable.mou));
	return;
}
///////////////////////////////////////////////////
void T_WPD_DATA::fillStructureZi(){
	structTableZi.pre_entIdZi = pre_entIdZi();
	structTableZi.WPDX_NAMEZi[0] = WPDX_NAMEZi(0);
	structTableZi.WPDX_NAMEZi[1] = WPDX_NAMEZi(1);
	structTableZi.WPDX_NAMEZi[2] = WPDX_NAMEZi(2);
	structTableZi.WPDX_NAMEZi[3] = WPDX_NAMEZi(3);
	structTableZi.WPDX_NAMEZi[4] = WPDX_NAMEZi(4);
	structTableZi.WPDX_NAMEZi[5] = WPDX_NAMEZi(5);
	structTableZi.WPDXZi[0] = WPDXZi(0);
	structTableZi.WPDXZi[1] = WPDXZi(1);
	structTableZi.WPDXZi[2] = WPDXZi(2);
	structTableZi.WPDXZi[3] = WPDXZi(3);
	structTableZi.WPDXZi[4] = WPDXZi(4);
	structTableZi.WPDXZi[5] = WPDXZi(5);
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_WPD_DATA::setStructure() {
	set_pre_entId( structTable.pre_entId);
	set_WPDX_NAME( 0, structTable.WPDX_NAME[0]);
	set_WPDX_NAME( 1, structTable.WPDX_NAME[1]);
	set_WPDX_NAME( 2, structTable.WPDX_NAME[2]);
	set_WPDX_NAME( 3, structTable.WPDX_NAME[3]);
	set_WPDX_NAME( 4, structTable.WPDX_NAME[4]);
	set_WPDX_NAME( 5, structTable.WPDX_NAME[5]);
	set_WPDX( 0, structTable.WPDX[0]);
	set_WPDX( 1, structTable.WPDX[1]);
	set_WPDX( 2, structTable.WPDX[2]);
	set_WPDX( 3, structTable.WPDX[3]);
	set_WPDX( 4, structTable.WPDX[4]);
	set_WPDX( 5, structTable.WPDX[5]);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_WPD_DATA::setStructureZi() {
	set_pre_entIdZi( structTableZi.pre_entIdZi);
	set_WPDX_NAMEZi( 0, structTableZi.WPDX_NAMEZi[0]);
	set_WPDX_NAMEZi( 1, structTableZi.WPDX_NAMEZi[1]);
	set_WPDX_NAMEZi( 2, structTableZi.WPDX_NAMEZi[2]);
	set_WPDX_NAMEZi( 3, structTableZi.WPDX_NAMEZi[3]);
	set_WPDX_NAMEZi( 4, structTableZi.WPDX_NAMEZi[4]);
	set_WPDX_NAMEZi( 5, structTableZi.WPDX_NAMEZi[5]);
	set_WPDXZi( 0, structTableZi.WPDXZi[0]);
	set_WPDXZi( 1, structTableZi.WPDXZi[1]);
	set_WPDXZi( 2, structTableZi.WPDXZi[2]);
	set_WPDXZi( 3, structTableZi.WPDXZi[3]);
	set_WPDXZi( 4, structTableZi.WPDXZi[4]);
	set_WPDXZi( 5, structTableZi.WPDXZi[5]);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_WPD_DATA::getName(){
	return((char*)"T_WPD_DATA");
}
///////////////////////////////////////////////////
int T_WPD_DATA::getSqlCode(){
	return( db.dbSqlCode);
}
int T_WPD_DATA::getRowsProcessed(){
	return( db.dbRowsProcessed);
}