// Version:		2021.3.25  16:25:20

// File: T_PDO_RULE.cpp

#include "T_PDO_RULE.h"

T_PDO_RULE::T_PDO_RULE(){
//  initialise all membervariables
	initial();
}
T_PDO_RULE::~T_PDO_RULE(){
}
void T_PDO_RULE::initial(){
//  initialise all membervariables
	set_RuleId((char*)"");
	set_stime((char*)"");
	set_entId((char*)"");
	set_entIdZi(-1);
	set_start(0);
	set_startZi(-1);
	set_end(0);
	set_endZi(-1);
	set_speed(0.0);
	set_speedZi(-1);
	set_tension(0.0);
	set_tensionZi(-1);
	set_current(0.0);
	set_currentZi(-1);
	set_nspare1(0.0);
	set_nspare1Zi(-1);
	set_nspare2(0.0);
	set_nspare2Zi(-1);
	set_nspare3(0.0);
	set_nspare3Zi(-1);
	set_nspare4(0.0);
	set_nspare4Zi(-1);
	set_nspare5(0.0);
	set_nspare5Zi(-1);
	set_nspare6(0.0);
	set_nspare6Zi(-1);
	set_nspare7(0.0);
	set_nspare7Zi(-1);
	set_nspare8(0.0);
	set_nspare8Zi(-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_RuleId((char*)"");
	set_k_stime((char*)"");
}
T_PDO_RULE::T_PDO_RULE(const char* arg1,char* arg2)
{
	initial();
	setPrimKey (arg1, arg2);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_PDO_RULE::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_PDO_RULE
//
//	this methode stores the unique key attributes
//
void T_PDO_RULE::setPrimKey( const char* arg1 , char* arg2 ){
	strncpy( (char*)c_k_RuleId , arg1 , sizeof(c_k_RuleId) );
	c_k_RuleId[sizeof(c_k_RuleId)-1] = '\0';
	strncpy( (char*)c_k_stime , arg2 , sizeof(c_k_stime) );
	c_k_stime[sizeof(c_k_stime)-1] = '\0';
} // end of methode

void T_PDO_RULE::initInsertKeys( const char* arg1 , char* arg2 ){
	setPrimKey (  arg1 , arg2);
	strncpy( (char*)c_RuleId , arg1 , sizeof(c_RuleId) );
	c_RuleId[sizeof(c_RuleId)-1] = '\0';
	strncpy( (char*)c_stime , arg2 , sizeof(c_stime) );
	c_stime[sizeof(c_stime)-1] = '\0';
} // end of methode
void T_PDO_RULE::setKeysFromRecord(){
	set_k_RuleId( RuleId() );
	set_k_stime( stime() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_PDO_RULE T_PDO_RULE::operator+(const T_PDO_RULE &inst) const{
	T_PDO_RULE ptrT_PDO_RULE(*this);
//----------------------------------------------------------
	ptrT_PDO_RULE.set_RuleId(inst.RuleId());
//----------------------------------------------------------
	ptrT_PDO_RULE.set_stime(inst.stime());
//----------------------------------------------------------
	if(inst.entIdZi() != -1){
		ptrT_PDO_RULE.set_entId(inst.entId());
		ptrT_PDO_RULE.set_entIdZi(inst.entIdZi());
	}
//----------------------------------------------------------
	if(inst.startZi() != -1){
		ptrT_PDO_RULE.set_start(inst.start());
		ptrT_PDO_RULE.set_startZi(inst.startZi());
	}
//----------------------------------------------------------
	if(inst.endZi() != -1){
		ptrT_PDO_RULE.set_end(inst.end());
		ptrT_PDO_RULE.set_endZi(inst.endZi());
	}
//----------------------------------------------------------
	if(inst.speedZi() != -1){
		ptrT_PDO_RULE.set_speed(inst.speed());
		ptrT_PDO_RULE.set_speedZi(inst.speedZi());
	}
//----------------------------------------------------------
	if(inst.tensionZi() != -1){
		ptrT_PDO_RULE.set_tension(inst.tension());
		ptrT_PDO_RULE.set_tensionZi(inst.tensionZi());
	}
//----------------------------------------------------------
	if(inst.currentZi() != -1){
		ptrT_PDO_RULE.set_current(inst.current());
		ptrT_PDO_RULE.set_currentZi(inst.currentZi());
	}
//----------------------------------------------------------
	if(inst.nspare1Zi() != -1){
		ptrT_PDO_RULE.set_nspare1(inst.nspare1());
		ptrT_PDO_RULE.set_nspare1Zi(inst.nspare1Zi());
	}
//----------------------------------------------------------
	if(inst.nspare2Zi() != -1){
		ptrT_PDO_RULE.set_nspare2(inst.nspare2());
		ptrT_PDO_RULE.set_nspare2Zi(inst.nspare2Zi());
	}
//----------------------------------------------------------
	if(inst.nspare3Zi() != -1){
		ptrT_PDO_RULE.set_nspare3(inst.nspare3());
		ptrT_PDO_RULE.set_nspare3Zi(inst.nspare3Zi());
	}
//----------------------------------------------------------
	if(inst.nspare4Zi() != -1){
		ptrT_PDO_RULE.set_nspare4(inst.nspare4());
		ptrT_PDO_RULE.set_nspare4Zi(inst.nspare4Zi());
	}
//----------------------------------------------------------
	if(inst.nspare5Zi() != -1){
		ptrT_PDO_RULE.set_nspare5(inst.nspare5());
		ptrT_PDO_RULE.set_nspare5Zi(inst.nspare5Zi());
	}
//----------------------------------------------------------
	if(inst.nspare6Zi() != -1){
		ptrT_PDO_RULE.set_nspare6(inst.nspare6());
		ptrT_PDO_RULE.set_nspare6Zi(inst.nspare6Zi());
	}
//----------------------------------------------------------
	if(inst.nspare7Zi() != -1){
		ptrT_PDO_RULE.set_nspare7(inst.nspare7());
		ptrT_PDO_RULE.set_nspare7Zi(inst.nspare7Zi());
	}
//----------------------------------------------------------
	if(inst.nspare8Zi() != -1){
		ptrT_PDO_RULE.set_nspare8(inst.nspare8());
		ptrT_PDO_RULE.set_nspare8Zi(inst.nspare8Zi());
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_PDO_RULE.set_toc(inst.toc());
		ptrT_PDO_RULE.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_PDO_RULE.set_tom(inst.tom());
		ptrT_PDO_RULE.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_PDO_RULE.set_mop(inst.mop());
		ptrT_PDO_RULE.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_PDO_RULE.set_mou(inst.mou());
		ptrT_PDO_RULE.set_mouZi(inst.mouZi());
	}
	return (ptrT_PDO_RULE);
}

//
//O P E R A T O R  = 
//===================
//
const T_PDO_RULE& T_PDO_RULE::operator=(const T_PDO_RULE &inst){
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_stime(inst.stime());
//----------------------------------------------------------
	this->set_entId(inst.entId());
	this->set_entIdZi(inst.entIdZi());
//----------------------------------------------------------
	this->set_start(inst.start());
	this->set_startZi(inst.startZi());
//----------------------------------------------------------
	this->set_end(inst.end());
	this->set_endZi(inst.endZi());
//----------------------------------------------------------
	this->set_speed(inst.speed());
	this->set_speedZi(inst.speedZi());
//----------------------------------------------------------
	this->set_tension(inst.tension());
	this->set_tensionZi(inst.tensionZi());
//----------------------------------------------------------
	this->set_current(inst.current());
	this->set_currentZi(inst.currentZi());
//----------------------------------------------------------
	this->set_nspare1(inst.nspare1());
	this->set_nspare1Zi(inst.nspare1Zi());
//----------------------------------------------------------
	this->set_nspare2(inst.nspare2());
	this->set_nspare2Zi(inst.nspare2Zi());
//----------------------------------------------------------
	this->set_nspare3(inst.nspare3());
	this->set_nspare3Zi(inst.nspare3Zi());
//----------------------------------------------------------
	this->set_nspare4(inst.nspare4());
	this->set_nspare4Zi(inst.nspare4Zi());
//----------------------------------------------------------
	this->set_nspare5(inst.nspare5());
	this->set_nspare5Zi(inst.nspare5Zi());
//----------------------------------------------------------
	this->set_nspare6(inst.nspare6());
	this->set_nspare6Zi(inst.nspare6Zi());
//----------------------------------------------------------
	this->set_nspare7(inst.nspare7());
	this->set_nspare7Zi(inst.nspare7Zi());
//----------------------------------------------------------
	this->set_nspare8(inst.nspare8());
	this->set_nspare8Zi(inst.nspare8Zi());
//----------------------------------------------------------
	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_PDO_RULE::T_PDO_RULE(const T_PDO_RULE &inst){
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_stime(inst.stime());
//----------------------------------------------------------
	this->set_entId(inst.entId());
	this->set_entIdZi(inst.entIdZi());
//----------------------------------------------------------
	this->set_start(inst.start());
	this->set_startZi(inst.startZi());
//----------------------------------------------------------
	this->set_end(inst.end());
	this->set_endZi(inst.endZi());
//----------------------------------------------------------
	this->set_speed(inst.speed());
	this->set_speedZi(inst.speedZi());
//----------------------------------------------------------
	this->set_tension(inst.tension());
	this->set_tensionZi(inst.tensionZi());
//----------------------------------------------------------
	this->set_current(inst.current());
	this->set_currentZi(inst.currentZi());
//----------------------------------------------------------
	this->set_nspare1(inst.nspare1());
	this->set_nspare1Zi(inst.nspare1Zi());
//----------------------------------------------------------
	this->set_nspare2(inst.nspare2());
	this->set_nspare2Zi(inst.nspare2Zi());
//----------------------------------------------------------
	this->set_nspare3(inst.nspare3());
	this->set_nspare3Zi(inst.nspare3Zi());
//----------------------------------------------------------
	this->set_nspare4(inst.nspare4());
	this->set_nspare4Zi(inst.nspare4Zi());
//----------------------------------------------------------
	this->set_nspare5(inst.nspare5());
	this->set_nspare5Zi(inst.nspare5Zi());
//----------------------------------------------------------
	this->set_nspare6(inst.nspare6());
	this->set_nspare6Zi(inst.nspare6Zi());
//----------------------------------------------------------
	this->set_nspare7(inst.nspare7());
	this->set_nspare7Zi(inst.nspare7Zi());
//----------------------------------------------------------
	this->set_nspare8(inst.nspare8());
	this->set_nspare8Zi(inst.nspare8Zi());
//----------------------------------------------------------
	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_PDO_RULE::RuleId() const{
	return((char*)c_RuleId );
}


void T_PDO_RULE::set_RuleId( const char* arg ){ 
	strncpy((char*)c_RuleId , arg , sizeof(c_RuleId));
	c_RuleId[sizeof(c_RuleId)-1] = '\0';
	return;
}


char* T_PDO_RULE::stime() const{
	return((char*)c_stime );
}


void T_PDO_RULE::set_stime( char* arg ){ 
	strncpy((char*)c_stime , arg , sizeof(c_stime));
	c_stime[sizeof(c_stime)-1] = '\0';
	return;
}


char* T_PDO_RULE::entId() const{
	return((char*)c_entId );
}

short T_PDO_RULE::entIdZi() const{
	return( s_entIdZi);
}

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

void T_PDO_RULE::set_entIdZi( short arg ) {
	s_entIdZi =  arg;
}

long T_PDO_RULE::start() const{
	return((long)l_start );
}

short T_PDO_RULE::startZi() const{
	return( s_startZi);
}

void T_PDO_RULE::set_start( long arg ){ 
	l_start = arg;
	s_startZi=  0;
	return;
}

void T_PDO_RULE::set_startZi( short arg ) {
	s_startZi =  arg;
}

long T_PDO_RULE::end() const{
	return((long)l_end );
}

short T_PDO_RULE::endZi() const{
	return( s_endZi);
}

void T_PDO_RULE::set_end( long arg ){ 
	l_end = arg;
	s_endZi=  0;
	return;
}

void T_PDO_RULE::set_endZi( short arg ) {
	s_endZi =  arg;
}

double T_PDO_RULE::speed() const{
	return((double)d_speed );
}

short T_PDO_RULE::speedZi() const{
	return( s_speedZi);
}

void T_PDO_RULE::set_speed( double arg ){ 
	d_speed = arg;
	s_speedZi=  0;
	return;
}

void T_PDO_RULE::set_speedZi( short arg ) {
	s_speedZi =  arg;
}

double T_PDO_RULE::tension() const{
	return((double)d_tension );
}

short T_PDO_RULE::tensionZi() const{
	return( s_tensionZi);
}

void T_PDO_RULE::set_tension( double arg ){ 
	d_tension = arg;
	s_tensionZi=  0;
	return;
}

void T_PDO_RULE::set_tensionZi( short arg ) {
	s_tensionZi =  arg;
}

double T_PDO_RULE::current() const{
	return((double)d_current );
}

short T_PDO_RULE::currentZi() const{
	return( s_currentZi);
}

void T_PDO_RULE::set_current( double arg ){ 
	d_current = arg;
	s_currentZi=  0;
	return;
}

void T_PDO_RULE::set_currentZi( short arg ) {
	s_currentZi =  arg;
}

double T_PDO_RULE::nspare1() const{
	return((double)d_nspare1 );
}

short T_PDO_RULE::nspare1Zi() const{
	return( s_nspare1Zi);
}

void T_PDO_RULE::set_nspare1( double arg ){ 
	d_nspare1 = arg;
	s_nspare1Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare1Zi( short arg ) {
	s_nspare1Zi =  arg;
}

double T_PDO_RULE::nspare2() const{
	return((double)d_nspare2 );
}

short T_PDO_RULE::nspare2Zi() const{
	return( s_nspare2Zi);
}

void T_PDO_RULE::set_nspare2( double arg ){ 
	d_nspare2 = arg;
	s_nspare2Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare2Zi( short arg ) {
	s_nspare2Zi =  arg;
}

double T_PDO_RULE::nspare3() const{
	return((double)d_nspare3 );
}

short T_PDO_RULE::nspare3Zi() const{
	return( s_nspare3Zi);
}

void T_PDO_RULE::set_nspare3( double arg ){ 
	d_nspare3 = arg;
	s_nspare3Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare3Zi( short arg ) {
	s_nspare3Zi =  arg;
}

double T_PDO_RULE::nspare4() const{
	return((double)d_nspare4 );
}

short T_PDO_RULE::nspare4Zi() const{
	return( s_nspare4Zi);
}

void T_PDO_RULE::set_nspare4( double arg ){ 
	d_nspare4 = arg;
	s_nspare4Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare4Zi( short arg ) {
	s_nspare4Zi =  arg;
}

double T_PDO_RULE::nspare5() const{
	return((double)d_nspare5 );
}

short T_PDO_RULE::nspare5Zi() const{
	return( s_nspare5Zi);
}

void T_PDO_RULE::set_nspare5( double arg ){ 
	d_nspare5 = arg;
	s_nspare5Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare5Zi( short arg ) {
	s_nspare5Zi =  arg;
}

double T_PDO_RULE::nspare6() const{
	return((double)d_nspare6 );
}

short T_PDO_RULE::nspare6Zi() const{
	return( s_nspare6Zi);
}

void T_PDO_RULE::set_nspare6( double arg ){ 
	d_nspare6 = arg;
	s_nspare6Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare6Zi( short arg ) {
	s_nspare6Zi =  arg;
}

double T_PDO_RULE::nspare7() const{
	return((double)d_nspare7 );
}

short T_PDO_RULE::nspare7Zi() const{
	return( s_nspare7Zi);
}

void T_PDO_RULE::set_nspare7( double arg ){ 
	d_nspare7 = arg;
	s_nspare7Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare7Zi( short arg ) {
	s_nspare7Zi =  arg;
}

double T_PDO_RULE::nspare8() const{
	return((double)d_nspare8 );
}

short T_PDO_RULE::nspare8Zi() const{
	return( s_nspare8Zi);
}

void T_PDO_RULE::set_nspare8( double arg ){ 
	d_nspare8 = arg;
	s_nspare8Zi=  0;
	return;
}

void T_PDO_RULE::set_nspare8Zi( short arg ) {
	s_nspare8Zi =  arg;
}

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

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

void T_PDO_RULE::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_PDO_RULE::set_tocZi( short arg ){
	s_tocZi =  arg;
}

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

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

void T_PDO_RULE::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_PDO_RULE::set_tomZi( short arg ){
	s_tomZi =  arg;
}

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

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

void T_PDO_RULE::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_PDO_RULE::set_mopZi( short arg ){
	s_mopZi =  arg;
}

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

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

void T_PDO_RULE::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_PDO_RULE::set_mouZi( short arg ){
	s_mouZi =  arg;
}

// methodes for Primary key
char* T_PDO_RULE::k_RuleId(){
	return((char*)c_k_RuleId );
}

void T_PDO_RULE::set_k_RuleId( char* arg ){
	strncpy((char*)c_k_RuleId , arg , sizeof(c_k_RuleId));
	c_k_RuleId[sizeof(c_k_RuleId)-1] = '\0';
	return;
}

char* T_PDO_RULE::k_stime(){
	return((char*)c_k_stime );
}

void T_PDO_RULE::set_k_stime( char* arg ){
	strncpy((char*)c_k_stime , arg , sizeof(c_k_stime));
	c_k_stime[sizeof(c_k_stime)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_PDO_RULE::fillStructure(){
	strncpy ( structTable.RuleId , RuleId(),sizeof(structTable.RuleId));
	strncpy ( structTable.stime , stime(),sizeof(structTable.stime));
	strncpy ( structTable.entId , entId(),sizeof(structTable.entId));
	structTable.start = start();
	structTable.end = end();
	structTable.speed = speed();
	structTable.tension = tension();
	structTable.current = current();
	structTable.nspare1 = nspare1();
	structTable.nspare2 = nspare2();
	structTable.nspare3 = nspare3();
	structTable.nspare4 = nspare4();
	structTable.nspare5 = nspare5();
	structTable.nspare6 = nspare6();
	structTable.nspare7 = nspare7();
	structTable.nspare8 = nspare8();
	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_PDO_RULE::fillStructureZi(){
	structTableZi.entIdZi = entIdZi();
	structTableZi.startZi = startZi();
	structTableZi.endZi = endZi();
	structTableZi.speedZi = speedZi();
	structTableZi.tensionZi = tensionZi();
	structTableZi.currentZi = currentZi();
	structTableZi.nspare1Zi = nspare1Zi();
	structTableZi.nspare2Zi = nspare2Zi();
	structTableZi.nspare3Zi = nspare3Zi();
	structTableZi.nspare4Zi = nspare4Zi();
	structTableZi.nspare5Zi = nspare5Zi();
	structTableZi.nspare6Zi = nspare6Zi();
	structTableZi.nspare7Zi = nspare7Zi();
	structTableZi.nspare8Zi = nspare8Zi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_PDO_RULE::setStructure() {
	set_entId( structTable.entId);
	set_start( structTable.start);
	set_end( structTable.end);
	set_speed( structTable.speed);
	set_tension( structTable.tension);
	set_current( structTable.current);
	set_nspare1( structTable.nspare1);
	set_nspare2( structTable.nspare2);
	set_nspare3( structTable.nspare3);
	set_nspare4( structTable.nspare4);
	set_nspare5( structTable.nspare5);
	set_nspare6( structTable.nspare6);
	set_nspare7( structTable.nspare7);
	set_nspare8( structTable.nspare8);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_PDO_RULE::setStructureZi() {
	set_entIdZi( structTableZi.entIdZi);
	set_startZi( structTableZi.startZi);
	set_endZi( structTableZi.endZi);
	set_speedZi( structTableZi.speedZi);
	set_tensionZi( structTableZi.tensionZi);
	set_currentZi( structTableZi.currentZi);
	set_nspare1Zi( structTableZi.nspare1Zi);
	set_nspare2Zi( structTableZi.nspare2Zi);
	set_nspare3Zi( structTableZi.nspare3Zi);
	set_nspare4Zi( structTableZi.nspare4Zi);
	set_nspare5Zi( structTableZi.nspare5Zi);
	set_nspare6Zi( structTableZi.nspare6Zi);
	set_nspare7Zi( structTableZi.nspare7Zi);
	set_nspare8Zi( structTableZi.nspare8Zi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_PDO_RULE::getName(){
	return((char*)"T_PDO_RULE");
}
///////////////////////////////////////////////////
int T_PDO_RULE::getSqlCode(){
	return( db.dbSqlCode);
}
int T_PDO_RULE::getRowsProcessed(){
	return( db.dbRowsProcessed);
}