// Version:		2021.3.3  10:24:15

// File: T_RULE_RESULT.cpp

#include "T_RULE_RESULT.h"

T_RULE_RESULT::T_RULE_RESULT(){
//  initialise all membervariables
	initial();
}
T_RULE_RESULT::~T_RULE_RESULT(){
}
void T_RULE_RESULT::initial(){
//  initialise all membervariables
	set_RuleBTime((char*)"");
	set_RuleId((char*)"");
	set_RuleGroup((char*)"");
	set_RuleName((char*)"");
	set_RuleNameZi(-1);
	set_Result((char*)"");
	set_ResultZi(-1);
	set_DealResult(0);
	set_DealResultZi(-1);
	set_RuleETime((char*)"");
	set_RuleETimeZi(-1);
	set_DealTime((char*)"");
	set_DealTimeZi(-1);
// initialies Primary key members
	set_k_RuleBTime((char*)"");
	set_k_RuleId((char*)"");
	set_k_RuleGroup((char*)"");
}
T_RULE_RESULT::T_RULE_RESULT(char* arg1,const char* arg2,const char* arg3)
{
	initial();
	setPrimKey (arg1, arg2, arg3);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

char* T_RULE_RESULT::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_RULE_RESULT
//
//	this methode stores the unique key attributes
//
void T_RULE_RESULT::setPrimKey( char* arg1 , const char* arg2 , const char* arg3 ){
	strncpy( (char*)c_k_RuleBTime , arg1 , sizeof(c_k_RuleBTime) );
	c_k_RuleBTime[sizeof(c_k_RuleBTime)-1] = '\0';
	strncpy( (char*)c_k_RuleId , arg2 , sizeof(c_k_RuleId) );
	c_k_RuleId[sizeof(c_k_RuleId)-1] = '\0';
	strncpy( (char*)c_k_RuleGroup , arg3 , sizeof(c_k_RuleGroup) );
	c_k_RuleGroup[sizeof(c_k_RuleGroup)-1] = '\0';
} // end of methode

void T_RULE_RESULT::initInsertKeys( char* arg1 , const char* arg2 , const char* arg3 ){
	setPrimKey (  arg1 , arg2 , arg3);
	strncpy( (char*)c_RuleBTime , arg1 , sizeof(c_RuleBTime) );
	c_RuleBTime[sizeof(c_RuleBTime)-1] = '\0';
	strncpy( (char*)c_RuleId , arg2 , sizeof(c_RuleId) );
	c_RuleId[sizeof(c_RuleId)-1] = '\0';
	strncpy( (char*)c_RuleGroup , arg3 , sizeof(c_RuleGroup) );
	c_RuleGroup[sizeof(c_RuleGroup)-1] = '\0';
} // end of methode
void T_RULE_RESULT::setKeysFromRecord(){
	set_k_RuleBTime( RuleBTime() );
	set_k_RuleId( RuleId() );
	set_k_RuleGroup( RuleGroup() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_RULE_RESULT T_RULE_RESULT::operator+(const T_RULE_RESULT &inst) const{
	T_RULE_RESULT ptrT_RULE_RESULT(*this);
//----------------------------------------------------------
	ptrT_RULE_RESULT.set_RuleBTime(inst.RuleBTime());
//----------------------------------------------------------
	ptrT_RULE_RESULT.set_RuleId(inst.RuleId());
//----------------------------------------------------------
	ptrT_RULE_RESULT.set_RuleGroup(inst.RuleGroup());
//----------------------------------------------------------
	if(inst.RuleNameZi() != -1){
		ptrT_RULE_RESULT.set_RuleName(inst.RuleName());
		ptrT_RULE_RESULT.set_RuleNameZi(inst.RuleNameZi());
	}
//----------------------------------------------------------
	if(inst.ResultZi() != -1){
		ptrT_RULE_RESULT.set_Result(inst.Result());
		ptrT_RULE_RESULT.set_ResultZi(inst.ResultZi());
	}
//----------------------------------------------------------
	if(inst.DealResultZi() != -1){
		ptrT_RULE_RESULT.set_DealResult(inst.DealResult());
		ptrT_RULE_RESULT.set_DealResultZi(inst.DealResultZi());
	}
//----------------------------------------------------------
	if(inst.RuleETimeZi() != -1){
		ptrT_RULE_RESULT.set_RuleETime(inst.RuleETime());
		ptrT_RULE_RESULT.set_RuleETimeZi(inst.RuleETimeZi());
	}
//----------------------------------------------------------
	if(inst.DealTimeZi() != -1){
		ptrT_RULE_RESULT.set_DealTime(inst.DealTime());
		ptrT_RULE_RESULT.set_DealTimeZi(inst.DealTimeZi());
	}
	return (ptrT_RULE_RESULT);
}

//
//O P E R A T O R  = 
//===================
//
const T_RULE_RESULT& T_RULE_RESULT::operator=(const T_RULE_RESULT &inst){
//----------------------------------------------------------
	this->set_RuleBTime(inst.RuleBTime());
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_RuleGroup(inst.RuleGroup());
//----------------------------------------------------------
	this->set_RuleName(inst.RuleName());
	this->set_RuleNameZi(inst.RuleNameZi());
//----------------------------------------------------------
	this->set_Result(inst.Result());
	this->set_ResultZi(inst.ResultZi());
//----------------------------------------------------------
	this->set_DealResult(inst.DealResult());
	this->set_DealResultZi(inst.DealResultZi());
//----------------------------------------------------------
	this->set_RuleETime(inst.RuleETime());
	this->set_RuleETimeZi(inst.RuleETimeZi());
//----------------------------------------------------------
	this->set_DealTime(inst.DealTime());
	this->set_DealTimeZi(inst.DealTimeZi());
	return (*this);
}
//
//C O P Y - C O N S T R U C T O R
//===================
//
T_RULE_RESULT::T_RULE_RESULT(const T_RULE_RESULT &inst){
//----------------------------------------------------------
	this->set_RuleBTime(inst.RuleBTime());
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_RuleGroup(inst.RuleGroup());
//----------------------------------------------------------
	this->set_RuleName(inst.RuleName());
	this->set_RuleNameZi(inst.RuleNameZi());
//----------------------------------------------------------
	this->set_Result(inst.Result());
	this->set_ResultZi(inst.ResultZi());
//----------------------------------------------------------
	this->set_DealResult(inst.DealResult());
	this->set_DealResultZi(inst.DealResultZi());
//----------------------------------------------------------
	this->set_RuleETime(inst.RuleETime());
	this->set_RuleETimeZi(inst.RuleETimeZi());
//----------------------------------------------------------
	this->set_DealTime(inst.DealTime());
	this->set_DealTimeZi(inst.DealTimeZi());
}
char* T_RULE_RESULT::RuleBTime() const{
	return((char*)c_RuleBTime );
}


void T_RULE_RESULT::set_RuleBTime( char* arg ){ 
	strncpy((char*)c_RuleBTime , arg , sizeof(c_RuleBTime));
	c_RuleBTime[sizeof(c_RuleBTime)-1] = '\0';
	return;
}


char* T_RULE_RESULT::RuleId() const{
	return((char*)c_RuleId );
}


void T_RULE_RESULT::set_RuleId( const char* arg ){ 
	strncpy((char*)c_RuleId , arg , sizeof(c_RuleId));
	c_RuleId[sizeof(c_RuleId)-1] = '\0';
	return;
}


char* T_RULE_RESULT::RuleGroup() const{
	return((char*)c_RuleGroup );
}


void T_RULE_RESULT::set_RuleGroup( const char* arg ){ 
	strncpy((char*)c_RuleGroup , arg , sizeof(c_RuleGroup));
	c_RuleGroup[sizeof(c_RuleGroup)-1] = '\0';
	return;
}


char* T_RULE_RESULT::RuleName() const{
	return((char*)c_RuleName );
}

short T_RULE_RESULT::RuleNameZi() const{
	return( s_RuleNameZi);
}

void T_RULE_RESULT::set_RuleName( const char* arg ){ 
	strncpy((char*)c_RuleName , arg , sizeof(c_RuleName));
	c_RuleName[sizeof(c_RuleName)-1] = '\0';
	s_RuleNameZi=  0;
	return;
}

void T_RULE_RESULT::set_RuleNameZi( short arg ) {
	s_RuleNameZi =  arg;
}

char* T_RULE_RESULT::Result() const{
	return((char*)c_Result );
}

short T_RULE_RESULT::ResultZi() const{
	return( s_ResultZi);
}

void T_RULE_RESULT::set_Result( const char* arg ){ 
	strncpy((char*)c_Result , arg , sizeof(c_Result));
	c_Result[sizeof(c_Result)-1] = '\0';
	s_ResultZi=  0;
	return;
}

void T_RULE_RESULT::set_ResultZi( short arg ) {
	s_ResultZi =  arg;
}

long T_RULE_RESULT::DealResult() const{
	return((long)l_DealResult );
}

short T_RULE_RESULT::DealResultZi() const{
	return( s_DealResultZi);
}

void T_RULE_RESULT::set_DealResult( long arg ){ 
	l_DealResult = arg;
	s_DealResultZi=  0;
	return;
}

void T_RULE_RESULT::set_DealResultZi( short arg ) {
	s_DealResultZi =  arg;
}

char* T_RULE_RESULT::RuleETime() const{
	return((char*)c_RuleETime );
}

short T_RULE_RESULT::RuleETimeZi() const{
	return( s_RuleETimeZi);
}

void T_RULE_RESULT::set_RuleETime( char* arg ){ 
	strncpy((char*)c_RuleETime , arg , sizeof(c_RuleETime));
	c_RuleETime[sizeof(c_RuleETime)-1] = '\0';
	s_RuleETimeZi=  0;
	return;
}

void T_RULE_RESULT::set_RuleETimeZi( short arg ) {
	s_RuleETimeZi =  arg;
}

char* T_RULE_RESULT::DealTime() const{
	return((char*)c_DealTime );
}

short T_RULE_RESULT::DealTimeZi() const{
	return( s_DealTimeZi);
}

void T_RULE_RESULT::set_DealTime( char* arg ){ 
	strncpy((char*)c_DealTime , arg , sizeof(c_DealTime));
	c_DealTime[sizeof(c_DealTime)-1] = '\0';
	s_DealTimeZi=  0;
	return;
}

void T_RULE_RESULT::set_DealTimeZi( short arg ) {
	s_DealTimeZi =  arg;
}

// methodes for Primary key
char* T_RULE_RESULT::k_RuleBTime(){
	return((char*)c_k_RuleBTime );
}

void T_RULE_RESULT::set_k_RuleBTime( char* arg ){
	strncpy((char*)c_k_RuleBTime , arg , sizeof(c_k_RuleBTime));
	c_k_RuleBTime[sizeof(c_k_RuleBTime)-1] = '\0';
	return;
}

char* T_RULE_RESULT::k_RuleId(){
	return((char*)c_k_RuleId );
}

void T_RULE_RESULT::set_k_RuleId( char* arg ){
	strncpy((char*)c_k_RuleId , arg , sizeof(c_k_RuleId));
	c_k_RuleId[sizeof(c_k_RuleId)-1] = '\0';
	return;
}

char* T_RULE_RESULT::k_RuleGroup(){
	return((char*)c_k_RuleGroup );
}

void T_RULE_RESULT::set_k_RuleGroup( char* arg ){
	strncpy((char*)c_k_RuleGroup , arg , sizeof(c_k_RuleGroup));
	c_k_RuleGroup[sizeof(c_k_RuleGroup)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_RULE_RESULT::fillStructure(){
	strncpy ( structTable.RuleBTime , RuleBTime(),sizeof(structTable.RuleBTime));
	strncpy ( structTable.RuleId , RuleId(),sizeof(structTable.RuleId));
	strncpy ( structTable.RuleGroup , RuleGroup(),sizeof(structTable.RuleGroup));
	strncpy ( structTable.RuleName , RuleName(),sizeof(structTable.RuleName));
	strncpy ( structTable.Result , Result(),sizeof(structTable.Result));
	structTable.DealResult = DealResult();
	strncpy ( structTable.RuleETime , RuleETime(),sizeof(structTable.RuleETime));
	strncpy ( structTable.DealTime , DealTime(),sizeof(structTable.DealTime));
	return;
}
///////////////////////////////////////////////////
void T_RULE_RESULT::fillStructureZi(){
	structTableZi.RuleNameZi = RuleNameZi();
	structTableZi.ResultZi = ResultZi();
	structTableZi.DealResultZi = DealResultZi();
	structTableZi.RuleETimeZi = RuleETimeZi();
	structTableZi.DealTimeZi = DealTimeZi();
	return;
}
///////////////////////////////////////////////////
void T_RULE_RESULT::setStructure() {
	set_RuleName( structTable.RuleName);
	set_Result( structTable.Result);
	set_DealResult( structTable.DealResult);
	set_RuleETime( structTable.RuleETime);
	set_DealTime( structTable.DealTime);
	return;
}
///////////////////////////////////////////////////
void T_RULE_RESULT::setStructureZi() {
	set_RuleNameZi( structTableZi.RuleNameZi);
	set_ResultZi( structTableZi.ResultZi);
	set_DealResultZi( structTableZi.DealResultZi);
	set_RuleETimeZi( structTableZi.RuleETimeZi);
	set_DealTimeZi( structTableZi.DealTimeZi);
	return;
}
///////////////////////////////////////////////////
char* T_RULE_RESULT::getName(){
	return((char*)"T_RULE_RESULT");
}
///////////////////////////////////////////////////
int T_RULE_RESULT::getSqlCode(){
	return( db.dbSqlCode);
}
int T_RULE_RESULT::getRowsProcessed(){
	return( db.dbRowsProcessed);
}