// Version:		2019.4.4  10:22:45

// File: T_LOG_INFO.cpp

#include "T_LOG_INFO.h"

T_LOG_INFO::T_LOG_INFO(){
//  initialise all membervariables
	initial();
}
T_LOG_INFO::~T_LOG_INFO(){
}
void T_LOG_INFO::initial(){
//  initialise all membervariables
	set_SeqNo(0);
	set_extId((char*)"");
	set_extIdZi(-1);
	set_HostName((char*)"");
	set_HostNameZi(-1);
	set_Information((char*)"");
	set_InformationZi(-1);
	set_IPADDR((char*)"");
	set_IPADDRZi(-1);
	set_LogLevel(0);
	set_LogLevelZi(-1);
	set_LogTime((char*)"");
	set_LogTimeZi(-1);
	set_Module((char*)"");
	set_ModuleZi(-1);
	set_UserID((char*)"");
	set_UserIDZi(-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_SeqNo(0);
}
T_LOG_INFO::T_LOG_INFO(long arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_LOG_INFO::initInsertKeys( long arg1 ){
	setPrimKey (  arg1);
	l_SeqNo = arg1;
} // end of methode
void T_LOG_INFO::setKeysFromRecord(){
	set_k_SeqNo( SeqNo() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_LOG_INFO T_LOG_INFO::operator+(const T_LOG_INFO &inst) const{
	T_LOG_INFO ptrT_LOG_INFO(*this);
//----------------------------------------------------------
	ptrT_LOG_INFO.set_SeqNo(inst.SeqNo());
//----------------------------------------------------------
	if(inst.extIdZi() != -1){
		ptrT_LOG_INFO.set_extId(inst.extId());
		ptrT_LOG_INFO.set_extIdZi(inst.extIdZi());
	}
//----------------------------------------------------------
	if(inst.HostNameZi() != -1){
		ptrT_LOG_INFO.set_HostName(inst.HostName());
		ptrT_LOG_INFO.set_HostNameZi(inst.HostNameZi());
	}
//----------------------------------------------------------
	if(inst.InformationZi() != -1){
		ptrT_LOG_INFO.set_Information(inst.Information());
		ptrT_LOG_INFO.set_InformationZi(inst.InformationZi());
	}
//----------------------------------------------------------
	if(inst.IPADDRZi() != -1){
		ptrT_LOG_INFO.set_IPADDR(inst.IPADDR());
		ptrT_LOG_INFO.set_IPADDRZi(inst.IPADDRZi());
	}
//----------------------------------------------------------
	if(inst.LogLevelZi() != -1){
		ptrT_LOG_INFO.set_LogLevel(inst.LogLevel());
		ptrT_LOG_INFO.set_LogLevelZi(inst.LogLevelZi());
	}
//----------------------------------------------------------
	if(inst.LogTimeZi() != -1){
		ptrT_LOG_INFO.set_LogTime(inst.LogTime());
		ptrT_LOG_INFO.set_LogTimeZi(inst.LogTimeZi());
	}
//----------------------------------------------------------
	if(inst.ModuleZi() != -1){
		ptrT_LOG_INFO.set_Module(inst.Module());
		ptrT_LOG_INFO.set_ModuleZi(inst.ModuleZi());
	}
//----------------------------------------------------------
	if(inst.UserIDZi() != -1){
		ptrT_LOG_INFO.set_UserID(inst.UserID());
		ptrT_LOG_INFO.set_UserIDZi(inst.UserIDZi());
	}
//----------------------------------------------------------
	if(inst.tocZi() != -1){
		ptrT_LOG_INFO.set_toc(inst.toc());
		ptrT_LOG_INFO.set_tocZi(inst.tocZi());
	}
//----------------------------------------------------------
	if(inst.tomZi() != -1){
		ptrT_LOG_INFO.set_tom(inst.tom());
		ptrT_LOG_INFO.set_tomZi(inst.tomZi());
	}
//----------------------------------------------------------
	if(inst.mopZi() != -1){
		ptrT_LOG_INFO.set_mop(inst.mop());
		ptrT_LOG_INFO.set_mopZi(inst.mopZi());
	}
//----------------------------------------------------------
	if(inst.mouZi() != -1){
		ptrT_LOG_INFO.set_mou(inst.mou());
		ptrT_LOG_INFO.set_mouZi(inst.mouZi());
	}
	return (ptrT_LOG_INFO);
}

//
//O P E R A T O R  = 
//===================
//
const T_LOG_INFO& T_LOG_INFO::operator=(const T_LOG_INFO &inst){
//----------------------------------------------------------
	this->set_SeqNo(inst.SeqNo());
//----------------------------------------------------------
	this->set_extId(inst.extId());
	this->set_extIdZi(inst.extIdZi());
//----------------------------------------------------------
	this->set_HostName(inst.HostName());
	this->set_HostNameZi(inst.HostNameZi());
//----------------------------------------------------------
	this->set_Information(inst.Information());
	this->set_InformationZi(inst.InformationZi());
//----------------------------------------------------------
	this->set_IPADDR(inst.IPADDR());
	this->set_IPADDRZi(inst.IPADDRZi());
//----------------------------------------------------------
	this->set_LogLevel(inst.LogLevel());
	this->set_LogLevelZi(inst.LogLevelZi());
//----------------------------------------------------------
	this->set_LogTime(inst.LogTime());
	this->set_LogTimeZi(inst.LogTimeZi());
//----------------------------------------------------------
	this->set_Module(inst.Module());
	this->set_ModuleZi(inst.ModuleZi());
//----------------------------------------------------------
	this->set_UserID(inst.UserID());
	this->set_UserIDZi(inst.UserIDZi());
//----------------------------------------------------------
	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_LOG_INFO::T_LOG_INFO(const T_LOG_INFO &inst){
//----------------------------------------------------------
	this->set_SeqNo(inst.SeqNo());
//----------------------------------------------------------
	this->set_extId(inst.extId());
	this->set_extIdZi(inst.extIdZi());
//----------------------------------------------------------
	this->set_HostName(inst.HostName());
	this->set_HostNameZi(inst.HostNameZi());
//----------------------------------------------------------
	this->set_Information(inst.Information());
	this->set_InformationZi(inst.InformationZi());
//----------------------------------------------------------
	this->set_IPADDR(inst.IPADDR());
	this->set_IPADDRZi(inst.IPADDRZi());
//----------------------------------------------------------
	this->set_LogLevel(inst.LogLevel());
	this->set_LogLevelZi(inst.LogLevelZi());
//----------------------------------------------------------
	this->set_LogTime(inst.LogTime());
	this->set_LogTimeZi(inst.LogTimeZi());
//----------------------------------------------------------
	this->set_Module(inst.Module());
	this->set_ModuleZi(inst.ModuleZi());
//----------------------------------------------------------
	this->set_UserID(inst.UserID());
	this->set_UserIDZi(inst.UserIDZi());
//----------------------------------------------------------
	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_LOG_INFO::SeqNo() const{
	return((long)l_SeqNo );
}


void T_LOG_INFO::set_SeqNo( long arg ){ 
	l_SeqNo = arg;
	return;
}


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

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

void T_LOG_INFO::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_LOG_INFO::set_extIdZi( short arg ) {
	s_extIdZi =  arg;
}

char* T_LOG_INFO::HostName() const{
	return((char*)c_HostName );
}

short T_LOG_INFO::HostNameZi() const{
	return( s_HostNameZi);
}

void T_LOG_INFO::set_HostName( const char* arg ){ 
	strncpy((char*)c_HostName , arg , sizeof(c_HostName));
	c_HostName[sizeof(c_HostName)-1] = '\0';
	s_HostNameZi=  0;
	return;
}

void T_LOG_INFO::set_HostNameZi( short arg ) {
	s_HostNameZi =  arg;
}

char* T_LOG_INFO::Information() const{
	return((char*)c_Information );
}

short T_LOG_INFO::InformationZi() const{
	return( s_InformationZi);
}

void T_LOG_INFO::set_Information( const char* arg ){ 
	strncpy((char*)c_Information , arg , sizeof(c_Information));
	c_Information[sizeof(c_Information)-1] = '\0';
	s_InformationZi=  0;
	return;
}

void T_LOG_INFO::set_InformationZi( short arg ) {
	s_InformationZi =  arg;
}

char* T_LOG_INFO::IPADDR() const{
	return((char*)c_IPADDR );
}

short T_LOG_INFO::IPADDRZi() const{
	return( s_IPADDRZi);
}

void T_LOG_INFO::set_IPADDR( const char* arg ){ 
	strncpy((char*)c_IPADDR , arg , sizeof(c_IPADDR));
	c_IPADDR[sizeof(c_IPADDR)-1] = '\0';
	s_IPADDRZi=  0;
	return;
}

void T_LOG_INFO::set_IPADDRZi( short arg ) {
	s_IPADDRZi =  arg;
}

long T_LOG_INFO::LogLevel() const{
	return((long)l_LogLevel );
}

short T_LOG_INFO::LogLevelZi() const{
	return( s_LogLevelZi);
}

void T_LOG_INFO::set_LogLevel( long arg ){ 
	l_LogLevel = arg;
	s_LogLevelZi=  0;
	return;
}

void T_LOG_INFO::set_LogLevelZi( short arg ) {
	s_LogLevelZi =  arg;
}

char* T_LOG_INFO::LogTime() const{
	return((char*)c_LogTime );
}

short T_LOG_INFO::LogTimeZi() const{
	return( s_LogTimeZi);
}

void T_LOG_INFO::set_LogTime( char* arg ){ 
	strncpy((char*)c_LogTime , arg , sizeof(c_LogTime));
	c_LogTime[sizeof(c_LogTime)-1] = '\0';
	s_LogTimeZi=  0;
	return;
}

void T_LOG_INFO::set_LogTimeZi( short arg ) {
	s_LogTimeZi =  arg;
}

char* T_LOG_INFO::Module() const{
	return((char*)c_Module );
}

short T_LOG_INFO::ModuleZi() const{
	return( s_ModuleZi);
}

void T_LOG_INFO::set_Module( const char* arg ){ 
	strncpy((char*)c_Module , arg , sizeof(c_Module));
	c_Module[sizeof(c_Module)-1] = '\0';
	s_ModuleZi=  0;
	return;
}

void T_LOG_INFO::set_ModuleZi( short arg ) {
	s_ModuleZi =  arg;
}

char* T_LOG_INFO::UserID() const{
	return((char*)c_UserID );
}

short T_LOG_INFO::UserIDZi() const{
	return( s_UserIDZi);
}

void T_LOG_INFO::set_UserID( const char* arg ){ 
	strncpy((char*)c_UserID , arg , sizeof(c_UserID));
	c_UserID[sizeof(c_UserID)-1] = '\0';
	s_UserIDZi=  0;
	return;
}

void T_LOG_INFO::set_UserIDZi( short arg ) {
	s_UserIDZi =  arg;
}

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

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

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

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

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

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

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

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

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

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

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

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

// methodes for Primary key
long T_LOG_INFO::k_SeqNo(){
	return((long)l_k_SeqNo );
}

void T_LOG_INFO::set_k_SeqNo( long arg ){
	l_k_SeqNo =  arg;
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_LOG_INFO::fillStructure(){
	structTable.SeqNo = SeqNo();
	strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
	strncpy ( structTable.HostName , HostName(),sizeof(structTable.HostName));
	strncpy ( structTable.Information , Information(),sizeof(structTable.Information));
	strncpy ( structTable.IPADDR , IPADDR(),sizeof(structTable.IPADDR));
	structTable.LogLevel = LogLevel();
	strncpy ( structTable.LogTime , LogTime(),sizeof(structTable.LogTime));
	strncpy ( structTable.Module , Module(),sizeof(structTable.Module));
	strncpy ( structTable.UserID , UserID(),sizeof(structTable.UserID));
	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_LOG_INFO::fillStructureZi(){
	structTableZi.extIdZi = extIdZi();
	structTableZi.HostNameZi = HostNameZi();
	structTableZi.InformationZi = InformationZi();
	structTableZi.IPADDRZi = IPADDRZi();
	structTableZi.LogLevelZi = LogLevelZi();
	structTableZi.LogTimeZi = LogTimeZi();
	structTableZi.ModuleZi = ModuleZi();
	structTableZi.UserIDZi = UserIDZi();
	structTableZi.tocZi = tocZi();
	structTableZi.tomZi = tomZi();
	structTableZi.mopZi = mopZi();
	structTableZi.mouZi = mouZi();
	return;
}
///////////////////////////////////////////////////
void T_LOG_INFO::setStructure() {
	set_extId( structTable.extId);
	set_HostName( structTable.HostName);
	set_Information( structTable.Information);
	set_IPADDR( structTable.IPADDR);
	set_LogLevel( structTable.LogLevel);
	set_LogTime( structTable.LogTime);
	set_Module( structTable.Module);
	set_UserID( structTable.UserID);
	set_toc(structTable.toc);
	set_tom(structTable.tom);
	set_mop(structTable.mop);
	set_mou(structTable.mou);
	return;
}
///////////////////////////////////////////////////
void T_LOG_INFO::setStructureZi() {
	set_extIdZi( structTableZi.extIdZi);
	set_HostNameZi( structTableZi.HostNameZi);
	set_InformationZi( structTableZi.InformationZi);
	set_IPADDRZi( structTableZi.IPADDRZi);
	set_LogLevelZi( structTableZi.LogLevelZi);
	set_LogTimeZi( structTableZi.LogTimeZi);
	set_ModuleZi( structTableZi.ModuleZi);
	set_UserIDZi( structTableZi.UserIDZi);
	set_tocZi(structTableZi.tocZi);
	set_tomZi(structTableZi.tomZi);
	set_mopZi(structTableZi.mopZi);
	set_mouZi(structTableZi.mouZi);
	return;
}
///////////////////////////////////////////////////
char* T_LOG_INFO::getName(){
	return((char*)"T_LOG_INFO");
}
///////////////////////////////////////////////////
int T_LOG_INFO::getSqlCode(){
	return( db.dbSqlCode);
}
int T_LOG_INFO::getRowsProcessed(){
	return( db.dbRowsProcessed);
}