663 lines
17 KiB
C++
663 lines
17 KiB
C++
// Version: 2018.7.20 13:7:35
|
|
|
|
// File: T_DOT_DATA.cpp
|
|
|
|
#include "T_DOT_DATA.h"
|
|
|
|
T_DOT_DATA::T_DOT_DATA(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_DOT_DATA::~T_DOT_DATA(){
|
|
}
|
|
void T_DOT_DATA::initial(){
|
|
// initialise all membervariables
|
|
set_Seq(0);
|
|
set_StopDate((char*)"");
|
|
set_StopDateZi(-1);
|
|
set_Shift((char*)"");
|
|
set_ShiftZi(-1);
|
|
set_Turn((char*)"");
|
|
set_TurnZi(-1);
|
|
set_StopStart((char*)"");
|
|
set_StopStartZi(-1);
|
|
set_StopEnd((char*)"");
|
|
set_StopEndZi(-1);
|
|
set_StopElapsed(0);
|
|
set_StopElapsedZi(-1);
|
|
set_Code((char*)"");
|
|
set_CodeZi(-1);
|
|
set_Status((char*)"");
|
|
set_StatusZi(-1);
|
|
set_WorkLevel((char*)"");
|
|
set_WorkLevelZi(-1);
|
|
set_toc((char*)"");
|
|
set_tocZi(-1);
|
|
set_toc((char*)"");
|
|
set_tomZi(-1);
|
|
set_mop((char*)"");
|
|
set_mopZi(-1);
|
|
set_mou((char*)"");
|
|
set_mouZi(-1);
|
|
// initialies Primary key members
|
|
set_k_Seq(0);
|
|
}
|
|
T_DOT_DATA::T_DOT_DATA(long arg1)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_DOT_DATA:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_DOT_DATA:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_DOT_DATA:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_DOT_DATA::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_DOT_DATA::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_DOT_DATA::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_DOT_DATA::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_DOT_DATA::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_DOT_DATA::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_DOT_DATA::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_DOT_DATA::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_DOT_DATA::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_DOT_DATA::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_DOT_DATA
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_DOT_DATA::setPrimKey( long arg1 ){
|
|
l_k_Seq = arg1;
|
|
} // end of methode
|
|
|
|
void T_DOT_DATA::initInsertKeys( long arg1 ){
|
|
setPrimKey ( arg1);
|
|
l_Seq = arg1;
|
|
} // end of methode
|
|
void T_DOT_DATA::setKeysFromRecord(){
|
|
set_k_Seq( Seq() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_DOT_DATA T_DOT_DATA::operator+(const T_DOT_DATA &inst) const{
|
|
T_DOT_DATA ptrT_DOT_DATA(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_DOT_DATA.set_Seq(inst.Seq());
|
|
//----------------------------------------------------------
|
|
if(inst.StopDateZi() != -1){
|
|
ptrT_DOT_DATA.set_StopDate(inst.StopDate());
|
|
ptrT_DOT_DATA.set_StopDateZi(inst.StopDateZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ShiftZi() != -1){
|
|
ptrT_DOT_DATA.set_Shift(inst.Shift());
|
|
ptrT_DOT_DATA.set_ShiftZi(inst.ShiftZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.TurnZi() != -1){
|
|
ptrT_DOT_DATA.set_Turn(inst.Turn());
|
|
ptrT_DOT_DATA.set_TurnZi(inst.TurnZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.StopStartZi() != -1){
|
|
ptrT_DOT_DATA.set_StopStart(inst.StopStart());
|
|
ptrT_DOT_DATA.set_StopStartZi(inst.StopStartZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.StopEndZi() != -1){
|
|
ptrT_DOT_DATA.set_StopEnd(inst.StopEnd());
|
|
ptrT_DOT_DATA.set_StopEndZi(inst.StopEndZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.StopElapsedZi() != -1){
|
|
ptrT_DOT_DATA.set_StopElapsed(inst.StopElapsed());
|
|
ptrT_DOT_DATA.set_StopElapsedZi(inst.StopElapsedZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.CodeZi() != -1){
|
|
ptrT_DOT_DATA.set_Code(inst.Code());
|
|
ptrT_DOT_DATA.set_CodeZi(inst.CodeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.StatusZi() != -1){
|
|
ptrT_DOT_DATA.set_Status(inst.Status());
|
|
ptrT_DOT_DATA.set_StatusZi(inst.StatusZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.WorkLevelZi() != -1){
|
|
ptrT_DOT_DATA.set_WorkLevel(inst.WorkLevel());
|
|
ptrT_DOT_DATA.set_WorkLevelZi(inst.WorkLevelZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_DOT_DATA.set_toc(inst.toc());
|
|
ptrT_DOT_DATA.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_DOT_DATA.set_tom(inst.tom());
|
|
ptrT_DOT_DATA.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_DOT_DATA.set_mop(inst.mop());
|
|
ptrT_DOT_DATA.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_DOT_DATA.set_mou(inst.mou());
|
|
ptrT_DOT_DATA.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_DOT_DATA);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_DOT_DATA& T_DOT_DATA::operator=(const T_DOT_DATA &inst){
|
|
//----------------------------------------------------------
|
|
this->set_Seq(inst.Seq());
|
|
//----------------------------------------------------------
|
|
this->set_StopDate(inst.StopDate());
|
|
this->set_StopDateZi(inst.StopDateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Shift(inst.Shift());
|
|
this->set_ShiftZi(inst.ShiftZi());
|
|
//----------------------------------------------------------
|
|
this->set_Turn(inst.Turn());
|
|
this->set_TurnZi(inst.TurnZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopStart(inst.StopStart());
|
|
this->set_StopStartZi(inst.StopStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopEnd(inst.StopEnd());
|
|
this->set_StopEndZi(inst.StopEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopElapsed(inst.StopElapsed());
|
|
this->set_StopElapsedZi(inst.StopElapsedZi());
|
|
//----------------------------------------------------------
|
|
this->set_Code(inst.Code());
|
|
this->set_CodeZi(inst.CodeZi());
|
|
//----------------------------------------------------------
|
|
this->set_Status(inst.Status());
|
|
this->set_StatusZi(inst.StatusZi());
|
|
//----------------------------------------------------------
|
|
this->set_WorkLevel(inst.WorkLevel());
|
|
this->set_WorkLevelZi(inst.WorkLevelZi());
|
|
//----------------------------------------------------------
|
|
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_DOT_DATA::T_DOT_DATA(const T_DOT_DATA &inst){
|
|
//----------------------------------------------------------
|
|
this->set_Seq(inst.Seq());
|
|
//----------------------------------------------------------
|
|
this->set_StopDate(inst.StopDate());
|
|
this->set_StopDateZi(inst.StopDateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Shift(inst.Shift());
|
|
this->set_ShiftZi(inst.ShiftZi());
|
|
//----------------------------------------------------------
|
|
this->set_Turn(inst.Turn());
|
|
this->set_TurnZi(inst.TurnZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopStart(inst.StopStart());
|
|
this->set_StopStartZi(inst.StopStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopEnd(inst.StopEnd());
|
|
this->set_StopEndZi(inst.StopEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_StopElapsed(inst.StopElapsed());
|
|
this->set_StopElapsedZi(inst.StopElapsedZi());
|
|
//----------------------------------------------------------
|
|
this->set_Code(inst.Code());
|
|
this->set_CodeZi(inst.CodeZi());
|
|
//----------------------------------------------------------
|
|
this->set_Status(inst.Status());
|
|
this->set_StatusZi(inst.StatusZi());
|
|
//----------------------------------------------------------
|
|
this->set_WorkLevel(inst.WorkLevel());
|
|
this->set_WorkLevelZi(inst.WorkLevelZi());
|
|
//----------------------------------------------------------
|
|
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_DOT_DATA::Seq() const{
|
|
return((long)l_Seq );
|
|
}
|
|
|
|
|
|
void T_DOT_DATA::set_Seq( long arg ){
|
|
l_Seq = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_DOT_DATA::StopDate() const{
|
|
return((char*)c_StopDate );
|
|
}
|
|
|
|
short T_DOT_DATA::StopDateZi() const{
|
|
return( s_StopDateZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopDate( char* arg ){
|
|
strncpy((char*)c_StopDate , arg , sizeof(c_StopDate));
|
|
c_StopDate[sizeof(c_StopDate)-1] = '\0';
|
|
s_StopDateZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopDateZi( short arg ) {
|
|
s_StopDateZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::Shift() const{
|
|
return((char*)c_Shift );
|
|
}
|
|
|
|
short T_DOT_DATA::ShiftZi() const{
|
|
return( s_ShiftZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_Shift( const char* arg ){
|
|
strncpy((char*)c_Shift , arg , sizeof(c_Shift));
|
|
c_Shift[sizeof(c_Shift)-1] = '\0';
|
|
s_ShiftZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_ShiftZi( short arg ) {
|
|
s_ShiftZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::Turn() const{
|
|
return((char*)c_Turn );
|
|
}
|
|
|
|
short T_DOT_DATA::TurnZi() const{
|
|
return( s_TurnZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_Turn( const char* arg ){
|
|
strncpy((char*)c_Turn , arg , sizeof(c_Turn));
|
|
c_Turn[sizeof(c_Turn)-1] = '\0';
|
|
s_TurnZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_TurnZi( short arg ) {
|
|
s_TurnZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::StopStart() const{
|
|
return((char*)c_StopStart );
|
|
}
|
|
|
|
short T_DOT_DATA::StopStartZi() const{
|
|
return( s_StopStartZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopStart( char* arg ){
|
|
strncpy((char*)c_StopStart , arg , sizeof(c_StopStart));
|
|
c_StopStart[sizeof(c_StopStart)-1] = '\0';
|
|
s_StopStartZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopStartZi( short arg ) {
|
|
s_StopStartZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::StopEnd() const{
|
|
return((char*)c_StopEnd );
|
|
}
|
|
|
|
short T_DOT_DATA::StopEndZi() const{
|
|
return( s_StopEndZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopEnd( char* arg ){
|
|
strncpy((char*)c_StopEnd , arg , sizeof(c_StopEnd));
|
|
c_StopEnd[sizeof(c_StopEnd)-1] = '\0';
|
|
s_StopEndZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopEndZi( short arg ) {
|
|
s_StopEndZi = arg;
|
|
}
|
|
|
|
long T_DOT_DATA::StopElapsed() const{
|
|
return((long)l_StopElapsed );
|
|
}
|
|
|
|
short T_DOT_DATA::StopElapsedZi() const{
|
|
return( s_StopElapsedZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopElapsed( long arg ){
|
|
l_StopElapsed = arg;
|
|
s_StopElapsedZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_StopElapsedZi( short arg ) {
|
|
s_StopElapsedZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::Code() const{
|
|
return((char*)c_Code );
|
|
}
|
|
|
|
short T_DOT_DATA::CodeZi() const{
|
|
return( s_CodeZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_Code( const char* arg ){
|
|
strncpy((char*)c_Code , arg , sizeof(c_Code));
|
|
c_Code[sizeof(c_Code)-1] = '\0';
|
|
s_CodeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_CodeZi( short arg ) {
|
|
s_CodeZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::Status() const{
|
|
return((char*)c_Status );
|
|
}
|
|
|
|
short T_DOT_DATA::StatusZi() const{
|
|
return( s_StatusZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_Status( const char* arg ){
|
|
strncpy((char*)c_Status , arg , sizeof(c_Status));
|
|
c_Status[sizeof(c_Status)-1] = '\0';
|
|
s_StatusZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_StatusZi( short arg ) {
|
|
s_StatusZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::WorkLevel() const{
|
|
return((char*)c_WorkLevel );
|
|
}
|
|
|
|
short T_DOT_DATA::WorkLevelZi() const{
|
|
return( s_WorkLevelZi);
|
|
}
|
|
|
|
void T_DOT_DATA::set_WorkLevel( const char* arg ){
|
|
strncpy((char*)c_WorkLevel , arg , sizeof(c_WorkLevel));
|
|
c_WorkLevel[sizeof(c_WorkLevel)-1] = '\0';
|
|
s_WorkLevelZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DOT_DATA::set_WorkLevelZi( short arg ) {
|
|
s_WorkLevelZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_DOT_DATA::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_DOT_DATA::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_DOT_DATA::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_DOT_DATA::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_DOT_DATA::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_DOT_DATA::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_DOT_DATA::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_DOT_DATA::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_DOT_DATA::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_DOT_DATA::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_DOT_DATA::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_DOT_DATA::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_DOT_DATA::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_DOT_DATA::k_Seq(){
|
|
return((long)l_k_Seq );
|
|
}
|
|
|
|
void T_DOT_DATA::set_k_Seq( long arg ){
|
|
l_k_Seq = arg;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_DOT_DATA::fillStructure(){
|
|
structTable.Seq = Seq();
|
|
strncpy ( structTable.StopDate , StopDate(),sizeof(structTable.StopDate));
|
|
strncpy ( structTable.Shift , Shift(),sizeof(structTable.Shift));
|
|
strncpy ( structTable.Turn , Turn(),sizeof(structTable.Turn));
|
|
strncpy ( structTable.StopStart , StopStart(),sizeof(structTable.StopStart));
|
|
strncpy ( structTable.StopEnd , StopEnd(),sizeof(structTable.StopEnd));
|
|
structTable.StopElapsed = StopElapsed();
|
|
strncpy ( structTable.Code , Code(),sizeof(structTable.Code));
|
|
strncpy ( structTable.Status , Status(),sizeof(structTable.Status));
|
|
strncpy ( structTable.WorkLevel , WorkLevel(),sizeof(structTable.WorkLevel));
|
|
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_DOT_DATA::fillStructureZi(){
|
|
structTableZi.StopDateZi = StopDateZi();
|
|
structTableZi.ShiftZi = ShiftZi();
|
|
structTableZi.TurnZi = TurnZi();
|
|
structTableZi.StopStartZi = StopStartZi();
|
|
structTableZi.StopEndZi = StopEndZi();
|
|
structTableZi.StopElapsedZi = StopElapsedZi();
|
|
structTableZi.CodeZi = CodeZi();
|
|
structTableZi.StatusZi = StatusZi();
|
|
structTableZi.WorkLevelZi = WorkLevelZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_DOT_DATA::setStructure() {
|
|
set_StopDate( structTable.StopDate);
|
|
set_Shift( structTable.Shift);
|
|
set_Turn( structTable.Turn);
|
|
set_StopStart( structTable.StopStart);
|
|
set_StopEnd( structTable.StopEnd);
|
|
set_StopElapsed( structTable.StopElapsed);
|
|
set_Code( structTable.Code);
|
|
set_Status( structTable.Status);
|
|
set_WorkLevel( structTable.WorkLevel);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_DOT_DATA::setStructureZi() {
|
|
set_StopDateZi( structTableZi.StopDateZi);
|
|
set_ShiftZi( structTableZi.ShiftZi);
|
|
set_TurnZi( structTableZi.TurnZi);
|
|
set_StopStartZi( structTableZi.StopStartZi);
|
|
set_StopEndZi( structTableZi.StopEndZi);
|
|
set_StopElapsedZi( structTableZi.StopElapsedZi);
|
|
set_CodeZi( structTableZi.CodeZi);
|
|
set_StatusZi( structTableZi.StatusZi);
|
|
set_WorkLevelZi( structTableZi.WorkLevelZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_DOT_DATA::getName(){
|
|
return((char*)"T_DOT_DATA");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_DOT_DATA::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_DOT_DATA::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|