// Version:		2014.7.30  16:47:28

// File: T_TRK_REJECT.cpp

#include "T_TRK_REJECT.h"

T_TRK_REJECT::T_TRK_REJECT(){
//  initialise all membervariables
	initial();
}
T_TRK_REJECT::~T_TRK_REJECT(){
}
void T_TRK_REJECT::initial(){
//  initialise all membervariables
	set_location(0);
	set_locationZi(-1);
	set_dateTime("");
	set_dateTimeZi(-1);
	set_ReasonCode("");
	set_ReasonCodeZi(-1);
	set_reason("");
	set_reasonZi(-1);
	set_remark("");
	set_remarkZi(-1);
	set_L3AckFlag(0);
	set_L3AckFlagZi(-1);
	set_RejectFlag("");
	set_RejectFlagZi(-1);
	set_RejectCoilId("");
	set_RejectCoilIdZi(-1);
	set_HoldFlag("");
	set_HoldFlagZi(-1);
	set_UserId("");
	set_UserIdZi(-1);
	set_EntCoilId("");
	set_EntCoilIdZi(-1);
	set_FinalSign(0);
	set_FinalSignZi(-1);
	set_muId(0);
	set_muCreator("");
	set_musId(0);
	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_muId(0);
	set_k_muCreator("");
	set_k_musId(0);
}
T_TRK_REJECT::T_TRK_REJECT(MU_CODE muCode )
{
	initial();
	setPrimKey (muCode );	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_TRK_REJECT::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_TRK_REJECT
//
//	this methode stores the unique key attributes
//
void T_TRK_REJECT::setPrimKey( long arg1 , const char* arg2 , short arg3 ){
	l_k_muId = arg1;
	strncpy( (char*)c_k_muCreator , arg2 , sizeof(c_k_muCreator) );
	c_k_muCreator[sizeof(c_k_muCreator)-1] = '\0';
	s_k_musId = arg3;
} // end of methode
void T_TRK_REJECT::setPrimKey( MU_CODE muCode ){
	setPrimKey ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
} // end of methode

void T_TRK_REJECT::initInsertKeys( long arg1 , const char* arg2 , short arg3 ){
	setPrimKey (  arg1 ,  arg2 ,  arg3 );
	l_muId = arg1;
	strncpy( (char*)c_muCreator , arg2 , sizeof(c_muCreator) );
	c_muCreator[sizeof(c_muCreator)-1] = '\0';
	s_musId = arg3;
} // end of methode
void T_TRK_REJECT::initInsertKeys( MU_CODE muCode ){
	initInsertKeys ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
} // end of methode
void T_TRK_REJECT::setKeysFromRecord(){
	set_k_muId( muId() );
	set_k_muCreator( muCreator() );
	set_k_musId( musId() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_TRK_REJECT T_TRK_REJECT::operator+(const T_TRK_REJECT &inst) const{
	T_TRK_REJECT ptrT_TRK_REJECT(*this);
//----------------------------------------------------------
	if(inst.locationZi() != -1){
		ptrT_TRK_REJECT.set_location(inst.location());
		ptrT_TRK_REJECT.set_locationZi(inst.locationZi());
	}
//----------------------------------------------------------
	if(inst.dateTimeZi() != -1){
		ptrT_TRK_REJECT.set_dateTime(inst.dateTime());
		ptrT_TRK_REJECT.set_dateTimeZi(inst.dateTimeZi());
	}
//----------------------------------------------------------
	if(inst.ReasonCodeZi() != -1){
		ptrT_TRK_REJECT.set_ReasonCode(inst.ReasonCode());
		ptrT_TRK_REJECT.set_ReasonCodeZi(inst.ReasonCodeZi());
	}
//----------------------------------------------------------
	if(inst.reasonZi() != -1){
		ptrT_TRK_REJECT.set_reason(inst.reason());
		ptrT_TRK_REJECT.set_reasonZi(inst.reasonZi());
	}
//----------------------------------------------------------
	if(inst.remarkZi() != -1){
		ptrT_TRK_REJECT.set_remark(inst.remark());
		ptrT_TRK_REJECT.set_remarkZi(inst.remarkZi());
	}
//----------------------------------------------------------
	if(inst.L3AckFlagZi() != -1){
		ptrT_TRK_REJECT.set_L3AckFlag(inst.L3AckFlag());
		ptrT_TRK_REJECT.set_L3AckFlagZi(inst.L3AckFlagZi());
	}
//----------------------------------------------------------
	if(inst.RejectFlagZi() != -1){
		ptrT_TRK_REJECT.set_RejectFlag(inst.RejectFlag());
		ptrT_TRK_REJECT.set_RejectFlagZi(inst.RejectFlagZi());
	}
//----------------------------------------------------------
	if(inst.RejectCoilIdZi() != -1){
		ptrT_TRK_REJECT.set_RejectCoilId(inst.RejectCoilId());
		ptrT_TRK_REJECT.set_RejectCoilIdZi(inst.RejectCoilIdZi());
	}
//----------------------------------------------------------
	if(inst.HoldFlagZi() != -1){
		ptrT_TRK_REJECT.set_HoldFlag(inst.HoldFlag());
		ptrT_TRK_REJECT.set_HoldFlagZi(inst.HoldFlagZi());
	}
//----------------------------------------------------------
	if(inst.UserIdZi() != -1){
		ptrT_TRK_REJECT.set_UserId(inst.UserId());
		ptrT_TRK_REJECT.set_UserIdZi(inst.UserIdZi());
	}
//----------------------------------------------------------
	if(inst.EntCoilIdZi() != -1){
		ptrT_TRK_REJECT.set_EntCoilId(inst.EntCoilId());
		ptrT_TRK_REJECT.set_EntCoilIdZi(inst.EntCoilIdZi());
	}
//----------------------------------------------------------
	if(inst.FinalSignZi() != -1){
		ptrT_TRK_REJECT.set_FinalSign(inst.FinalSign());
		ptrT_TRK_REJECT.set_FinalSignZi(inst.FinalSignZi());
	}
//----------------------------------------------------------
	ptrT_TRK_REJECT.set_muId(inst.muId());
//----------------------------------------------------------
	ptrT_TRK_REJECT.set_muCreator(inst.muCreator());
//----------------------------------------------------------
	ptrT_TRK_REJECT.set_musId(inst.musId());
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_TRK_REJECT.set_toc(inst.toc());
		ptrT_TRK_REJECT.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_TRK_REJECT.set_tom(inst.tom());
		ptrT_TRK_REJECT.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_TRK_REJECT.set_mop(inst.mop());
		ptrT_TRK_REJECT.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_TRK_REJECT.set_mou(inst.mou());
		ptrT_TRK_REJECT.set_mouZi(inst.mouZi());
	}
	return (ptrT_TRK_REJECT);
}

//
//O P E R A T O R  = 
//===================
//
const T_TRK_REJECT& T_TRK_REJECT::operator=(const T_TRK_REJECT &inst){
//----------------------------------------------------------
	this->set_location(inst.location());
	this->set_locationZi(inst.locationZi());
//----------------------------------------------------------
	this->set_dateTime(inst.dateTime());
	this->set_dateTimeZi(inst.dateTimeZi());
//----------------------------------------------------------
	this->set_ReasonCode(inst.ReasonCode());
	this->set_ReasonCodeZi(inst.ReasonCodeZi());
//----------------------------------------------------------
	this->set_reason(inst.reason());
	this->set_reasonZi(inst.reasonZi());
//----------------------------------------------------------
	this->set_remark(inst.remark());
	this->set_remarkZi(inst.remarkZi());
//----------------------------------------------------------
	this->set_L3AckFlag(inst.L3AckFlag());
	this->set_L3AckFlagZi(inst.L3AckFlagZi());
//----------------------------------------------------------
	this->set_RejectFlag(inst.RejectFlag());
	this->set_RejectFlagZi(inst.RejectFlagZi());
//----------------------------------------------------------
	this->set_RejectCoilId(inst.RejectCoilId());
	this->set_RejectCoilIdZi(inst.RejectCoilIdZi());
//----------------------------------------------------------
	this->set_HoldFlag(inst.HoldFlag());
	this->set_HoldFlagZi(inst.HoldFlagZi());
//----------------------------------------------------------
	this->set_UserId(inst.UserId());
	this->set_UserIdZi(inst.UserIdZi());
//----------------------------------------------------------
	this->set_EntCoilId(inst.EntCoilId());
	this->set_EntCoilIdZi(inst.EntCoilIdZi());
//----------------------------------------------------------
	this->set_FinalSign(inst.FinalSign());
	this->set_FinalSignZi(inst.FinalSignZi());
//----------------------------------------------------------
	this->set_muId(inst.muId());
//----------------------------------------------------------
	this->set_muCreator(inst.muCreator());
//----------------------------------------------------------
	this->set_musId(inst.musId());
//----------------------------------------------------------
	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_TRK_REJECT::T_TRK_REJECT(const T_TRK_REJECT &inst){
//----------------------------------------------------------
	this->set_location(inst.location());
	this->set_locationZi(inst.locationZi());
//----------------------------------------------------------
	this->set_dateTime(inst.dateTime());
	this->set_dateTimeZi(inst.dateTimeZi());
//----------------------------------------------------------
	this->set_ReasonCode(inst.ReasonCode());
	this->set_ReasonCodeZi(inst.ReasonCodeZi());
//----------------------------------------------------------
	this->set_reason(inst.reason());
	this->set_reasonZi(inst.reasonZi());
//----------------------------------------------------------
	this->set_remark(inst.remark());
	this->set_remarkZi(inst.remarkZi());
//----------------------------------------------------------
	this->set_L3AckFlag(inst.L3AckFlag());
	this->set_L3AckFlagZi(inst.L3AckFlagZi());
//----------------------------------------------------------
	this->set_RejectFlag(inst.RejectFlag());
	this->set_RejectFlagZi(inst.RejectFlagZi());
//----------------------------------------------------------
	this->set_RejectCoilId(inst.RejectCoilId());
	this->set_RejectCoilIdZi(inst.RejectCoilIdZi());
//----------------------------------------------------------
	this->set_HoldFlag(inst.HoldFlag());
	this->set_HoldFlagZi(inst.HoldFlagZi());
//----------------------------------------------------------
	this->set_UserId(inst.UserId());
	this->set_UserIdZi(inst.UserIdZi());
//----------------------------------------------------------
	this->set_EntCoilId(inst.EntCoilId());
	this->set_EntCoilIdZi(inst.EntCoilIdZi());
//----------------------------------------------------------
	this->set_FinalSign(inst.FinalSign());
	this->set_FinalSignZi(inst.FinalSignZi());
//----------------------------------------------------------
	this->set_muId(inst.muId());
//----------------------------------------------------------
	this->set_muCreator(inst.muCreator());
//----------------------------------------------------------
	this->set_musId(inst.musId());
//----------------------------------------------------------
	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_TRK_REJECT::location() const{
	return((long)l_location );
}

short T_TRK_REJECT::locationZi() const{
	return( s_locationZi);
}

void T_TRK_REJECT::set_location( long arg ){ 
	l_location = arg;
	s_locationZi=  0;
	return;
}

void T_TRK_REJECT::set_locationZi( short arg ) {
	s_locationZi =  arg;
}

char* T_TRK_REJECT::dateTime() const{
	return((char*)c_dateTime );
}

short T_TRK_REJECT::dateTimeZi() const{
	return( s_dateTimeZi);
}

void T_TRK_REJECT::set_dateTime( char* arg ){ 
	strncpy((char*)c_dateTime , arg , sizeof(c_dateTime));
	c_dateTime[sizeof(c_dateTime)-1] = '\0';
	s_dateTimeZi=  0;
	return;
}

void T_TRK_REJECT::set_dateTimeZi( short arg ) {
	s_dateTimeZi =  arg;
}

char* T_TRK_REJECT::ReasonCode() const{
	return((char*)c_ReasonCode );
}

short T_TRK_REJECT::ReasonCodeZi() const{
	return( s_ReasonCodeZi);
}

void T_TRK_REJECT::set_ReasonCode( const char* arg ){ 
	strncpy((char*)c_ReasonCode , arg , sizeof(c_ReasonCode));
	c_ReasonCode[sizeof(c_ReasonCode)-1] = '\0';
	s_ReasonCodeZi=  0;
	return;
}

void T_TRK_REJECT::set_ReasonCodeZi( short arg ) {
	s_ReasonCodeZi =  arg;
}

char* T_TRK_REJECT::reason() const{
	return((char*)c_reason );
}

short T_TRK_REJECT::reasonZi() const{
	return( s_reasonZi);
}

void T_TRK_REJECT::set_reason( const char* arg ){ 
	strncpy((char*)c_reason , arg , sizeof(c_reason));
	c_reason[sizeof(c_reason)-1] = '\0';
	s_reasonZi=  0;
	return;
}

void T_TRK_REJECT::set_reasonZi( short arg ) {
	s_reasonZi =  arg;
}

char* T_TRK_REJECT::remark() const{
	return((char*)c_remark );
}

short T_TRK_REJECT::remarkZi() const{
	return( s_remarkZi);
}

void T_TRK_REJECT::set_remark( const char* arg ){ 
	strncpy((char*)c_remark , arg , sizeof(c_remark));
	c_remark[sizeof(c_remark)-1] = '\0';
	s_remarkZi=  0;
	return;
}

void T_TRK_REJECT::set_remarkZi( short arg ) {
	s_remarkZi =  arg;
}

long T_TRK_REJECT::L3AckFlag() const{
	return((long)l_L3AckFlag );
}

short T_TRK_REJECT::L3AckFlagZi() const{
	return( s_L3AckFlagZi);
}

void T_TRK_REJECT::set_L3AckFlag( long arg ){ 
	l_L3AckFlag = arg;
	s_L3AckFlagZi=  0;
	return;
}

void T_TRK_REJECT::set_L3AckFlagZi( short arg ) {
	s_L3AckFlagZi =  arg;
}

char* T_TRK_REJECT::RejectFlag() const{
	return((char*)c_RejectFlag );
}

short T_TRK_REJECT::RejectFlagZi() const{
	return( s_RejectFlagZi);
}

void T_TRK_REJECT::set_RejectFlag( const char* arg ){ 
	strncpy((char*)c_RejectFlag , arg , sizeof(c_RejectFlag));
	c_RejectFlag[sizeof(c_RejectFlag)-1] = '\0';
	s_RejectFlagZi=  0;
	return;
}

void T_TRK_REJECT::set_RejectFlagZi( short arg ) {
	s_RejectFlagZi =  arg;
}

char* T_TRK_REJECT::RejectCoilId() const{
	return((char*)c_RejectCoilId );
}

short T_TRK_REJECT::RejectCoilIdZi() const{
	return( s_RejectCoilIdZi);
}

void T_TRK_REJECT::set_RejectCoilId( const char* arg ){ 
	strncpy((char*)c_RejectCoilId , arg , sizeof(c_RejectCoilId));
	c_RejectCoilId[sizeof(c_RejectCoilId)-1] = '\0';
	s_RejectCoilIdZi=  0;
	return;
}

void T_TRK_REJECT::set_RejectCoilIdZi( short arg ) {
	s_RejectCoilIdZi =  arg;
}

char* T_TRK_REJECT::HoldFlag() const{
	return((char*)c_HoldFlag );
}

short T_TRK_REJECT::HoldFlagZi() const{
	return( s_HoldFlagZi);
}

void T_TRK_REJECT::set_HoldFlag( const char* arg ){ 
	strncpy((char*)c_HoldFlag , arg , sizeof(c_HoldFlag));
	c_HoldFlag[sizeof(c_HoldFlag)-1] = '\0';
	s_HoldFlagZi=  0;
	return;
}

void T_TRK_REJECT::set_HoldFlagZi( short arg ) {
	s_HoldFlagZi =  arg;
}

char* T_TRK_REJECT::UserId() const{
	return((char*)c_UserId );
}

short T_TRK_REJECT::UserIdZi() const{
	return( s_UserIdZi);
}

void T_TRK_REJECT::set_UserId( const char* arg ){ 
	strncpy((char*)c_UserId , arg , sizeof(c_UserId));
	c_UserId[sizeof(c_UserId)-1] = '\0';
	s_UserIdZi=  0;
	return;
}

void T_TRK_REJECT::set_UserIdZi( short arg ) {
	s_UserIdZi =  arg;
}

char* T_TRK_REJECT::EntCoilId() const{
	return((char*)c_EntCoilId );
}

short T_TRK_REJECT::EntCoilIdZi() const{
	return( s_EntCoilIdZi);
}

void T_TRK_REJECT::set_EntCoilId( const char* arg ){ 
	strncpy((char*)c_EntCoilId , arg , sizeof(c_EntCoilId));
	c_EntCoilId[sizeof(c_EntCoilId)-1] = '\0';
	s_EntCoilIdZi=  0;
	return;
}

void T_TRK_REJECT::set_EntCoilIdZi( short arg ) {
	s_EntCoilIdZi =  arg;
}

long T_TRK_REJECT::FinalSign() const{
	return((long)l_FinalSign );
}

short T_TRK_REJECT::FinalSignZi() const{
	return( s_FinalSignZi);
}

void T_TRK_REJECT::set_FinalSign( long arg ){ 
	l_FinalSign = arg;
	s_FinalSignZi=  0;
	return;
}

void T_TRK_REJECT::set_FinalSignZi( short arg ) {
	s_FinalSignZi =  arg;
}

long	T_TRK_REJECT::muId() const{
	return((long)l_muId );
}

void	T_TRK_REJECT::set_muId( long arg ){
	l_muId =  arg;
	return;
}

char*	T_TRK_REJECT::muCreator() const{
	return((char*)c_muCreator );
}

void	T_TRK_REJECT::set_muCreator( const char* arg ){
	strncpy((char*)c_muCreator , arg , sizeof(c_muCreator));
	c_muCreator[sizeof(c_muCreator)-1] = '\0';
	return;
}

short	T_TRK_REJECT::musId() const{
	return((short)s_musId );
}

void	T_TRK_REJECT::set_musId( short arg ){
	s_musId =  arg;
	return;
}

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

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

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

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

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

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

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

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

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

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

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

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

// methodes for Primary key
long T_TRK_REJECT::k_muId(){
	return((long)l_k_muId );
}

void T_TRK_REJECT::set_k_muId( long arg ){
	l_k_muId =  arg;
	return;
}

char* T_TRK_REJECT::k_muCreator(){
	return((char*)c_k_muCreator );
}

void T_TRK_REJECT::set_k_muCreator( char* arg ){
	strncpy((char*)c_k_muCreator , arg , sizeof(c_k_muCreator));
	c_k_muCreator[sizeof(c_k_muCreator)-1] = '\0';
	return;
}

short T_TRK_REJECT::k_musId(){
	return((short)s_k_musId );
}

void T_TRK_REJECT::set_k_musId( short arg ){
	s_k_musId =  arg;
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_TRK_REJECT::fillStructure(){
	structTable.location = location();
	strncpy ( structTable.dateTime , dateTime(),sizeof(structTable.dateTime));
	strncpy ( structTable.ReasonCode , ReasonCode(),sizeof(structTable.ReasonCode));
	strncpy ( structTable.reason , reason(),sizeof(structTable.reason));
	strncpy ( structTable.remark , remark(),sizeof(structTable.remark));
	structTable.L3AckFlag = L3AckFlag();
	strncpy ( structTable.RejectFlag , RejectFlag(),sizeof(structTable.RejectFlag));
	strncpy ( structTable.RejectCoilId , RejectCoilId(),sizeof(structTable.RejectCoilId));
	strncpy ( structTable.HoldFlag , HoldFlag(),sizeof(structTable.HoldFlag));
	strncpy ( structTable.UserId , UserId(),sizeof(structTable.UserId));
	strncpy ( structTable.EntCoilId , EntCoilId(),sizeof(structTable.EntCoilId));
	structTable.FinalSign = FinalSign();
	structTable.muId = muId();
	strncpy ( structTable.muCreator , muCreator(),sizeof(structTable.muCreator));
	structTable.musId = musId();
	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_TRK_REJECT::fillStructureZi(){
	structTableZi.locationZi = locationZi();
	structTableZi.dateTimeZi = dateTimeZi();
	structTableZi.ReasonCodeZi = ReasonCodeZi();
	structTableZi.reasonZi = reasonZi();
	structTableZi.remarkZi = remarkZi();
	structTableZi.L3AckFlagZi = L3AckFlagZi();
	structTableZi.RejectFlagZi = RejectFlagZi();
	structTableZi.RejectCoilIdZi = RejectCoilIdZi();
	structTableZi.HoldFlagZi = HoldFlagZi();
	structTableZi.UserIdZi = UserIdZi();
	structTableZi.EntCoilIdZi = EntCoilIdZi();
	structTableZi.FinalSignZi = FinalSignZi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_TRK_REJECT::setStructure() {
	set_location( structTable.location);
	set_dateTime( structTable.dateTime);
	set_ReasonCode( structTable.ReasonCode);
	set_reason( structTable.reason);
	set_remark( structTable.remark);
	set_L3AckFlag( structTable.L3AckFlag);
	set_RejectFlag( structTable.RejectFlag);
	set_RejectCoilId( structTable.RejectCoilId);
	set_HoldFlag( structTable.HoldFlag);
	set_UserId( structTable.UserId);
	set_EntCoilId( structTable.EntCoilId);
	set_FinalSign( structTable.FinalSign);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_TRK_REJECT::setStructureZi() {
	set_locationZi( structTableZi.locationZi);
	set_dateTimeZi( structTableZi.dateTimeZi);
	set_ReasonCodeZi( structTableZi.ReasonCodeZi);
	set_reasonZi( structTableZi.reasonZi);
	set_remarkZi( structTableZi.remarkZi);
	set_L3AckFlagZi( structTableZi.L3AckFlagZi);
	set_RejectFlagZi( structTableZi.RejectFlagZi);
	set_RejectCoilIdZi( structTableZi.RejectCoilIdZi);
	set_HoldFlagZi( structTableZi.HoldFlagZi);
	set_UserIdZi( structTableZi.UserIdZi);
	set_EntCoilIdZi( structTableZi.EntCoilIdZi);
	set_FinalSignZi( structTableZi.FinalSignZi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_TRK_REJECT::getName(){
	return("T_TRK_REJECT");
}
///////////////////////////////////////////////////
int T_TRK_REJECT::getSqlCode(){
	return( db.dbSqlCode);
}
int T_TRK_REJECT::getRowsProcessed(){
	return( db.dbRowsProcessed);
}