836 lines
22 KiB
C++
836 lines
22 KiB
C++
// 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);
|
|
}
|