// Version:		2020.7.15  20:54:34

// File: T_STA_PROAB_A.cpp

#include "T_STA_PROAB_A.h"

T_STA_PROAB_A::T_STA_PROAB_A(){
//  initialise all membervariables
	initial();
}
T_STA_PROAB_A::~T_STA_PROAB_A(){
}
void T_STA_PROAB_A::initial(){
//  initialise all membervariables
	set_updateTime((char*)"");
	set_tagName((char*)"");
	set_tagNameChinese((char*)"");
	set_tagNameChineseZi(-1);
	set_standardDeviation(0.0);
	set_standardDeviationZi(-1);
	set_data((char*)"");
	set_dataZi(-1);
	set_ruleMin(0.0);
	set_ruleMinZi(-1);
	set_ruleMax(0.0);
	set_ruleMaxZi(-1);
	set_source(0);
	set_sourceZi(-1);
// initialies Primary key members
	set_k_updateTime((char*)"");
	set_k_tagName((char*)"");
}
T_STA_PROAB_A::T_STA_PROAB_A(char* arg1,const char* arg2)
{
	initial();
	setPrimKey (arg1, arg2);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void T_STA_PROAB_A::initInsertKeys( char* arg1 , const char* arg2 ){
	setPrimKey (  arg1 , arg2);
	strncpy( (char*)c_updateTime , arg1 , sizeof(c_updateTime) );
	c_updateTime[sizeof(c_updateTime)-1] = '\0';
	strncpy( (char*)c_tagName , arg2 , sizeof(c_tagName) );
	c_tagName[sizeof(c_tagName)-1] = '\0';
} // end of methode
void T_STA_PROAB_A::setKeysFromRecord(){
	set_k_updateTime( updateTime() );
	set_k_tagName( tagName() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_STA_PROAB_A T_STA_PROAB_A::operator+(const T_STA_PROAB_A &inst) const{
	T_STA_PROAB_A ptrT_STA_PROAB_A(*this);
//----------------------------------------------------------
	ptrT_STA_PROAB_A.set_updateTime(inst.updateTime());
//----------------------------------------------------------
	ptrT_STA_PROAB_A.set_tagName(inst.tagName());
//----------------------------------------------------------
	if(inst.tagNameChineseZi() != -1){
		ptrT_STA_PROAB_A.set_tagNameChinese(inst.tagNameChinese());
		ptrT_STA_PROAB_A.set_tagNameChineseZi(inst.tagNameChineseZi());
	}
//----------------------------------------------------------
	if(inst.standardDeviationZi() != -1){
		ptrT_STA_PROAB_A.set_standardDeviation(inst.standardDeviation());
		ptrT_STA_PROAB_A.set_standardDeviationZi(inst.standardDeviationZi());
	}
//----------------------------------------------------------
	if(inst.dataZi() != -1){
		ptrT_STA_PROAB_A.set_data(inst.data());
		ptrT_STA_PROAB_A.set_dataZi(inst.dataZi());
	}
//----------------------------------------------------------
	if(inst.ruleMinZi() != -1){
		ptrT_STA_PROAB_A.set_ruleMin(inst.ruleMin());
		ptrT_STA_PROAB_A.set_ruleMinZi(inst.ruleMinZi());
	}
//----------------------------------------------------------
	if(inst.ruleMaxZi() != -1){
		ptrT_STA_PROAB_A.set_ruleMax(inst.ruleMax());
		ptrT_STA_PROAB_A.set_ruleMaxZi(inst.ruleMaxZi());
	}
//----------------------------------------------------------
	if(inst.sourceZi() != -1){
		ptrT_STA_PROAB_A.set_source(inst.source());
		ptrT_STA_PROAB_A.set_sourceZi(inst.sourceZi());
	}
	return (ptrT_STA_PROAB_A);
}

//
//O P E R A T O R  = 
//===================
//
const T_STA_PROAB_A& T_STA_PROAB_A::operator=(const T_STA_PROAB_A &inst){
//----------------------------------------------------------
	this->set_updateTime(inst.updateTime());
//----------------------------------------------------------
	this->set_tagName(inst.tagName());
//----------------------------------------------------------
	this->set_tagNameChinese(inst.tagNameChinese());
	this->set_tagNameChineseZi(inst.tagNameChineseZi());
//----------------------------------------------------------
	this->set_standardDeviation(inst.standardDeviation());
	this->set_standardDeviationZi(inst.standardDeviationZi());
//----------------------------------------------------------
	this->set_data(inst.data());
	this->set_dataZi(inst.dataZi());
//----------------------------------------------------------
	this->set_ruleMin(inst.ruleMin());
	this->set_ruleMinZi(inst.ruleMinZi());
//----------------------------------------------------------
	this->set_ruleMax(inst.ruleMax());
	this->set_ruleMaxZi(inst.ruleMaxZi());
//----------------------------------------------------------
	this->set_source(inst.source());
	this->set_sourceZi(inst.sourceZi());
	return (*this);
}
//
//C O P Y - C O N S T R U C T O R
//===================
//
T_STA_PROAB_A::T_STA_PROAB_A(const T_STA_PROAB_A &inst){
//----------------------------------------------------------
	this->set_updateTime(inst.updateTime());
//----------------------------------------------------------
	this->set_tagName(inst.tagName());
//----------------------------------------------------------
	this->set_tagNameChinese(inst.tagNameChinese());
	this->set_tagNameChineseZi(inst.tagNameChineseZi());
//----------------------------------------------------------
	this->set_standardDeviation(inst.standardDeviation());
	this->set_standardDeviationZi(inst.standardDeviationZi());
//----------------------------------------------------------
	this->set_data(inst.data());
	this->set_dataZi(inst.dataZi());
//----------------------------------------------------------
	this->set_ruleMin(inst.ruleMin());
	this->set_ruleMinZi(inst.ruleMinZi());
//----------------------------------------------------------
	this->set_ruleMax(inst.ruleMax());
	this->set_ruleMaxZi(inst.ruleMaxZi());
//----------------------------------------------------------
	this->set_source(inst.source());
	this->set_sourceZi(inst.sourceZi());
}
char* T_STA_PROAB_A::updateTime() const{
	return((char*)c_updateTime );
}


void T_STA_PROAB_A::set_updateTime( char* arg ){ 
	strncpy((char*)c_updateTime , arg , sizeof(c_updateTime));
	c_updateTime[sizeof(c_updateTime)-1] = '\0';
	return;
}


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


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


char* T_STA_PROAB_A::tagNameChinese() const{
	return((char*)c_tagNameChinese );
}

short T_STA_PROAB_A::tagNameChineseZi() const{
	return( s_tagNameChineseZi);
}

void T_STA_PROAB_A::set_tagNameChinese( const char* arg ){ 
	strncpy((char*)c_tagNameChinese , arg , sizeof(c_tagNameChinese));
	c_tagNameChinese[sizeof(c_tagNameChinese)-1] = '\0';
	s_tagNameChineseZi=  0;
	return;
}

void T_STA_PROAB_A::set_tagNameChineseZi( short arg ) {
	s_tagNameChineseZi =  arg;
}

double T_STA_PROAB_A::standardDeviation() const{
	return((double)d_standardDeviation );
}

short T_STA_PROAB_A::standardDeviationZi() const{
	return( s_standardDeviationZi);
}

void T_STA_PROAB_A::set_standardDeviation( double arg ){ 
	d_standardDeviation = arg;
	s_standardDeviationZi=  0;
	return;
}

void T_STA_PROAB_A::set_standardDeviationZi( short arg ) {
	s_standardDeviationZi =  arg;
}

char* T_STA_PROAB_A::data() const{
	return((char*)c_data );
}

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

void T_STA_PROAB_A::set_data( const char* arg ){ 
	strncpy((char*)c_data , arg , sizeof(c_data));
	c_data[sizeof(c_data)-1] = '\0';
	s_dataZi=  0;
	return;
}

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

double T_STA_PROAB_A::ruleMin() const{
	return((double)d_ruleMin );
}

short T_STA_PROAB_A::ruleMinZi() const{
	return( s_ruleMinZi);
}

void T_STA_PROAB_A::set_ruleMin( double arg ){ 
	d_ruleMin = arg;
	s_ruleMinZi=  0;
	return;
}

void T_STA_PROAB_A::set_ruleMinZi( short arg ) {
	s_ruleMinZi =  arg;
}

double T_STA_PROAB_A::ruleMax() const{
	return((double)d_ruleMax );
}

short T_STA_PROAB_A::ruleMaxZi() const{
	return( s_ruleMaxZi);
}

void T_STA_PROAB_A::set_ruleMax( double arg ){ 
	d_ruleMax = arg;
	s_ruleMaxZi=  0;
	return;
}

void T_STA_PROAB_A::set_ruleMaxZi( short arg ) {
	s_ruleMaxZi =  arg;
}

short T_STA_PROAB_A::source() const{
	return((short)s_source );
}

short T_STA_PROAB_A::sourceZi() const{
	return( s_sourceZi);
}

void T_STA_PROAB_A::set_source( short arg ){ 
	s_source = arg;
	s_sourceZi=  0;
	return;
}

void T_STA_PROAB_A::set_sourceZi( short arg ) {
	s_sourceZi =  arg;
}

// methodes for Primary key
char* T_STA_PROAB_A::k_updateTime(){
	return((char*)c_k_updateTime );
}

void T_STA_PROAB_A::set_k_updateTime( char* arg ){
	strncpy((char*)c_k_updateTime , arg , sizeof(c_k_updateTime));
	c_k_updateTime[sizeof(c_k_updateTime)-1] = '\0';
	return;
}

char* T_STA_PROAB_A::k_tagName(){
	return((char*)c_k_tagName );
}

void T_STA_PROAB_A::set_k_tagName( char* arg ){
	strncpy((char*)c_k_tagName , arg , sizeof(c_k_tagName));
	c_k_tagName[sizeof(c_k_tagName)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_STA_PROAB_A::fillStructure(){
	strncpy ( structTable.updateTime , updateTime(),sizeof(structTable.updateTime));
	strncpy ( structTable.tagName , tagName(),sizeof(structTable.tagName));
	strncpy ( structTable.tagNameChinese , tagNameChinese(),sizeof(structTable.tagNameChinese));
	structTable.standardDeviation = standardDeviation();
	strncpy ( structTable.data , data(),sizeof(structTable.data));
	structTable.ruleMin = ruleMin();
	structTable.ruleMax = ruleMax();
	structTable.source = source();
	return;
}
///////////////////////////////////////////////////
void T_STA_PROAB_A::fillStructureZi(){
	structTableZi.tagNameChineseZi = tagNameChineseZi();
	structTableZi.standardDeviationZi = standardDeviationZi();
	structTableZi.dataZi = dataZi();
	structTableZi.ruleMinZi = ruleMinZi();
	structTableZi.ruleMaxZi = ruleMaxZi();
	structTableZi.sourceZi = sourceZi();
	return;
}
///////////////////////////////////////////////////
void T_STA_PROAB_A::setStructure() {
	set_tagNameChinese( structTable.tagNameChinese);
	set_standardDeviation( structTable.standardDeviation);
	set_data( structTable.data);
	set_ruleMin( structTable.ruleMin);
	set_ruleMax( structTable.ruleMax);
	set_source( structTable.source);
	return;
}
///////////////////////////////////////////////////
void T_STA_PROAB_A::setStructureZi() {
	set_tagNameChineseZi( structTableZi.tagNameChineseZi);
	set_standardDeviationZi( structTableZi.standardDeviationZi);
	set_dataZi( structTableZi.dataZi);
	set_ruleMinZi( structTableZi.ruleMinZi);
	set_ruleMaxZi( structTableZi.ruleMaxZi);
	set_sourceZi( structTableZi.sourceZi);
	return;
}
///////////////////////////////////////////////////
char* T_STA_PROAB_A::getName(){
	return((char*)"T_STA_PROAB_A");
}
///////////////////////////////////////////////////
int T_STA_PROAB_A::getSqlCode(){
	return( db.dbSqlCode);
}
int T_STA_PROAB_A::getRowsProcessed(){
	return( db.dbRowsProcessed);
}