448 lines
12 KiB
C++
448 lines
12 KiB
C++
|
// 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);
|
||
|
|
}
|