// 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);
}