// Version:		2018.8.14  9:25:19

// File: T_TEL_RECV.cpp

#include "T_TEL_RECV.h"

T_TEL_RECV::T_TEL_RECV(){
//  initialise all membervariables
	initial();
}
T_TEL_RECV::~T_TEL_RECV(){
}
void T_TEL_RECV::initial(){
//  initialise all membervariables
	set_seq(0);
	set_RcvTime((char*)"");
	set_RcvTimeZi(-1);
	set_Counter(0);
	set_accessFlag(0);
	set_teleId((char*)"");
	set_extId((char*)"");
	set_eventno(0);
	set_sender((char*)"");
	set_senderZi(-1);
	set_telegramData((char*)"");
	set_telegramLength(0);
	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_TEL_RECV::T_TEL_RECV(long arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_TEL_RECV::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_TEL_RECV
//
//	this methode stores the unique key attributes
//
void T_TEL_RECV::setPrimKey( long arg1 ){
	l_k_seq = arg1;
} // end of methode

void T_TEL_RECV::initInsertKeys( long arg1 ){
	setPrimKey (  arg1);
	l_seq = arg1;
} // end of methode
void T_TEL_RECV::setKeysFromRecord(){
	set_k_seq( seq() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_TEL_RECV T_TEL_RECV::operator+(const T_TEL_RECV &inst) const{
	T_TEL_RECV ptrT_TEL_RECV(*this);
//----------------------------------------------------------
	ptrT_TEL_RECV.set_seq(inst.seq());
//----------------------------------------------------------
	if(inst.RcvTimeZi() != -1){
		ptrT_TEL_RECV.set_RcvTime(inst.RcvTime());
		ptrT_TEL_RECV.set_RcvTimeZi(inst.RcvTimeZi());
	}
//----------------------------------------------------------
	ptrT_TEL_RECV.set_Counter(inst.Counter());
//----------------------------------------------------------
	ptrT_TEL_RECV.set_accessFlag(inst.accessFlag());
//----------------------------------------------------------
	ptrT_TEL_RECV.set_teleId(inst.teleId());
//----------------------------------------------------------
	ptrT_TEL_RECV.set_extId(inst.extId());
//----------------------------------------------------------
	ptrT_TEL_RECV.set_eventno(inst.eventno());
//----------------------------------------------------------
	if(inst.senderZi() != -1){
		ptrT_TEL_RECV.set_sender(inst.sender());
		ptrT_TEL_RECV.set_senderZi(inst.senderZi());
	}
//----------------------------------------------------------
	ptrT_TEL_RECV.set_telegramData(inst.telegramData());
//----------------------------------------------------------
	ptrT_TEL_RECV.set_telegramLength(inst.telegramLength());
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_TEL_RECV.set_toc(inst.toc());
		ptrT_TEL_RECV.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_TEL_RECV.set_tom(inst.tom());
		ptrT_TEL_RECV.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_TEL_RECV.set_mop(inst.mop());
		ptrT_TEL_RECV.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_TEL_RECV.set_mou(inst.mou());
		ptrT_TEL_RECV.set_mouZi(inst.mouZi());
	}
	return (ptrT_TEL_RECV);
}

//
//O P E R A T O R  = 
//===================
//
const T_TEL_RECV& T_TEL_RECV::operator=(const T_TEL_RECV &inst){
//----------------------------------------------------------
	this->set_seq(inst.seq());
//----------------------------------------------------------
	this->set_RcvTime(inst.RcvTime());
	this->set_RcvTimeZi(inst.RcvTimeZi());
//----------------------------------------------------------
	this->set_Counter(inst.Counter());
//----------------------------------------------------------
	this->set_accessFlag(inst.accessFlag());
//----------------------------------------------------------
	this->set_teleId(inst.teleId());
//----------------------------------------------------------
	this->set_extId(inst.extId());
//----------------------------------------------------------
	this->set_eventno(inst.eventno());
//----------------------------------------------------------
	this->set_sender(inst.sender());
	this->set_senderZi(inst.senderZi());
//----------------------------------------------------------
	this->set_telegramData(inst.telegramData());
//----------------------------------------------------------
	this->set_telegramLength(inst.telegramLength());
//----------------------------------------------------------
	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_TEL_RECV::T_TEL_RECV(const T_TEL_RECV &inst){
//----------------------------------------------------------
	this->set_seq(inst.seq());
//----------------------------------------------------------
	this->set_RcvTime(inst.RcvTime());
	this->set_RcvTimeZi(inst.RcvTimeZi());
//----------------------------------------------------------
	this->set_Counter(inst.Counter());
//----------------------------------------------------------
	this->set_accessFlag(inst.accessFlag());
//----------------------------------------------------------
	this->set_teleId(inst.teleId());
//----------------------------------------------------------
	this->set_extId(inst.extId());
//----------------------------------------------------------
	this->set_eventno(inst.eventno());
//----------------------------------------------------------
	this->set_sender(inst.sender());
	this->set_senderZi(inst.senderZi());
//----------------------------------------------------------
	this->set_telegramData(inst.telegramData());
//----------------------------------------------------------
	this->set_telegramLength(inst.telegramLength());
//----------------------------------------------------------
	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_TEL_RECV::seq() const{
	return((long)l_seq );
}


void T_TEL_RECV::set_seq( long arg ){ 
	l_seq = arg;
	return;
}


char* T_TEL_RECV::RcvTime() const{
	return((char*)c_RcvTime );
}

short T_TEL_RECV::RcvTimeZi() const{
	return( s_RcvTimeZi);
}

void T_TEL_RECV::set_RcvTime( char* arg ){ 
	strncpy((char*)c_RcvTime , arg , sizeof(c_RcvTime));
	c_RcvTime[sizeof(c_RcvTime)-1] = '\0';
	s_RcvTimeZi=  0;
	return;
}

void T_TEL_RECV::set_RcvTimeZi( short arg ) {
	s_RcvTimeZi =  arg;
}

long T_TEL_RECV::Counter() const{
	return((long)l_Counter );
}


void T_TEL_RECV::set_Counter( long arg ){ 
	l_Counter = arg;
	return;
}


long T_TEL_RECV::accessFlag() const{
	return((long)l_accessFlag );
}


void T_TEL_RECV::set_accessFlag( long arg ){ 
	l_accessFlag = arg;
	return;
}


char* T_TEL_RECV::teleId() const{
	return((char*)c_teleId );
}


void T_TEL_RECV::set_teleId( const char* arg ){ 
	strncpy((char*)c_teleId , arg , sizeof(c_teleId));
	c_teleId[sizeof(c_teleId)-1] = '\0';
	return;
}


char* T_TEL_RECV::extId() const{
	return((char*)c_extId );
}


void T_TEL_RECV::set_extId( const char* arg ){ 
	strncpy((char*)c_extId , arg , sizeof(c_extId));
	c_extId[sizeof(c_extId)-1] = '\0';
	return;
}


long T_TEL_RECV::eventno() const{
	return((long)l_eventno );
}


void T_TEL_RECV::set_eventno( long arg ){ 
	l_eventno = arg;
	return;
}


char* T_TEL_RECV::sender() const{
	return((char*)c_sender );
}

short T_TEL_RECV::senderZi() const{
	return( s_senderZi);
}

void T_TEL_RECV::set_sender( const char* arg ){ 
	strncpy((char*)c_sender , arg , sizeof(c_sender));
	c_sender[sizeof(c_sender)-1] = '\0';
	s_senderZi=  0;
	return;
}

void T_TEL_RECV::set_senderZi( short arg ) {
	s_senderZi =  arg;
}

char* T_TEL_RECV::telegramData() const{
	return((char*)c_telegramData );
}


void T_TEL_RECV::set_telegramData( const char* arg ){ 
	strncpy((char*)c_telegramData , arg , sizeof(c_telegramData));
	c_telegramData[sizeof(c_telegramData)-1] = '\0';
	return;
}


long T_TEL_RECV::telegramLength() const{
	return((long)l_telegramLength );
}


void T_TEL_RECV::set_telegramLength( long arg ){ 
	l_telegramLength = arg;
	return;
}


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

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

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

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

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

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

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

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

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

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

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

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

// methodes for Primary key
long T_TEL_RECV::k_seq(){
	return((long)l_k_seq );
}

void T_TEL_RECV::set_k_seq( long arg ){
	l_k_seq =  arg;
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_TEL_RECV::fillStructure(){
	structTable.seq = seq();
	strncpy ( structTable.RcvTime , RcvTime(),sizeof(structTable.RcvTime));
	structTable.Counter = Counter();
	structTable.accessFlag = accessFlag();
	strncpy ( structTable.teleId , teleId(),sizeof(structTable.teleId));
	strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
	structTable.eventno = eventno();
	strncpy ( structTable.sender , sender(),sizeof(structTable.sender));
	strncpy ( structTable.telegramData , telegramData(),sizeof(structTable.telegramData));
	structTable.telegramLength = telegramLength();
	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_TEL_RECV::fillStructureZi(){
	structTableZi.RcvTimeZi = RcvTimeZi();
	structTableZi.senderZi = senderZi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_TEL_RECV::setStructure() {
	set_RcvTime( structTable.RcvTime);
	set_Counter( structTable.Counter);
	set_accessFlag( structTable.accessFlag);
	set_teleId( structTable.teleId);
	set_extId( structTable.extId);
	set_eventno( structTable.eventno);
	set_sender( structTable.sender);
	set_telegramData( structTable.telegramData);
	set_telegramLength( structTable.telegramLength);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_TEL_RECV::setStructureZi() {
	set_RcvTimeZi( structTableZi.RcvTimeZi);
	set_senderZi( structTableZi.senderZi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_TEL_RECV::getName(){
	return((char*)"T_TEL_RECV");
}
///////////////////////////////////////////////////
int T_TEL_RECV::getSqlCode(){
	return( db.dbSqlCode);
}
int T_TEL_RECV::getRowsProcessed(){
	return( db.dbRowsProcessed);
}