// Version:		2018.8.14  9:25:19

// File: T_TEL_SEND.cpp

#include "T_TEL_SEND.h"

T_TEL_SEND::T_TEL_SEND(){
//  initialise all membervariables
	initial();
}
T_TEL_SEND::~T_TEL_SEND(){
}
void T_TEL_SEND::initial(){
//  initialise all membervariables
	set_seq(0);
	set_sndTime((char*)"");
	set_sndTimeZi(-1);
	set_accessFlag(0);
	set_accessFlagZi(-1);
	set_extId((char*)"");
	set_extIdZi(-1);
	set_teleId((char*)"");
	set_eventNo(0);
	set_eventNoZi(-1);
	set_telegramData((char*)"");
	set_telegramDataZi(-1);
	set_telegramLength(0);
	set_telegramLengthZi(-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_TEL_SEND::T_TEL_SEND(long arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_TEL_SEND::initInsertKeys( long arg1 ){
	setPrimKey (  arg1);
	l_seq = arg1;
} // end of methode
void T_TEL_SEND::setKeysFromRecord(){
	set_k_seq( seq() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_TEL_SEND T_TEL_SEND::operator+(const T_TEL_SEND &inst) const{
	T_TEL_SEND ptrT_TEL_SEND(*this);
//----------------------------------------------------------
	ptrT_TEL_SEND.set_seq(inst.seq());
//----------------------------------------------------------
	if(inst.sndTimeZi() != -1){
		ptrT_TEL_SEND.set_sndTime(inst.sndTime());
		ptrT_TEL_SEND.set_sndTimeZi(inst.sndTimeZi());
	}
//----------------------------------------------------------
	if(inst.accessFlagZi() != -1){
		ptrT_TEL_SEND.set_accessFlag(inst.accessFlag());
		ptrT_TEL_SEND.set_accessFlagZi(inst.accessFlagZi());
	}
//----------------------------------------------------------
	if(inst.extIdZi() != -1){
		ptrT_TEL_SEND.set_extId(inst.extId());
		ptrT_TEL_SEND.set_extIdZi(inst.extIdZi());
	}
//----------------------------------------------------------
	ptrT_TEL_SEND.set_teleId(inst.teleId());
//----------------------------------------------------------
	if(inst.eventNoZi() != -1){
		ptrT_TEL_SEND.set_eventNo(inst.eventNo());
		ptrT_TEL_SEND.set_eventNoZi(inst.eventNoZi());
	}
//----------------------------------------------------------
	if(inst.telegramDataZi() != -1){
		ptrT_TEL_SEND.set_telegramData(inst.telegramData());
		ptrT_TEL_SEND.set_telegramDataZi(inst.telegramDataZi());
	}
//----------------------------------------------------------
	if(inst.telegramLengthZi() != -1){
		ptrT_TEL_SEND.set_telegramLength(inst.telegramLength());
		ptrT_TEL_SEND.set_telegramLengthZi(inst.telegramLengthZi());
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_TEL_SEND.set_toc(inst.toc());
		ptrT_TEL_SEND.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_TEL_SEND.set_tom(inst.tom());
		ptrT_TEL_SEND.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_TEL_SEND.set_mop(inst.mop());
		ptrT_TEL_SEND.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_TEL_SEND.set_mou(inst.mou());
		ptrT_TEL_SEND.set_mouZi(inst.mouZi());
	}
	return (ptrT_TEL_SEND);
}

//
//O P E R A T O R  = 
//===================
//
const T_TEL_SEND& T_TEL_SEND::operator=(const T_TEL_SEND &inst){
//----------------------------------------------------------
	this->set_seq(inst.seq());
//----------------------------------------------------------
	this->set_sndTime(inst.sndTime());
	this->set_sndTimeZi(inst.sndTimeZi());
//----------------------------------------------------------
	this->set_accessFlag(inst.accessFlag());
	this->set_accessFlagZi(inst.accessFlagZi());
//----------------------------------------------------------
	this->set_extId(inst.extId());
	this->set_extIdZi(inst.extIdZi());
//----------------------------------------------------------
	this->set_teleId(inst.teleId());
//----------------------------------------------------------
	this->set_eventNo(inst.eventNo());
	this->set_eventNoZi(inst.eventNoZi());
//----------------------------------------------------------
	this->set_telegramData(inst.telegramData());
	this->set_telegramDataZi(inst.telegramDataZi());
//----------------------------------------------------------
	this->set_telegramLength(inst.telegramLength());
	this->set_telegramLengthZi(inst.telegramLengthZi());
//----------------------------------------------------------
	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_SEND::T_TEL_SEND(const T_TEL_SEND &inst){
//----------------------------------------------------------
	this->set_seq(inst.seq());
//----------------------------------------------------------
	this->set_sndTime(inst.sndTime());
	this->set_sndTimeZi(inst.sndTimeZi());
//----------------------------------------------------------
	this->set_accessFlag(inst.accessFlag());
	this->set_accessFlagZi(inst.accessFlagZi());
//----------------------------------------------------------
	this->set_extId(inst.extId());
	this->set_extIdZi(inst.extIdZi());
//----------------------------------------------------------
	this->set_teleId(inst.teleId());
//----------------------------------------------------------
	this->set_eventNo(inst.eventNo());
	this->set_eventNoZi(inst.eventNoZi());
//----------------------------------------------------------
	this->set_telegramData(inst.telegramData());
	this->set_telegramDataZi(inst.telegramDataZi());
//----------------------------------------------------------
	this->set_telegramLength(inst.telegramLength());
	this->set_telegramLengthZi(inst.telegramLengthZi());
//----------------------------------------------------------
	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_SEND::seq() const{
	return((long)l_seq );
}


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


char* T_TEL_SEND::sndTime() const{
	return((char*)c_sndTime );
}

short T_TEL_SEND::sndTimeZi() const{
	return( s_sndTimeZi);
}

void T_TEL_SEND::set_sndTime( char* arg ){ 
	strncpy((char*)c_sndTime , arg , sizeof(c_sndTime));
	c_sndTime[sizeof(c_sndTime)-1] = '\0';
	s_sndTimeZi=  0;
	return;
}

void T_TEL_SEND::set_sndTimeZi( short arg ) {
	s_sndTimeZi =  arg;
}

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

short T_TEL_SEND::accessFlagZi() const{
	return( s_accessFlagZi);
}

void T_TEL_SEND::set_accessFlag( long arg ){ 
	l_accessFlag = arg;
	s_accessFlagZi=  0;
	return;
}

void T_TEL_SEND::set_accessFlagZi( short arg ) {
	s_accessFlagZi =  arg;
}

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

short T_TEL_SEND::extIdZi() const{
	return( s_extIdZi);
}

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

void T_TEL_SEND::set_extIdZi( short arg ) {
	s_extIdZi =  arg;
}

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


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


long T_TEL_SEND::eventNo() const{
	return((long)l_eventNo );
}

short T_TEL_SEND::eventNoZi() const{
	return( s_eventNoZi);
}

void T_TEL_SEND::set_eventNo( long arg ){ 
	l_eventNo = arg;
	s_eventNoZi=  0;
	return;
}

void T_TEL_SEND::set_eventNoZi( short arg ) {
	s_eventNoZi =  arg;
}

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

short T_TEL_SEND::telegramDataZi() const{
	return( s_telegramDataZi);
}

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

void T_TEL_SEND::set_telegramDataZi( short arg ) {
	s_telegramDataZi =  arg;
}

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

short T_TEL_SEND::telegramLengthZi() const{
	return( s_telegramLengthZi);
}

void T_TEL_SEND::set_telegramLength( long arg ){ 
	l_telegramLength = arg;
	s_telegramLengthZi=  0;
	return;
}

void T_TEL_SEND::set_telegramLengthZi( short arg ) {
	s_telegramLengthZi =  arg;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_TEL_SEND::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_SEND::fillStructure(){
	structTable.seq = seq();
	strncpy ( structTable.sndTime , sndTime(),sizeof(structTable.sndTime));
	structTable.accessFlag = accessFlag();
	strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
	strncpy ( structTable.teleId , teleId(),sizeof(structTable.teleId));
	structTable.eventNo = eventNo();
	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_SEND::fillStructureZi(){
	structTableZi.sndTimeZi = sndTimeZi();
	structTableZi.accessFlagZi = accessFlagZi();
	structTableZi.extIdZi = extIdZi();
	structTableZi.eventNoZi = eventNoZi();
	structTableZi.telegramDataZi = telegramDataZi();
	structTableZi.telegramLengthZi = telegramLengthZi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_TEL_SEND::setStructure() {
	set_sndTime( structTable.sndTime);
	set_accessFlag( structTable.accessFlag);
	set_extId( structTable.extId);
	set_teleId( structTable.teleId);
	set_eventNo( structTable.eventNo);
	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_SEND::setStructureZi() {
	set_sndTimeZi( structTableZi.sndTimeZi);
	set_accessFlagZi( structTableZi.accessFlagZi);
	set_extIdZi( structTableZi.extIdZi);
	set_eventNoZi( structTableZi.eventNoZi);
	set_telegramDataZi( structTableZi.telegramDataZi);
	set_telegramLengthZi( structTableZi.telegramLengthZi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_TEL_SEND::getName(){
	return((char*)"T_TEL_SEND");
}
///////////////////////////////////////////////////
int T_TEL_SEND::getSqlCode(){
	return( db.dbSqlCode);
}
int T_TEL_SEND::getRowsProcessed(){
	return( db.dbRowsProcessed);
}