1007 lines
27 KiB
C++
1007 lines
27 KiB
C++
// Version: 2014.10.20 14:41:0
|
|
|
|
// File: T_TRK_COILPROC.cpp
|
|
|
|
#include "T_TRK_COILPROC.h"
|
|
|
|
T_TRK_COILPROC::T_TRK_COILPROC(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_TRK_COILPROC::~T_TRK_COILPROC(){
|
|
}
|
|
void T_TRK_COILPROC::initial(){
|
|
// initialise all membervariables
|
|
set_cutTime("");
|
|
set_cutTimeZi(-1);
|
|
set_bookTime("");
|
|
set_bookTimeZi(-1);
|
|
set_EnCoilId("");
|
|
set_EnCoilIdZi(-1);
|
|
set_fasexitFlag(0);
|
|
set_fasexitFlagZi(-1);
|
|
set_FinalFlag(0);
|
|
set_FinalFlagZi(-1);
|
|
set_ProdStart("");
|
|
set_ProdStartZi(-1);
|
|
set_ProdEnd("");
|
|
set_ProdEndZi(-1);
|
|
set_EnHLen(0.0);
|
|
set_EnHLenZi(-1);
|
|
set_EnTLen(0.0);
|
|
set_EnTLenZi(-1);
|
|
set_ExHLen(0.0);
|
|
set_ExHLenZi(-1);
|
|
set_ExTLen(0.0);
|
|
set_ExTLenZi(-1);
|
|
set_CurLen(0.0);
|
|
set_CurLenZi(-1);
|
|
set_CoilLen(0.0);
|
|
set_CoilLenZi(-1);
|
|
set_EnHCutNo(0);
|
|
set_EnHCutNoZi(-1);
|
|
set_ExHCutNo(0);
|
|
set_ExHCutNoZi(-1);
|
|
set_EnTCutNo(0);
|
|
set_EnTCutNoZi(-1);
|
|
set_ExTCutNo(0);
|
|
set_ExTCutNoZi(-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_COILPROC::T_TRK_COILPROC(MU_CODE muCode )
|
|
{
|
|
initial();
|
|
setPrimKey (muCode ); //read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_TRK_COILPROC:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_TRK_COILPROC::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_COILPROC
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_TRK_COILPROC::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_COILPROC::setPrimKey( MU_CODE muCode ){
|
|
setPrimKey ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
|
|
} // end of methode
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::initInsertKeys( MU_CODE muCode ){
|
|
initInsertKeys ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
|
|
} // end of methode
|
|
void T_TRK_COILPROC::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_COILPROC T_TRK_COILPROC::operator+(const T_TRK_COILPROC &inst) const{
|
|
T_TRK_COILPROC ptrT_TRK_COILPROC(*this);
|
|
//----------------------------------------------------------
|
|
if(inst.cutTimeZi() != -1){
|
|
ptrT_TRK_COILPROC.set_cutTime(inst.cutTime());
|
|
ptrT_TRK_COILPROC.set_cutTimeZi(inst.cutTimeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.bookTimeZi() != -1){
|
|
ptrT_TRK_COILPROC.set_bookTime(inst.bookTime());
|
|
ptrT_TRK_COILPROC.set_bookTimeZi(inst.bookTimeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnCoilIdZi() != -1){
|
|
ptrT_TRK_COILPROC.set_EnCoilId(inst.EnCoilId());
|
|
ptrT_TRK_COILPROC.set_EnCoilIdZi(inst.EnCoilIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.fasexitFlagZi() != -1){
|
|
ptrT_TRK_COILPROC.set_fasexitFlag(inst.fasexitFlag());
|
|
ptrT_TRK_COILPROC.set_fasexitFlagZi(inst.fasexitFlagZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.FinalFlagZi() != -1){
|
|
ptrT_TRK_COILPROC.set_FinalFlag(inst.FinalFlag());
|
|
ptrT_TRK_COILPROC.set_FinalFlagZi(inst.FinalFlagZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ProdStartZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ProdStart(inst.ProdStart());
|
|
ptrT_TRK_COILPROC.set_ProdStartZi(inst.ProdStartZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ProdEndZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ProdEnd(inst.ProdEnd());
|
|
ptrT_TRK_COILPROC.set_ProdEndZi(inst.ProdEndZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnHLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_EnHLen(inst.EnHLen());
|
|
ptrT_TRK_COILPROC.set_EnHLenZi(inst.EnHLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnTLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_EnTLen(inst.EnTLen());
|
|
ptrT_TRK_COILPROC.set_EnTLenZi(inst.EnTLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ExHLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ExHLen(inst.ExHLen());
|
|
ptrT_TRK_COILPROC.set_ExHLenZi(inst.ExHLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ExTLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ExTLen(inst.ExTLen());
|
|
ptrT_TRK_COILPROC.set_ExTLenZi(inst.ExTLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.CurLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_CurLen(inst.CurLen());
|
|
ptrT_TRK_COILPROC.set_CurLenZi(inst.CurLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.CoilLenZi() != -1){
|
|
ptrT_TRK_COILPROC.set_CoilLen(inst.CoilLen());
|
|
ptrT_TRK_COILPROC.set_CoilLenZi(inst.CoilLenZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnHCutNoZi() != -1){
|
|
ptrT_TRK_COILPROC.set_EnHCutNo(inst.EnHCutNo());
|
|
ptrT_TRK_COILPROC.set_EnHCutNoZi(inst.EnHCutNoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ExHCutNoZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ExHCutNo(inst.ExHCutNo());
|
|
ptrT_TRK_COILPROC.set_ExHCutNoZi(inst.ExHCutNoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnTCutNoZi() != -1){
|
|
ptrT_TRK_COILPROC.set_EnTCutNo(inst.EnTCutNo());
|
|
ptrT_TRK_COILPROC.set_EnTCutNoZi(inst.EnTCutNoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ExTCutNoZi() != -1){
|
|
ptrT_TRK_COILPROC.set_ExTCutNo(inst.ExTCutNo());
|
|
ptrT_TRK_COILPROC.set_ExTCutNoZi(inst.ExTCutNoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
ptrT_TRK_COILPROC.set_muId(inst.muId());
|
|
//----------------------------------------------------------
|
|
ptrT_TRK_COILPROC.set_muCreator(inst.muCreator());
|
|
//----------------------------------------------------------
|
|
ptrT_TRK_COILPROC.set_musId(inst.musId());
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_TRK_COILPROC.set_toc(inst.toc());
|
|
ptrT_TRK_COILPROC.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_TRK_COILPROC.set_tom(inst.tom());
|
|
ptrT_TRK_COILPROC.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_TRK_COILPROC.set_mop(inst.mop());
|
|
ptrT_TRK_COILPROC.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_TRK_COILPROC.set_mou(inst.mou());
|
|
ptrT_TRK_COILPROC.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_TRK_COILPROC);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_TRK_COILPROC& T_TRK_COILPROC::operator=(const T_TRK_COILPROC &inst){
|
|
//----------------------------------------------------------
|
|
this->set_cutTime(inst.cutTime());
|
|
this->set_cutTimeZi(inst.cutTimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_bookTime(inst.bookTime());
|
|
this->set_bookTimeZi(inst.bookTimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnCoilId(inst.EnCoilId());
|
|
this->set_EnCoilIdZi(inst.EnCoilIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_fasexitFlag(inst.fasexitFlag());
|
|
this->set_fasexitFlagZi(inst.fasexitFlagZi());
|
|
//----------------------------------------------------------
|
|
this->set_FinalFlag(inst.FinalFlag());
|
|
this->set_FinalFlagZi(inst.FinalFlagZi());
|
|
//----------------------------------------------------------
|
|
this->set_ProdStart(inst.ProdStart());
|
|
this->set_ProdStartZi(inst.ProdStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_ProdEnd(inst.ProdEnd());
|
|
this->set_ProdEndZi(inst.ProdEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnHLen(inst.EnHLen());
|
|
this->set_EnHLenZi(inst.EnHLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnTLen(inst.EnTLen());
|
|
this->set_EnTLenZi(inst.EnTLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExHLen(inst.ExHLen());
|
|
this->set_ExHLenZi(inst.ExHLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExTLen(inst.ExTLen());
|
|
this->set_ExTLenZi(inst.ExTLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_CurLen(inst.CurLen());
|
|
this->set_CurLenZi(inst.CurLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_CoilLen(inst.CoilLen());
|
|
this->set_CoilLenZi(inst.CoilLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnHCutNo(inst.EnHCutNo());
|
|
this->set_EnHCutNoZi(inst.EnHCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExHCutNo(inst.ExHCutNo());
|
|
this->set_ExHCutNoZi(inst.ExHCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnTCutNo(inst.EnTCutNo());
|
|
this->set_EnTCutNoZi(inst.EnTCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExTCutNo(inst.ExTCutNo());
|
|
this->set_ExTCutNoZi(inst.ExTCutNoZi());
|
|
//----------------------------------------------------------
|
|
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_COILPROC::T_TRK_COILPROC(const T_TRK_COILPROC &inst){
|
|
//----------------------------------------------------------
|
|
this->set_cutTime(inst.cutTime());
|
|
this->set_cutTimeZi(inst.cutTimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_bookTime(inst.bookTime());
|
|
this->set_bookTimeZi(inst.bookTimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnCoilId(inst.EnCoilId());
|
|
this->set_EnCoilIdZi(inst.EnCoilIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_fasexitFlag(inst.fasexitFlag());
|
|
this->set_fasexitFlagZi(inst.fasexitFlagZi());
|
|
//----------------------------------------------------------
|
|
this->set_FinalFlag(inst.FinalFlag());
|
|
this->set_FinalFlagZi(inst.FinalFlagZi());
|
|
//----------------------------------------------------------
|
|
this->set_ProdStart(inst.ProdStart());
|
|
this->set_ProdStartZi(inst.ProdStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_ProdEnd(inst.ProdEnd());
|
|
this->set_ProdEndZi(inst.ProdEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnHLen(inst.EnHLen());
|
|
this->set_EnHLenZi(inst.EnHLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnTLen(inst.EnTLen());
|
|
this->set_EnTLenZi(inst.EnTLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExHLen(inst.ExHLen());
|
|
this->set_ExHLenZi(inst.ExHLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExTLen(inst.ExTLen());
|
|
this->set_ExTLenZi(inst.ExTLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_CurLen(inst.CurLen());
|
|
this->set_CurLenZi(inst.CurLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_CoilLen(inst.CoilLen());
|
|
this->set_CoilLenZi(inst.CoilLenZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnHCutNo(inst.EnHCutNo());
|
|
this->set_EnHCutNoZi(inst.EnHCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExHCutNo(inst.ExHCutNo());
|
|
this->set_ExHCutNoZi(inst.ExHCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_EnTCutNo(inst.EnTCutNo());
|
|
this->set_EnTCutNoZi(inst.EnTCutNoZi());
|
|
//----------------------------------------------------------
|
|
this->set_ExTCutNo(inst.ExTCutNo());
|
|
this->set_ExTCutNoZi(inst.ExTCutNoZi());
|
|
//----------------------------------------------------------
|
|
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());
|
|
}
|
|
char* T_TRK_COILPROC::cutTime() const{
|
|
return((char*)c_cutTime );
|
|
}
|
|
|
|
short T_TRK_COILPROC::cutTimeZi() const{
|
|
return( s_cutTimeZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_cutTime( char* arg ){
|
|
strncpy((char*)c_cutTime , arg , sizeof(c_cutTime));
|
|
c_cutTime[sizeof(c_cutTime)-1] = '\0';
|
|
s_cutTimeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_cutTimeZi( short arg ) {
|
|
s_cutTimeZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::bookTime() const{
|
|
return((char*)c_bookTime );
|
|
}
|
|
|
|
short T_TRK_COILPROC::bookTimeZi() const{
|
|
return( s_bookTimeZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_bookTime( char* arg ){
|
|
strncpy((char*)c_bookTime , arg , sizeof(c_bookTime));
|
|
c_bookTime[sizeof(c_bookTime)-1] = '\0';
|
|
s_bookTimeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_bookTimeZi( short arg ) {
|
|
s_bookTimeZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::EnCoilId() const{
|
|
return((char*)c_EnCoilId );
|
|
}
|
|
|
|
short T_TRK_COILPROC::EnCoilIdZi() const{
|
|
return( s_EnCoilIdZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnCoilId( const char* arg ){
|
|
strncpy((char*)c_EnCoilId , arg , sizeof(c_EnCoilId));
|
|
c_EnCoilId[sizeof(c_EnCoilId)-1] = '\0';
|
|
s_EnCoilIdZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnCoilIdZi( short arg ) {
|
|
s_EnCoilIdZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::fasexitFlag() const{
|
|
return((long)l_fasexitFlag );
|
|
}
|
|
|
|
short T_TRK_COILPROC::fasexitFlagZi() const{
|
|
return( s_fasexitFlagZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_fasexitFlag( long arg ){
|
|
l_fasexitFlag = arg;
|
|
s_fasexitFlagZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_fasexitFlagZi( short arg ) {
|
|
s_fasexitFlagZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::FinalFlag() const{
|
|
return((long)l_FinalFlag );
|
|
}
|
|
|
|
short T_TRK_COILPROC::FinalFlagZi() const{
|
|
return( s_FinalFlagZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_FinalFlag( long arg ){
|
|
l_FinalFlag = arg;
|
|
s_FinalFlagZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_FinalFlagZi( short arg ) {
|
|
s_FinalFlagZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::ProdStart() const{
|
|
return((char*)c_ProdStart );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ProdStartZi() const{
|
|
return( s_ProdStartZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ProdStart( char* arg ){
|
|
strncpy((char*)c_ProdStart , arg , sizeof(c_ProdStart));
|
|
c_ProdStart[sizeof(c_ProdStart)-1] = '\0';
|
|
s_ProdStartZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ProdStartZi( short arg ) {
|
|
s_ProdStartZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::ProdEnd() const{
|
|
return((char*)c_ProdEnd );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ProdEndZi() const{
|
|
return( s_ProdEndZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ProdEnd( char* arg ){
|
|
strncpy((char*)c_ProdEnd , arg , sizeof(c_ProdEnd));
|
|
c_ProdEnd[sizeof(c_ProdEnd)-1] = '\0';
|
|
s_ProdEndZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ProdEndZi( short arg ) {
|
|
s_ProdEndZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::EnHLen() const{
|
|
return((double)d_EnHLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::EnHLenZi() const{
|
|
return( s_EnHLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnHLen( double arg ){
|
|
d_EnHLen = arg;
|
|
s_EnHLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnHLenZi( short arg ) {
|
|
s_EnHLenZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::EnTLen() const{
|
|
return((double)d_EnTLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::EnTLenZi() const{
|
|
return( s_EnTLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnTLen( double arg ){
|
|
d_EnTLen = arg;
|
|
s_EnTLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnTLenZi( short arg ) {
|
|
s_EnTLenZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::ExHLen() const{
|
|
return((double)d_ExHLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ExHLenZi() const{
|
|
return( s_ExHLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExHLen( double arg ){
|
|
d_ExHLen = arg;
|
|
s_ExHLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExHLenZi( short arg ) {
|
|
s_ExHLenZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::ExTLen() const{
|
|
return((double)d_ExTLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ExTLenZi() const{
|
|
return( s_ExTLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExTLen( double arg ){
|
|
d_ExTLen = arg;
|
|
s_ExTLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExTLenZi( short arg ) {
|
|
s_ExTLenZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::CurLen() const{
|
|
return((double)d_CurLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::CurLenZi() const{
|
|
return( s_CurLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_CurLen( double arg ){
|
|
d_CurLen = arg;
|
|
s_CurLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_CurLenZi( short arg ) {
|
|
s_CurLenZi = arg;
|
|
}
|
|
|
|
double T_TRK_COILPROC::CoilLen() const{
|
|
return((double)d_CoilLen );
|
|
}
|
|
|
|
short T_TRK_COILPROC::CoilLenZi() const{
|
|
return( s_CoilLenZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_CoilLen( double arg ){
|
|
d_CoilLen = arg;
|
|
s_CoilLenZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_CoilLenZi( short arg ) {
|
|
s_CoilLenZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::EnHCutNo() const{
|
|
return((long)l_EnHCutNo );
|
|
}
|
|
|
|
short T_TRK_COILPROC::EnHCutNoZi() const{
|
|
return( s_EnHCutNoZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnHCutNo( long arg ){
|
|
l_EnHCutNo = arg;
|
|
s_EnHCutNoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnHCutNoZi( short arg ) {
|
|
s_EnHCutNoZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::ExHCutNo() const{
|
|
return((long)l_ExHCutNo );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ExHCutNoZi() const{
|
|
return( s_ExHCutNoZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExHCutNo( long arg ){
|
|
l_ExHCutNo = arg;
|
|
s_ExHCutNoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExHCutNoZi( short arg ) {
|
|
s_ExHCutNoZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::EnTCutNo() const{
|
|
return((long)l_EnTCutNo );
|
|
}
|
|
|
|
short T_TRK_COILPROC::EnTCutNoZi() const{
|
|
return( s_EnTCutNoZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnTCutNo( long arg ){
|
|
l_EnTCutNo = arg;
|
|
s_EnTCutNoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_EnTCutNoZi( short arg ) {
|
|
s_EnTCutNoZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::ExTCutNo() const{
|
|
return((long)l_ExTCutNo );
|
|
}
|
|
|
|
short T_TRK_COILPROC::ExTCutNoZi() const{
|
|
return( s_ExTCutNoZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExTCutNo( long arg ){
|
|
l_ExTCutNo = arg;
|
|
s_ExTCutNoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_ExTCutNoZi( short arg ) {
|
|
s_ExTCutNoZi = arg;
|
|
}
|
|
|
|
long T_TRK_COILPROC::muId() const{
|
|
return((long)l_muId );
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_muId( long arg ){
|
|
l_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::muCreator() const{
|
|
return((char*)c_muCreator );
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_muCreator( const char* arg ){
|
|
strncpy((char*)c_muCreator , arg , sizeof(c_muCreator));
|
|
c_muCreator[sizeof(c_muCreator)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
short T_TRK_COILPROC::musId() const{
|
|
return((short)s_musId );
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_musId( short arg ){
|
|
s_musId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_TRK_COILPROC::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_TRK_COILPROC::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_TRK_COILPROC::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_TRK_COILPROC::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_TRK_COILPROC::k_muId(){
|
|
return((long)l_k_muId );
|
|
}
|
|
|
|
void T_TRK_COILPROC::set_k_muId( long arg ){
|
|
l_k_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_TRK_COILPROC::k_muCreator(){
|
|
return((char*)c_k_muCreator );
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::k_musId(){
|
|
return((short)s_k_musId );
|
|
}
|
|
|
|
void T_TRK_COILPROC::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_COILPROC::fillStructure(){
|
|
strncpy ( structTable.cutTime , cutTime(),sizeof(structTable.cutTime));
|
|
strncpy ( structTable.bookTime , bookTime(),sizeof(structTable.bookTime));
|
|
strncpy ( structTable.EnCoilId , EnCoilId(),sizeof(structTable.EnCoilId));
|
|
structTable.fasexitFlag = fasexitFlag();
|
|
structTable.FinalFlag = FinalFlag();
|
|
strncpy ( structTable.ProdStart , ProdStart(),sizeof(structTable.ProdStart));
|
|
strncpy ( structTable.ProdEnd , ProdEnd(),sizeof(structTable.ProdEnd));
|
|
structTable.EnHLen = EnHLen();
|
|
structTable.EnTLen = EnTLen();
|
|
structTable.ExHLen = ExHLen();
|
|
structTable.ExTLen = ExTLen();
|
|
structTable.CurLen = CurLen();
|
|
structTable.CoilLen = CoilLen();
|
|
structTable.EnHCutNo = EnHCutNo();
|
|
structTable.ExHCutNo = ExHCutNo();
|
|
structTable.EnTCutNo = EnTCutNo();
|
|
structTable.ExTCutNo = ExTCutNo();
|
|
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_COILPROC::fillStructureZi(){
|
|
structTableZi.cutTimeZi = cutTimeZi();
|
|
structTableZi.bookTimeZi = bookTimeZi();
|
|
structTableZi.EnCoilIdZi = EnCoilIdZi();
|
|
structTableZi.fasexitFlagZi = fasexitFlagZi();
|
|
structTableZi.FinalFlagZi = FinalFlagZi();
|
|
structTableZi.ProdStartZi = ProdStartZi();
|
|
structTableZi.ProdEndZi = ProdEndZi();
|
|
structTableZi.EnHLenZi = EnHLenZi();
|
|
structTableZi.EnTLenZi = EnTLenZi();
|
|
structTableZi.ExHLenZi = ExHLenZi();
|
|
structTableZi.ExTLenZi = ExTLenZi();
|
|
structTableZi.CurLenZi = CurLenZi();
|
|
structTableZi.CoilLenZi = CoilLenZi();
|
|
structTableZi.EnHCutNoZi = EnHCutNoZi();
|
|
structTableZi.ExHCutNoZi = ExHCutNoZi();
|
|
structTableZi.EnTCutNoZi = EnTCutNoZi();
|
|
structTableZi.ExTCutNoZi = ExTCutNoZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_TRK_COILPROC::setStructure() {
|
|
set_cutTime( structTable.cutTime);
|
|
set_bookTime( structTable.bookTime);
|
|
set_EnCoilId( structTable.EnCoilId);
|
|
set_fasexitFlag( structTable.fasexitFlag);
|
|
set_FinalFlag( structTable.FinalFlag);
|
|
set_ProdStart( structTable.ProdStart);
|
|
set_ProdEnd( structTable.ProdEnd);
|
|
set_EnHLen( structTable.EnHLen);
|
|
set_EnTLen( structTable.EnTLen);
|
|
set_ExHLen( structTable.ExHLen);
|
|
set_ExTLen( structTable.ExTLen);
|
|
set_CurLen( structTable.CurLen);
|
|
set_CoilLen( structTable.CoilLen);
|
|
set_EnHCutNo( structTable.EnHCutNo);
|
|
set_ExHCutNo( structTable.ExHCutNo);
|
|
set_EnTCutNo( structTable.EnTCutNo);
|
|
set_ExTCutNo( structTable.ExTCutNo);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_TRK_COILPROC::setStructureZi() {
|
|
set_cutTimeZi( structTableZi.cutTimeZi);
|
|
set_bookTimeZi( structTableZi.bookTimeZi);
|
|
set_EnCoilIdZi( structTableZi.EnCoilIdZi);
|
|
set_fasexitFlagZi( structTableZi.fasexitFlagZi);
|
|
set_FinalFlagZi( structTableZi.FinalFlagZi);
|
|
set_ProdStartZi( structTableZi.ProdStartZi);
|
|
set_ProdEndZi( structTableZi.ProdEndZi);
|
|
set_EnHLenZi( structTableZi.EnHLenZi);
|
|
set_EnTLenZi( structTableZi.EnTLenZi);
|
|
set_ExHLenZi( structTableZi.ExHLenZi);
|
|
set_ExTLenZi( structTableZi.ExTLenZi);
|
|
set_CurLenZi( structTableZi.CurLenZi);
|
|
set_CoilLenZi( structTableZi.CoilLenZi);
|
|
set_EnHCutNoZi( structTableZi.EnHCutNoZi);
|
|
set_ExHCutNoZi( structTableZi.ExHCutNoZi);
|
|
set_EnTCutNoZi( structTableZi.EnTCutNoZi);
|
|
set_ExTCutNoZi( structTableZi.ExTCutNoZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_TRK_COILPROC::getName(){
|
|
return("T_TRK_COILPROC");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_TRK_COILPROC::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_TRK_COILPROC::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|