// Version:		2020.10.16  10:6:6

// File: T_RULE_SAMPLELEN.cpp

#include "T_RULE_SAMPLELEN.h"

T_RULE_SAMPLELEN::T_RULE_SAMPLELEN(){
//  initialise all membervariables
	initial();
}
T_RULE_SAMPLELEN::~T_RULE_SAMPLELEN(){
}
void T_RULE_SAMPLELEN::initial(){
//  initialise all membervariables
	set_RuleId((char*)"");
	set_sampleDate((char*)"");
	set_tagName((char*)"");
	set_tagNameZi(-1);
	set_data(0.0);
	set_dataZi(-1);
// initialies Primary key members
	set_k_RuleId((char*)"");
	set_k_sampleDate((char*)"");
}
T_RULE_SAMPLELEN::T_RULE_SAMPLELEN(const char* arg1,char* arg2)
{
	initial();
	setPrimKey (arg1, arg2);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_RULE_SAMPLELEN::initInsertKeys( const char* arg1 , char* arg2 ){
	setPrimKey (  arg1 , arg2);
	strncpy( (char*)c_RuleId , arg1 , sizeof(c_RuleId) );
	c_RuleId[sizeof(c_RuleId)-1] = '\0';
	strncpy( (char*)c_sampleDate , arg2 , sizeof(c_sampleDate) );
	c_sampleDate[sizeof(c_sampleDate)-1] = '\0';
} // end of methode
void T_RULE_SAMPLELEN::setKeysFromRecord(){
	set_k_RuleId( RuleId() );
	set_k_sampleDate( sampleDate() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_RULE_SAMPLELEN T_RULE_SAMPLELEN::operator+(const T_RULE_SAMPLELEN &inst) const{
	T_RULE_SAMPLELEN ptrT_RULE_SAMPLELEN(*this);
//----------------------------------------------------------
	ptrT_RULE_SAMPLELEN.set_RuleId(inst.RuleId());
//----------------------------------------------------------
	ptrT_RULE_SAMPLELEN.set_sampleDate(inst.sampleDate());
//----------------------------------------------------------
	if(inst.tagNameZi() != -1){
		ptrT_RULE_SAMPLELEN.set_tagName(inst.tagName());
		ptrT_RULE_SAMPLELEN.set_tagNameZi(inst.tagNameZi());
	}
//----------------------------------------------------------
	if(inst.dataZi() != -1){
		ptrT_RULE_SAMPLELEN.set_data(inst.data());
		ptrT_RULE_SAMPLELEN.set_dataZi(inst.dataZi());
	}
	return (ptrT_RULE_SAMPLELEN);
}

//
//O P E R A T O R  = 
//===================
//
const T_RULE_SAMPLELEN& T_RULE_SAMPLELEN::operator=(const T_RULE_SAMPLELEN &inst){
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_sampleDate(inst.sampleDate());
//----------------------------------------------------------
	this->set_tagName(inst.tagName());
	this->set_tagNameZi(inst.tagNameZi());
//----------------------------------------------------------
	this->set_data(inst.data());
	this->set_dataZi(inst.dataZi());
	return (*this);
}
//
//C O P Y - C O N S T R U C T O R
//===================
//
T_RULE_SAMPLELEN::T_RULE_SAMPLELEN(const T_RULE_SAMPLELEN &inst){
//----------------------------------------------------------
	this->set_RuleId(inst.RuleId());
//----------------------------------------------------------
	this->set_sampleDate(inst.sampleDate());
//----------------------------------------------------------
	this->set_tagName(inst.tagName());
	this->set_tagNameZi(inst.tagNameZi());
//----------------------------------------------------------
	this->set_data(inst.data());
	this->set_dataZi(inst.dataZi());
}
char* T_RULE_SAMPLELEN::RuleId() const{
	return((char*)c_RuleId );
}


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


char* T_RULE_SAMPLELEN::sampleDate() const{
	return((char*)c_sampleDate );
}


void T_RULE_SAMPLELEN::set_sampleDate( char* arg ){ 
	strncpy((char*)c_sampleDate , arg , sizeof(c_sampleDate));
	c_sampleDate[sizeof(c_sampleDate)-1] = '\0';
	return;
}


char* T_RULE_SAMPLELEN::tagName() const{
	return((char*)c_tagName );
}

short T_RULE_SAMPLELEN::tagNameZi() const{
	return( s_tagNameZi);
}

void T_RULE_SAMPLELEN::set_tagName( const char* arg ){ 
	strncpy((char*)c_tagName , arg , sizeof(c_tagName));
	c_tagName[sizeof(c_tagName)-1] = '\0';
	s_tagNameZi=  0;
	return;
}

void T_RULE_SAMPLELEN::set_tagNameZi( short arg ) {
	s_tagNameZi =  arg;
}

double T_RULE_SAMPLELEN::data() const{
	return((double)d_data );
}

short T_RULE_SAMPLELEN::dataZi() const{
	return( s_dataZi);
}

void T_RULE_SAMPLELEN::set_data( double arg ){ 
	d_data = arg;
	s_dataZi=  0;
	return;
}

void T_RULE_SAMPLELEN::set_dataZi( short arg ) {
	s_dataZi =  arg;
}

// methodes for Primary key
char* T_RULE_SAMPLELEN::k_RuleId(){
	return((char*)c_k_RuleId );
}

void T_RULE_SAMPLELEN::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_SAMPLELEN::k_sampleDate(){
	return((char*)c_k_sampleDate );
}

void T_RULE_SAMPLELEN::set_k_sampleDate( char* arg ){
	strncpy((char*)c_k_sampleDate , arg , sizeof(c_k_sampleDate));
	c_k_sampleDate[sizeof(c_k_sampleDate)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_RULE_SAMPLELEN::fillStructure(){
	strncpy ( structTable.RuleId , RuleId(),sizeof(structTable.RuleId));
	strncpy ( structTable.sampleDate , sampleDate(),sizeof(structTable.sampleDate));
	strncpy ( structTable.tagName , tagName(),sizeof(structTable.tagName));
	structTable.data = data();
	return;
}
///////////////////////////////////////////////////
void T_RULE_SAMPLELEN::fillStructureZi(){
	structTableZi.tagNameZi = tagNameZi();
	structTableZi.dataZi = dataZi();
	return;
}
///////////////////////////////////////////////////
void T_RULE_SAMPLELEN::setStructure() {
	set_tagName( structTable.tagName);
	set_data( structTable.data);
	return;
}
///////////////////////////////////////////////////
void T_RULE_SAMPLELEN::setStructureZi() {
	set_tagNameZi( structTableZi.tagNameZi);
	set_dataZi( structTableZi.dataZi);
	return;
}
///////////////////////////////////////////////////
char* T_RULE_SAMPLELEN::getName(){
	return((char*)"T_RULE_SAMPLELEN");
}
///////////////////////////////////////////////////
int T_RULE_SAMPLELEN::getSqlCode(){
	return( db.dbSqlCode);
}
int T_RULE_SAMPLELEN::getRowsProcessed(){
	return( db.dbRowsProcessed);
}