// Version:		2014.7.30  16:47:28

// File: T_TRK_BREAK.cpp

#include "T_TRK_BREAK.h"

T_TRK_BREAK::T_TRK_BREAK(){
//  initialise all membervariables
	initial();
}
T_TRK_BREAK::~T_TRK_BREAK(){
}
void T_TRK_BREAK::initial(){
//  initialise all membervariables
	set_muId(0);
	set_muCreator("");
	set_posInOldMu(0);
	set_breakageTime("");
	set_breakageTimeZi(-1);
	set_lookBack(0);
	set_newMuCreator("");
	set_newMuCreatorZi(-1);
	set_newMuId(0);
	set_newMuIdZi(-1);
	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_posInOldMu(0);
}
T_TRK_BREAK::T_TRK_BREAK(long arg1,const char* arg2,long arg3)
{
	initial();
	setPrimKey (arg1, arg2, arg3);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_TRK_BREAK::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_BREAK
//
//	this methode stores the unique key attributes
//
void T_TRK_BREAK::setPrimKey( long arg1 , const char* arg2 , long arg3 ){
	l_k_muId = arg1;
	strncpy( (char*)c_k_muCreator , arg2 , sizeof(c_k_muCreator) );
	c_k_muCreator[sizeof(c_k_muCreator)-1] = '\0';
	l_k_posInOldMu = arg3;
} // end of methode

void T_TRK_BREAK::initInsertKeys( long arg1 , const char* arg2 , long arg3 ){
	setPrimKey (  arg1 , arg2 , arg3);
	l_muId = arg1;
	strncpy( (char*)c_muCreator , arg2 , sizeof(c_muCreator) );
	c_muCreator[sizeof(c_muCreator)-1] = '\0';
	l_posInOldMu = arg3;
} // end of methode
void T_TRK_BREAK::setKeysFromRecord(){
	set_k_muId( muId() );
	set_k_muCreator( muCreator() );
	set_k_posInOldMu( posInOldMu() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_TRK_BREAK T_TRK_BREAK::operator+(const T_TRK_BREAK &inst) const{
	T_TRK_BREAK ptrT_TRK_BREAK(*this);
//----------------------------------------------------------
	ptrT_TRK_BREAK.set_muId(inst.muId());
//----------------------------------------------------------
	ptrT_TRK_BREAK.set_muCreator(inst.muCreator());
//----------------------------------------------------------
	ptrT_TRK_BREAK.set_posInOldMu(inst.posInOldMu());
//----------------------------------------------------------
	if(inst.breakageTimeZi() != -1){
		ptrT_TRK_BREAK.set_breakageTime(inst.breakageTime());
		ptrT_TRK_BREAK.set_breakageTimeZi(inst.breakageTimeZi());
	}
//----------------------------------------------------------
	ptrT_TRK_BREAK.set_lookBack(inst.lookBack());
//----------------------------------------------------------
	if(inst.newMuCreatorZi() != -1){
		ptrT_TRK_BREAK.set_newMuCreator(inst.newMuCreator());
		ptrT_TRK_BREAK.set_newMuCreatorZi(inst.newMuCreatorZi());
	}
//----------------------------------------------------------
	if(inst.newMuIdZi() != -1){
		ptrT_TRK_BREAK.set_newMuId(inst.newMuId());
		ptrT_TRK_BREAK.set_newMuIdZi(inst.newMuIdZi());
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_TRK_BREAK.set_toc(inst.toc());
		ptrT_TRK_BREAK.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_TRK_BREAK.set_tom(inst.tom());
		ptrT_TRK_BREAK.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_TRK_BREAK.set_mop(inst.mop());
		ptrT_TRK_BREAK.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_TRK_BREAK.set_mou(inst.mou());
		ptrT_TRK_BREAK.set_mouZi(inst.mouZi());
	}
	return (ptrT_TRK_BREAK);
}

//
//O P E R A T O R  = 
//===================
//
const T_TRK_BREAK& T_TRK_BREAK::operator=(const T_TRK_BREAK &inst){
//----------------------------------------------------------
	this->set_muId(inst.muId());
//----------------------------------------------------------
	this->set_muCreator(inst.muCreator());
//----------------------------------------------------------
	this->set_posInOldMu(inst.posInOldMu());
//----------------------------------------------------------
	this->set_breakageTime(inst.breakageTime());
	this->set_breakageTimeZi(inst.breakageTimeZi());
//----------------------------------------------------------
	this->set_lookBack(inst.lookBack());
//----------------------------------------------------------
	this->set_newMuCreator(inst.newMuCreator());
	this->set_newMuCreatorZi(inst.newMuCreatorZi());
//----------------------------------------------------------
	this->set_newMuId(inst.newMuId());
	this->set_newMuIdZi(inst.newMuIdZi());
//----------------------------------------------------------
	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_BREAK::T_TRK_BREAK(const T_TRK_BREAK &inst){
//----------------------------------------------------------
	this->set_muId(inst.muId());
//----------------------------------------------------------
	this->set_muCreator(inst.muCreator());
//----------------------------------------------------------
	this->set_posInOldMu(inst.posInOldMu());
//----------------------------------------------------------
	this->set_breakageTime(inst.breakageTime());
	this->set_breakageTimeZi(inst.breakageTimeZi());
//----------------------------------------------------------
	this->set_lookBack(inst.lookBack());
//----------------------------------------------------------
	this->set_newMuCreator(inst.newMuCreator());
	this->set_newMuCreatorZi(inst.newMuCreatorZi());
//----------------------------------------------------------
	this->set_newMuId(inst.newMuId());
	this->set_newMuIdZi(inst.newMuIdZi());
//----------------------------------------------------------
	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_BREAK::muId() const{
	return((long)l_muId );
}


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


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


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


long T_TRK_BREAK::posInOldMu() const{
	return((long)l_posInOldMu );
}


void T_TRK_BREAK::set_posInOldMu( long arg ){ 
	l_posInOldMu = arg;
	return;
}


char* T_TRK_BREAK::breakageTime() const{
	return((char*)c_breakageTime );
}

short T_TRK_BREAK::breakageTimeZi() const{
	return( s_breakageTimeZi);
}

void T_TRK_BREAK::set_breakageTime( char* arg ){ 
	strncpy((char*)c_breakageTime , arg , sizeof(c_breakageTime));
	c_breakageTime[sizeof(c_breakageTime)-1] = '\0';
	s_breakageTimeZi=  0;
	return;
}

void T_TRK_BREAK::set_breakageTimeZi( short arg ) {
	s_breakageTimeZi =  arg;
}

long T_TRK_BREAK::lookBack() const{
	return((long)l_lookBack );
}


void T_TRK_BREAK::set_lookBack( long arg ){ 
	l_lookBack = arg;
	return;
}


char* T_TRK_BREAK::newMuCreator() const{
	return((char*)c_newMuCreator );
}

short T_TRK_BREAK::newMuCreatorZi() const{
	return( s_newMuCreatorZi);
}

void T_TRK_BREAK::set_newMuCreator( const char* arg ){ 
	strncpy((char*)c_newMuCreator , arg , sizeof(c_newMuCreator));
	c_newMuCreator[sizeof(c_newMuCreator)-1] = '\0';
	s_newMuCreatorZi=  0;
	return;
}

void T_TRK_BREAK::set_newMuCreatorZi( short arg ) {
	s_newMuCreatorZi =  arg;
}

long T_TRK_BREAK::newMuId() const{
	return((long)l_newMuId );
}

short T_TRK_BREAK::newMuIdZi() const{
	return( s_newMuIdZi);
}

void T_TRK_BREAK::set_newMuId( long arg ){ 
	l_newMuId = arg;
	s_newMuIdZi=  0;
	return;
}

void T_TRK_BREAK::set_newMuIdZi( short arg ) {
	s_newMuIdZi =  arg;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_TRK_BREAK::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;
}

long T_TRK_BREAK::k_posInOldMu(){
	return((long)l_k_posInOldMu );
}

void T_TRK_BREAK::set_k_posInOldMu( long arg ){
	l_k_posInOldMu =  arg;
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_TRK_BREAK::fillStructure(){
	structTable.muId = muId();
	strncpy ( structTable.muCreator , muCreator(),sizeof(structTable.muCreator));
	structTable.posInOldMu = posInOldMu();
	strncpy ( structTable.breakageTime , breakageTime(),sizeof(structTable.breakageTime));
	structTable.lookBack = lookBack();
	strncpy ( structTable.newMuCreator , newMuCreator(),sizeof(structTable.newMuCreator));
	structTable.newMuId = newMuId();
	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_BREAK::fillStructureZi(){
	structTableZi.breakageTimeZi = breakageTimeZi();
	structTableZi.newMuCreatorZi = newMuCreatorZi();
	structTableZi.newMuIdZi = newMuIdZi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_TRK_BREAK::setStructure() {
	set_breakageTime( structTable.breakageTime);
	set_lookBack( structTable.lookBack);
	set_newMuCreator( structTable.newMuCreator);
	set_newMuId( structTable.newMuId);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_TRK_BREAK::setStructureZi() {
	set_breakageTimeZi( structTableZi.breakageTimeZi);
	set_newMuCreatorZi( structTableZi.newMuCreatorZi);
	set_newMuIdZi( structTableZi.newMuIdZi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_TRK_BREAK::getName(){
	return("T_TRK_BREAK");
}
///////////////////////////////////////////////////
int T_TRK_BREAK::getSqlCode(){
	return( db.dbSqlCode);
}
int T_TRK_BREAK::getRowsProcessed(){
	return( db.dbRowsProcessed);
}