eis/src/dbax/T_ACT_LINE.cpp

// Version:		2015.2.25  14:8:45

// File: T_ACT_LINE.cpp

#include "T_ACT_LINE.h"

T_ACT_LINE::T_ACT_LINE(){
//  initialise all membervariables
	initial();
}
T_ACT_LINE::~T_ACT_LINE(){
}
void T_ACT_LINE::initial(){
//  initialise all membervariables
	set_Seq(0);
	set_EntSpeed(0);
	set_EntSpeedZi(-1);
	set_CntSpeed(0);
	set_CntSpeedZi(-1);
	set_ExtSpeed(0);
	set_ExtSpeedZi(-1);
	set_Looper(0,0);
	set_LooperZi(0,-1);
	set_Looper(1,0);
	set_LooperZi(1,-1);
	set_Looper(2,0);
	set_LooperZi(2,-1);
	set_PorLen(0,0);
	set_PorLenZi(0,-1);
	set_PorLen(1,0);
	set_PorLenZi(1,-1);
	set_PorDiam(0,0);
	set_PorDiamZi(0,-1);
	set_PorDiam(1,0);
	set_PorDiamZi(1,-1);
	set_TrLen(0,0);
	set_TrLenZi(0,-1);
	set_TrLen(1,0);
	set_TrLenZi(1,-1);
	set_TrDiam(0,0);
	set_TrDiamZi(0,-1);
	set_TrDiam(1,0);
	set_TrDiamZi(1,-1);
	set_toc("");
	set_tocZi(-1);
	set_tom("");
	set_tomZi(-1);
	set_mop("");
	set_mopZi(-1);
	set_mou("");
	set_mouZi(-1);
// initialies Primary key members
	set_k_Seq(0);
}
T_ACT_LINE::T_ACT_LINE(long arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_ACT_LINE::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_ACT_LINE
//
//	this methode stores the unique key attributes
//
void T_ACT_LINE::setPrimKey( long arg1 ){
	l_k_Seq = arg1;
} // end of methode

void T_ACT_LINE::initInsertKeys( long arg1 ){
	setPrimKey (  arg1);
	l_Seq = arg1;
} // end of methode
void T_ACT_LINE::setKeysFromRecord(){
	set_k_Seq( Seq() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_ACT_LINE T_ACT_LINE::operator+(const T_ACT_LINE &inst) const{
	T_ACT_LINE ptrT_ACT_LINE(*this);
//----------------------------------------------------------
	ptrT_ACT_LINE.set_Seq(inst.Seq());
//----------------------------------------------------------
	if(inst.EntSpeedZi() != -1){
		ptrT_ACT_LINE.set_EntSpeed(inst.EntSpeed());
		ptrT_ACT_LINE.set_EntSpeedZi(inst.EntSpeedZi());
	}
//----------------------------------------------------------
	if(inst.CntSpeedZi() != -1){
		ptrT_ACT_LINE.set_CntSpeed(inst.CntSpeed());
		ptrT_ACT_LINE.set_CntSpeedZi(inst.CntSpeedZi());
	}
//----------------------------------------------------------
	if(inst.ExtSpeedZi() != -1){
		ptrT_ACT_LINE.set_ExtSpeed(inst.ExtSpeed());
		ptrT_ACT_LINE.set_ExtSpeedZi(inst.ExtSpeedZi());
	}
//----------------------------------------------------------
	if(inst.LooperZi(0) != -1){
		ptrT_ACT_LINE.set_Looper(0,inst.Looper(0));
		ptrT_ACT_LINE.set_LooperZi(0,inst.LooperZi(0));
	}
//----------------------------------------------------------
	if(inst.LooperZi(1) != -1){
		ptrT_ACT_LINE.set_Looper(1,inst.Looper(1));
		ptrT_ACT_LINE.set_LooperZi(1,inst.LooperZi(1));
	}
//----------------------------------------------------------
	if(inst.LooperZi(2) != -1){
		ptrT_ACT_LINE.set_Looper(2,inst.Looper(2));
		ptrT_ACT_LINE.set_LooperZi(2,inst.LooperZi(2));
	}
//----------------------------------------------------------
	if(inst.PorLenZi(0) != -1){
		ptrT_ACT_LINE.set_PorLen(0,inst.PorLen(0));
		ptrT_ACT_LINE.set_PorLenZi(0,inst.PorLenZi(0));
	}
//----------------------------------------------------------
	if(inst.PorLenZi(1) != -1){
		ptrT_ACT_LINE.set_PorLen(1,inst.PorLen(1));
		ptrT_ACT_LINE.set_PorLenZi(1,inst.PorLenZi(1));
	}
//----------------------------------------------------------
	if(inst.PorDiamZi(0) != -1){
		ptrT_ACT_LINE.set_PorDiam(0,inst.PorDiam(0));
		ptrT_ACT_LINE.set_PorDiamZi(0,inst.PorDiamZi(0));
	}
//----------------------------------------------------------
	if(inst.PorDiamZi(1) != -1){
		ptrT_ACT_LINE.set_PorDiam(1,inst.PorDiam(1));
		ptrT_ACT_LINE.set_PorDiamZi(1,inst.PorDiamZi(1));
	}
//----------------------------------------------------------
	if(inst.TrLenZi(0) != -1){
		ptrT_ACT_LINE.set_TrLen(0,inst.TrLen(0));
		ptrT_ACT_LINE.set_TrLenZi(0,inst.TrLenZi(0));
	}
//----------------------------------------------------------
	if(inst.TrLenZi(1) != -1){
		ptrT_ACT_LINE.set_TrLen(1,inst.TrLen(1));
		ptrT_ACT_LINE.set_TrLenZi(1,inst.TrLenZi(1));
	}
//----------------------------------------------------------
	if(inst.TrDiamZi(0) != -1){
		ptrT_ACT_LINE.set_TrDiam(0,inst.TrDiam(0));
		ptrT_ACT_LINE.set_TrDiamZi(0,inst.TrDiamZi(0));
	}
//----------------------------------------------------------
	if(inst.TrDiamZi(1) != -1){
		ptrT_ACT_LINE.set_TrDiam(1,inst.TrDiam(1));
		ptrT_ACT_LINE.set_TrDiamZi(1,inst.TrDiamZi(1));
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_ACT_LINE.set_toc(inst.toc());
		ptrT_ACT_LINE.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_ACT_LINE.set_tom(inst.tom());
		ptrT_ACT_LINE.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_ACT_LINE.set_mop(inst.mop());
		ptrT_ACT_LINE.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_ACT_LINE.set_mou(inst.mou());
		ptrT_ACT_LINE.set_mouZi(inst.mouZi());
	}
	return (ptrT_ACT_LINE);
}

//
//O P E R A T O R  = 
//===================
//
const T_ACT_LINE& T_ACT_LINE::operator=(const T_ACT_LINE &inst){
//----------------------------------------------------------
	this->set_Seq(inst.Seq());
//----------------------------------------------------------
	this->set_EntSpeed(inst.EntSpeed());
	this->set_EntSpeedZi(inst.EntSpeedZi());
//----------------------------------------------------------
	this->set_CntSpeed(inst.CntSpeed());
	this->set_CntSpeedZi(inst.CntSpeedZi());
//----------------------------------------------------------
	this->set_ExtSpeed(inst.ExtSpeed());
	this->set_ExtSpeedZi(inst.ExtSpeedZi());
//----------------------------------------------------------
	this->set_Looper(0,inst.Looper(0));
	this->set_LooperZi(0,inst.LooperZi(0));
//----------------------------------------------------------
	this->set_Looper(1,inst.Looper(1));
	this->set_LooperZi(1,inst.LooperZi(1));
//----------------------------------------------------------
	this->set_Looper(2,inst.Looper(2));
	this->set_LooperZi(2,inst.LooperZi(2));
//----------------------------------------------------------
	this->set_PorLen(0,inst.PorLen(0));
	this->set_PorLenZi(0,inst.PorLenZi(0));
//----------------------------------------------------------
	this->set_PorLen(1,inst.PorLen(1));
	this->set_PorLenZi(1,inst.PorLenZi(1));
//----------------------------------------------------------
	this->set_PorDiam(0,inst.PorDiam(0));
	this->set_PorDiamZi(0,inst.PorDiamZi(0));
//----------------------------------------------------------
	this->set_PorDiam(1,inst.PorDiam(1));
	this->set_PorDiamZi(1,inst.PorDiamZi(1));
//----------------------------------------------------------
	this->set_TrLen(0,inst.TrLen(0));
	this->set_TrLenZi(0,inst.TrLenZi(0));
//----------------------------------------------------------
	this->set_TrLen(1,inst.TrLen(1));
	this->set_TrLenZi(1,inst.TrLenZi(1));
//----------------------------------------------------------
	this->set_TrDiam(0,inst.TrDiam(0));
	this->set_TrDiamZi(0,inst.TrDiamZi(0));
//----------------------------------------------------------
	this->set_TrDiam(1,inst.TrDiam(1));
	this->set_TrDiamZi(1,inst.TrDiamZi(1));
//----------------------------------------------------------
	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_ACT_LINE::T_ACT_LINE(const T_ACT_LINE &inst){
//----------------------------------------------------------
	this->set_Seq(inst.Seq());
//----------------------------------------------------------
	this->set_EntSpeed(inst.EntSpeed());
	this->set_EntSpeedZi(inst.EntSpeedZi());
//----------------------------------------------------------
	this->set_CntSpeed(inst.CntSpeed());
	this->set_CntSpeedZi(inst.CntSpeedZi());
//----------------------------------------------------------
	this->set_ExtSpeed(inst.ExtSpeed());
	this->set_ExtSpeedZi(inst.ExtSpeedZi());
//----------------------------------------------------------
	this->set_Looper(0,inst.Looper(0));
	this->set_LooperZi(0,inst.LooperZi(0));
//----------------------------------------------------------
	this->set_Looper(1,inst.Looper(1));
	this->set_LooperZi(1,inst.LooperZi(1));
//----------------------------------------------------------
	this->set_Looper(2,inst.Looper(2));
	this->set_LooperZi(2,inst.LooperZi(2));
//----------------------------------------------------------
	this->set_PorLen(0,inst.PorLen(0));
	this->set_PorLenZi(0,inst.PorLenZi(0));
//----------------------------------------------------------
	this->set_PorLen(1,inst.PorLen(1));
	this->set_PorLenZi(1,inst.PorLenZi(1));
//----------------------------------------------------------
	this->set_PorDiam(0,inst.PorDiam(0));
	this->set_PorDiamZi(0,inst.PorDiamZi(0));
//----------------------------------------------------------
	this->set_PorDiam(1,inst.PorDiam(1));
	this->set_PorDiamZi(1,inst.PorDiamZi(1));
//----------------------------------------------------------
	this->set_TrLen(0,inst.TrLen(0));
	this->set_TrLenZi(0,inst.TrLenZi(0));
//----------------------------------------------------------
	this->set_TrLen(1,inst.TrLen(1));
	this->set_TrLenZi(1,inst.TrLenZi(1));
//----------------------------------------------------------
	this->set_TrDiam(0,inst.TrDiam(0));
	this->set_TrDiamZi(0,inst.TrDiamZi(0));
//----------------------------------------------------------
	this->set_TrDiam(1,inst.TrDiam(1));
	this->set_TrDiamZi(1,inst.TrDiamZi(1));
//----------------------------------------------------------
	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());
}
long T_ACT_LINE::Seq() const{
	return((long)l_Seq );
}


void T_ACT_LINE::set_Seq( long arg ){ 
	l_Seq = arg;
	return;
}


long T_ACT_LINE::EntSpeed() const{
	return((long)l_EntSpeed );
}

short T_ACT_LINE::EntSpeedZi() const{
	return( s_EntSpeedZi);
}

void T_ACT_LINE::set_EntSpeed( long arg ){ 
	l_EntSpeed = arg;
	s_EntSpeedZi=  0;
	return;
}

void T_ACT_LINE::set_EntSpeedZi( short arg ) {
	s_EntSpeedZi =  arg;
}

long T_ACT_LINE::CntSpeed() const{
	return((long)l_CntSpeed );
}

short T_ACT_LINE::CntSpeedZi() const{
	return( s_CntSpeedZi);
}

void T_ACT_LINE::set_CntSpeed( long arg ){ 
	l_CntSpeed = arg;
	s_CntSpeedZi=  0;
	return;
}

void T_ACT_LINE::set_CntSpeedZi( short arg ) {
	s_CntSpeedZi =  arg;
}

long T_ACT_LINE::ExtSpeed() const{
	return((long)l_ExtSpeed );
}

short T_ACT_LINE::ExtSpeedZi() const{
	return( s_ExtSpeedZi);
}

void T_ACT_LINE::set_ExtSpeed( long arg ){ 
	l_ExtSpeed = arg;
	s_ExtSpeedZi=  0;
	return;
}

void T_ACT_LINE::set_ExtSpeedZi( short arg ) {
	s_ExtSpeedZi =  arg;
}

int T_ACT_LINE::LooperArraySize(){
	return(3);
}

long T_ACT_LINE::Looper(int colInd) const{
	return((long)l_Looper[colInd] );
}

short T_ACT_LINE::LooperZi(int colInd) const{
	return( s_LooperZi[colInd]);
}

void T_ACT_LINE::set_Looper( int colInd, long arg ){ 
	l_Looper[colInd] = arg;
	s_LooperZi[colInd]=  0;
	return;
}

void T_ACT_LINE::set_LooperZi( int colInd, short arg ) {
	s_LooperZi[colInd] =  arg;
}

int T_ACT_LINE::PorLenArraySize(){
	return(2);
}

long T_ACT_LINE::PorLen(int colInd) const{
	return((long)l_PorLen[colInd] );
}

short T_ACT_LINE::PorLenZi(int colInd) const{
	return( s_PorLenZi[colInd]);
}

void T_ACT_LINE::set_PorLen( int colInd, long arg ){ 
	l_PorLen[colInd] = arg;
	s_PorLenZi[colInd]=  0;
	return;
}

void T_ACT_LINE::set_PorLenZi( int colInd, short arg ) {
	s_PorLenZi[colInd] =  arg;
}

int T_ACT_LINE::PorDiamArraySize(){
	return(2);
}

long T_ACT_LINE::PorDiam(int colInd) const{
	return((long)l_PorDiam[colInd] );
}

short T_ACT_LINE::PorDiamZi(int colInd) const{
	return( s_PorDiamZi[colInd]);
}

void T_ACT_LINE::set_PorDiam( int colInd, long arg ){ 
	l_PorDiam[colInd] = arg;
	s_PorDiamZi[colInd]=  0;
	return;
}

void T_ACT_LINE::set_PorDiamZi( int colInd, short arg ) {
	s_PorDiamZi[colInd] =  arg;
}

int T_ACT_LINE::TrLenArraySize(){
	return(2);
}

long T_ACT_LINE::TrLen(int colInd) const{
	return((long)l_TrLen[colInd] );
}

short T_ACT_LINE::TrLenZi(int colInd) const{
	return( s_TrLenZi[colInd]);
}

void T_ACT_LINE::set_TrLen( int colInd, long arg ){ 
	l_TrLen[colInd] = arg;
	s_TrLenZi[colInd]=  0;
	return;
}

void T_ACT_LINE::set_TrLenZi( int colInd, short arg ) {
	s_TrLenZi[colInd] =  arg;
}

int T_ACT_LINE::TrDiamArraySize(){
	return(2);
}

long T_ACT_LINE::TrDiam(int colInd) const{
	return((long)l_TrDiam[colInd] );
}

short T_ACT_LINE::TrDiamZi(int colInd) const{
	return( s_TrDiamZi[colInd]);
}

void T_ACT_LINE::set_TrDiam( int colInd, long arg ){ 
	l_TrDiam[colInd] = arg;
	s_TrDiamZi[colInd]=  0;
	return;
}

void T_ACT_LINE::set_TrDiamZi( int colInd, short arg ) {
	s_TrDiamZi[colInd] =  arg;
}

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

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

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

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

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

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

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

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

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

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

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

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

// methodes for Primary key
long T_ACT_LINE::k_Seq(){
	return((long)l_k_Seq );
}

void T_ACT_LINE::set_k_Seq( long arg ){
	l_k_Seq =  arg;
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_ACT_LINE::fillStructure(){
	structTable.Seq = Seq();
	structTable.EntSpeed = EntSpeed();
	structTable.CntSpeed = CntSpeed();
	structTable.ExtSpeed = ExtSpeed();
	structTable.Looper[0] = Looper(0);
	structTable.Looper[1] = Looper(1);
	structTable.Looper[2] = Looper(2);
	structTable.PorLen[0] = PorLen(0);
	structTable.PorLen[1] = PorLen(1);
	structTable.PorDiam[0] = PorDiam(0);
	structTable.PorDiam[1] = PorDiam(1);
	structTable.TrLen[0] = TrLen(0);
	structTable.TrLen[1] = TrLen(1);
	structTable.TrDiam[0] = TrDiam(0);
	structTable.TrDiam[1] = TrDiam(1);
	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_ACT_LINE::fillStructureZi(){
	structTableZi.EntSpeedZi = EntSpeedZi();
	structTableZi.CntSpeedZi = CntSpeedZi();
	structTableZi.ExtSpeedZi = ExtSpeedZi();
	structTableZi.LooperZi[0] = LooperZi(0);
	structTableZi.LooperZi[1] = LooperZi(1);
	structTableZi.LooperZi[2] = LooperZi(2);
	structTableZi.PorLenZi[0] = PorLenZi(0);
	structTableZi.PorLenZi[1] = PorLenZi(1);
	structTableZi.PorDiamZi[0] = PorDiamZi(0);
	structTableZi.PorDiamZi[1] = PorDiamZi(1);
	structTableZi.TrLenZi[0] = TrLenZi(0);
	structTableZi.TrLenZi[1] = TrLenZi(1);
	structTableZi.TrDiamZi[0] = TrDiamZi(0);
	structTableZi.TrDiamZi[1] = TrDiamZi(1);
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_ACT_LINE::setStructure() {
	set_EntSpeed( structTable.EntSpeed);
	set_CntSpeed( structTable.CntSpeed);
	set_ExtSpeed( structTable.ExtSpeed);
	set_Looper( 0, structTable.Looper[0]);
	set_Looper( 1, structTable.Looper[1]);
	set_Looper( 2, structTable.Looper[2]);
	set_PorLen( 0, structTable.PorLen[0]);
	set_PorLen( 1, structTable.PorLen[1]);
	set_PorDiam( 0, structTable.PorDiam[0]);
	set_PorDiam( 1, structTable.PorDiam[1]);
	set_TrLen( 0, structTable.TrLen[0]);
	set_TrLen( 1, structTable.TrLen[1]);
	set_TrDiam( 0, structTable.TrDiam[0]);
	set_TrDiam( 1, structTable.TrDiam[1]);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_ACT_LINE::setStructureZi() {
	set_EntSpeedZi( structTableZi.EntSpeedZi);
	set_CntSpeedZi( structTableZi.CntSpeedZi);
	set_ExtSpeedZi( structTableZi.ExtSpeedZi);
	set_LooperZi( 0, structTableZi.LooperZi[0]);
	set_LooperZi( 1, structTableZi.LooperZi[1]);
	set_LooperZi( 2, structTableZi.LooperZi[2]);
	set_PorLenZi( 0, structTableZi.PorLenZi[0]);
	set_PorLenZi( 1, structTableZi.PorLenZi[1]);
	set_PorDiamZi( 0, structTableZi.PorDiamZi[0]);
	set_PorDiamZi( 1, structTableZi.PorDiamZi[1]);
	set_TrLenZi( 0, structTableZi.TrLenZi[0]);
	set_TrLenZi( 1, structTableZi.TrLenZi[1]);
	set_TrDiamZi( 0, structTableZi.TrDiamZi[0]);
	set_TrDiamZi( 1, structTableZi.TrDiamZi[1]);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_ACT_LINE::getName(){
	return("T_ACT_LINE");
}
///////////////////////////////////////////////////
int T_ACT_LINE::getSqlCode(){
	return( db.dbSqlCode);
}
int T_ACT_LINE::getRowsProcessed(){
	return( db.dbRowsProcessed);
}