768 lines
20 KiB
C++
768 lines
20 KiB
C++
// Version: 2021.11.3 14:35:18
|
|
|
|
// File: T_PDO_LIST.cpp
|
|
|
|
#include "T_PDO_LIST.h"
|
|
|
|
T_PDO_LIST::T_PDO_LIST(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_PDO_LIST::~T_PDO_LIST(){
|
|
}
|
|
void T_PDO_LIST::initial(){
|
|
// initialise all membervariables
|
|
set_extId((char*)"");
|
|
set_entId((char*)"");
|
|
set_entIdZi(-1);
|
|
set_steelgrade((char*)"");
|
|
set_steelgradeZi(-1);
|
|
set_start(0);
|
|
set_startZi(-1);
|
|
set_end(0);
|
|
set_endZi(-1);
|
|
set_starttime((char*)"");
|
|
set_starttimeZi(-1);
|
|
set_endtime((char*)"");
|
|
set_endtimeZi(-1);
|
|
set_decision((char*)"");
|
|
set_decisionZi(-1);
|
|
set_SpeedRate(0);
|
|
set_SpeedRateZi(-1);
|
|
set_Yield(0);
|
|
set_YieldZi(-1);
|
|
set_AutoRate(0);
|
|
set_AutoRateZi(-1);
|
|
set_Energy(0);
|
|
set_EnergyZi(-1);
|
|
set_Quality(0);
|
|
set_QualityZi(-1);
|
|
set_AlarmScore(0);
|
|
set_AlarmScoreZi(-1);
|
|
set_OverallScore((char*)"");
|
|
set_OverallScoreZi(-1);
|
|
set_Elong((char*)"");
|
|
set_ElongZi(-1);
|
|
set_TC((char*)"");
|
|
set_TCZi(-1);
|
|
// initialies Primary key members
|
|
set_k_extId((char*)"");
|
|
}
|
|
T_PDO_LIST::T_PDO_LIST(const char* arg1)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_PDO_LIST:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_PDO_LIST:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_PDO_LIST:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_PDO_LIST::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_PDO_LIST::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_PDO_LIST::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_PDO_LIST::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_PDO_LIST::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_PDO_LIST::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_PDO_LIST::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_PDO_LIST::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_PDO_LIST::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_PDO_LIST::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_PDO_LIST
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_PDO_LIST::setPrimKey( const char* arg1 ){
|
|
strncpy( (char*)c_k_extId , arg1 , sizeof(c_k_extId) );
|
|
c_k_extId[sizeof(c_k_extId)-1] = '\0';
|
|
} // end of methode
|
|
|
|
void T_PDO_LIST::initInsertKeys( const char* arg1 ){
|
|
setPrimKey ( arg1);
|
|
strncpy( (char*)c_extId , arg1 , sizeof(c_extId) );
|
|
c_extId[sizeof(c_extId)-1] = '\0';
|
|
} // end of methode
|
|
void T_PDO_LIST::setKeysFromRecord(){
|
|
set_k_extId( extId() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_PDO_LIST T_PDO_LIST::operator+(const T_PDO_LIST &inst) const{
|
|
T_PDO_LIST ptrT_PDO_LIST(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_PDO_LIST.set_extId(inst.extId());
|
|
//----------------------------------------------------------
|
|
if(inst.entIdZi() != -1){
|
|
ptrT_PDO_LIST.set_entId(inst.entId());
|
|
ptrT_PDO_LIST.set_entIdZi(inst.entIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.steelgradeZi() != -1){
|
|
ptrT_PDO_LIST.set_steelgrade(inst.steelgrade());
|
|
ptrT_PDO_LIST.set_steelgradeZi(inst.steelgradeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.startZi() != -1){
|
|
ptrT_PDO_LIST.set_start(inst.start());
|
|
ptrT_PDO_LIST.set_startZi(inst.startZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.endZi() != -1){
|
|
ptrT_PDO_LIST.set_end(inst.end());
|
|
ptrT_PDO_LIST.set_endZi(inst.endZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.starttimeZi() != -1){
|
|
ptrT_PDO_LIST.set_starttime(inst.starttime());
|
|
ptrT_PDO_LIST.set_starttimeZi(inst.starttimeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.endtimeZi() != -1){
|
|
ptrT_PDO_LIST.set_endtime(inst.endtime());
|
|
ptrT_PDO_LIST.set_endtimeZi(inst.endtimeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.decisionZi() != -1){
|
|
ptrT_PDO_LIST.set_decision(inst.decision());
|
|
ptrT_PDO_LIST.set_decisionZi(inst.decisionZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.SpeedRateZi() != -1){
|
|
ptrT_PDO_LIST.set_SpeedRate(inst.SpeedRate());
|
|
ptrT_PDO_LIST.set_SpeedRateZi(inst.SpeedRateZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.YieldZi() != -1){
|
|
ptrT_PDO_LIST.set_Yield(inst.Yield());
|
|
ptrT_PDO_LIST.set_YieldZi(inst.YieldZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.AutoRateZi() != -1){
|
|
ptrT_PDO_LIST.set_AutoRate(inst.AutoRate());
|
|
ptrT_PDO_LIST.set_AutoRateZi(inst.AutoRateZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnergyZi() != -1){
|
|
ptrT_PDO_LIST.set_Energy(inst.Energy());
|
|
ptrT_PDO_LIST.set_EnergyZi(inst.EnergyZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.QualityZi() != -1){
|
|
ptrT_PDO_LIST.set_Quality(inst.Quality());
|
|
ptrT_PDO_LIST.set_QualityZi(inst.QualityZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.AlarmScoreZi() != -1){
|
|
ptrT_PDO_LIST.set_AlarmScore(inst.AlarmScore());
|
|
ptrT_PDO_LIST.set_AlarmScoreZi(inst.AlarmScoreZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.OverallScoreZi() != -1){
|
|
ptrT_PDO_LIST.set_OverallScore(inst.OverallScore());
|
|
ptrT_PDO_LIST.set_OverallScoreZi(inst.OverallScoreZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ElongZi() != -1){
|
|
ptrT_PDO_LIST.set_Elong(inst.Elong());
|
|
ptrT_PDO_LIST.set_ElongZi(inst.ElongZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.TCZi() != -1){
|
|
ptrT_PDO_LIST.set_TC(inst.TC());
|
|
ptrT_PDO_LIST.set_TCZi(inst.TCZi());
|
|
}
|
|
return (ptrT_PDO_LIST);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_PDO_LIST& T_PDO_LIST::operator=(const T_PDO_LIST &inst){
|
|
//----------------------------------------------------------
|
|
this->set_extId(inst.extId());
|
|
//----------------------------------------------------------
|
|
this->set_entId(inst.entId());
|
|
this->set_entIdZi(inst.entIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_steelgrade(inst.steelgrade());
|
|
this->set_steelgradeZi(inst.steelgradeZi());
|
|
//----------------------------------------------------------
|
|
this->set_start(inst.start());
|
|
this->set_startZi(inst.startZi());
|
|
//----------------------------------------------------------
|
|
this->set_end(inst.end());
|
|
this->set_endZi(inst.endZi());
|
|
//----------------------------------------------------------
|
|
this->set_starttime(inst.starttime());
|
|
this->set_starttimeZi(inst.starttimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_endtime(inst.endtime());
|
|
this->set_endtimeZi(inst.endtimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_decision(inst.decision());
|
|
this->set_decisionZi(inst.decisionZi());
|
|
//----------------------------------------------------------
|
|
this->set_SpeedRate(inst.SpeedRate());
|
|
this->set_SpeedRateZi(inst.SpeedRateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Yield(inst.Yield());
|
|
this->set_YieldZi(inst.YieldZi());
|
|
//----------------------------------------------------------
|
|
this->set_AutoRate(inst.AutoRate());
|
|
this->set_AutoRateZi(inst.AutoRateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Energy(inst.Energy());
|
|
this->set_EnergyZi(inst.EnergyZi());
|
|
//----------------------------------------------------------
|
|
this->set_Quality(inst.Quality());
|
|
this->set_QualityZi(inst.QualityZi());
|
|
//----------------------------------------------------------
|
|
this->set_AlarmScore(inst.AlarmScore());
|
|
this->set_AlarmScoreZi(inst.AlarmScoreZi());
|
|
//----------------------------------------------------------
|
|
this->set_OverallScore(inst.OverallScore());
|
|
this->set_OverallScoreZi(inst.OverallScoreZi());
|
|
//----------------------------------------------------------
|
|
this->set_Elong(inst.Elong());
|
|
this->set_ElongZi(inst.ElongZi());
|
|
//----------------------------------------------------------
|
|
this->set_TC(inst.TC());
|
|
this->set_TCZi(inst.TCZi());
|
|
return (*this);
|
|
}
|
|
//
|
|
//C O P Y - C O N S T R U C T O R
|
|
//===================
|
|
//
|
|
T_PDO_LIST::T_PDO_LIST(const T_PDO_LIST &inst){
|
|
//----------------------------------------------------------
|
|
this->set_extId(inst.extId());
|
|
//----------------------------------------------------------
|
|
this->set_entId(inst.entId());
|
|
this->set_entIdZi(inst.entIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_steelgrade(inst.steelgrade());
|
|
this->set_steelgradeZi(inst.steelgradeZi());
|
|
//----------------------------------------------------------
|
|
this->set_start(inst.start());
|
|
this->set_startZi(inst.startZi());
|
|
//----------------------------------------------------------
|
|
this->set_end(inst.end());
|
|
this->set_endZi(inst.endZi());
|
|
//----------------------------------------------------------
|
|
this->set_starttime(inst.starttime());
|
|
this->set_starttimeZi(inst.starttimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_endtime(inst.endtime());
|
|
this->set_endtimeZi(inst.endtimeZi());
|
|
//----------------------------------------------------------
|
|
this->set_decision(inst.decision());
|
|
this->set_decisionZi(inst.decisionZi());
|
|
//----------------------------------------------------------
|
|
this->set_SpeedRate(inst.SpeedRate());
|
|
this->set_SpeedRateZi(inst.SpeedRateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Yield(inst.Yield());
|
|
this->set_YieldZi(inst.YieldZi());
|
|
//----------------------------------------------------------
|
|
this->set_AutoRate(inst.AutoRate());
|
|
this->set_AutoRateZi(inst.AutoRateZi());
|
|
//----------------------------------------------------------
|
|
this->set_Energy(inst.Energy());
|
|
this->set_EnergyZi(inst.EnergyZi());
|
|
//----------------------------------------------------------
|
|
this->set_Quality(inst.Quality());
|
|
this->set_QualityZi(inst.QualityZi());
|
|
//----------------------------------------------------------
|
|
this->set_AlarmScore(inst.AlarmScore());
|
|
this->set_AlarmScoreZi(inst.AlarmScoreZi());
|
|
//----------------------------------------------------------
|
|
this->set_OverallScore(inst.OverallScore());
|
|
this->set_OverallScoreZi(inst.OverallScoreZi());
|
|
//----------------------------------------------------------
|
|
this->set_Elong(inst.Elong());
|
|
this->set_ElongZi(inst.ElongZi());
|
|
//----------------------------------------------------------
|
|
this->set_TC(inst.TC());
|
|
this->set_TCZi(inst.TCZi());
|
|
}
|
|
char* T_PDO_LIST::extId() const{
|
|
return((char*)c_extId );
|
|
}
|
|
|
|
|
|
void T_PDO_LIST::set_extId( const char* arg ){
|
|
strncpy((char*)c_extId , arg , sizeof(c_extId));
|
|
c_extId[sizeof(c_extId)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_PDO_LIST::entId() const{
|
|
return((char*)c_entId );
|
|
}
|
|
|
|
short T_PDO_LIST::entIdZi() const{
|
|
return( s_entIdZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_entId( const char* arg ){
|
|
strncpy((char*)c_entId , arg , sizeof(c_entId));
|
|
c_entId[sizeof(c_entId)-1] = '\0';
|
|
s_entIdZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_entIdZi( short arg ) {
|
|
s_entIdZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::steelgrade() const{
|
|
return((char*)c_steelgrade );
|
|
}
|
|
|
|
short T_PDO_LIST::steelgradeZi() const{
|
|
return( s_steelgradeZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_steelgrade( const char* arg ){
|
|
strncpy((char*)c_steelgrade , arg , sizeof(c_steelgrade));
|
|
c_steelgrade[sizeof(c_steelgrade)-1] = '\0';
|
|
s_steelgradeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_steelgradeZi( short arg ) {
|
|
s_steelgradeZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::start() const{
|
|
return((long)l_start );
|
|
}
|
|
|
|
short T_PDO_LIST::startZi() const{
|
|
return( s_startZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_start( long arg ){
|
|
l_start = arg;
|
|
s_startZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_startZi( short arg ) {
|
|
s_startZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::end() const{
|
|
return((long)l_end );
|
|
}
|
|
|
|
short T_PDO_LIST::endZi() const{
|
|
return( s_endZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_end( long arg ){
|
|
l_end = arg;
|
|
s_endZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_endZi( short arg ) {
|
|
s_endZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::starttime() const{
|
|
return((char*)c_starttime );
|
|
}
|
|
|
|
short T_PDO_LIST::starttimeZi() const{
|
|
return( s_starttimeZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_starttime( char* arg ){
|
|
strncpy((char*)c_starttime , arg , sizeof(c_starttime));
|
|
c_starttime[sizeof(c_starttime)-1] = '\0';
|
|
s_starttimeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_starttimeZi( short arg ) {
|
|
s_starttimeZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::endtime() const{
|
|
return((char*)c_endtime );
|
|
}
|
|
|
|
short T_PDO_LIST::endtimeZi() const{
|
|
return( s_endtimeZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_endtime( char* arg ){
|
|
strncpy((char*)c_endtime , arg , sizeof(c_endtime));
|
|
c_endtime[sizeof(c_endtime)-1] = '\0';
|
|
s_endtimeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_endtimeZi( short arg ) {
|
|
s_endtimeZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::decision() const{
|
|
return((char*)c_decision );
|
|
}
|
|
|
|
short T_PDO_LIST::decisionZi() const{
|
|
return( s_decisionZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_decision( const char* arg ){
|
|
strncpy((char*)c_decision , arg , sizeof(c_decision));
|
|
c_decision[sizeof(c_decision)-1] = '\0';
|
|
s_decisionZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_decisionZi( short arg ) {
|
|
s_decisionZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::SpeedRate() const{
|
|
return((long)l_SpeedRate );
|
|
}
|
|
|
|
short T_PDO_LIST::SpeedRateZi() const{
|
|
return( s_SpeedRateZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_SpeedRate( long arg ){
|
|
l_SpeedRate = arg;
|
|
s_SpeedRateZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_SpeedRateZi( short arg ) {
|
|
s_SpeedRateZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::Yield() const{
|
|
return((long)l_Yield );
|
|
}
|
|
|
|
short T_PDO_LIST::YieldZi() const{
|
|
return( s_YieldZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_Yield( long arg ){
|
|
l_Yield = arg;
|
|
s_YieldZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_YieldZi( short arg ) {
|
|
s_YieldZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::AutoRate() const{
|
|
return((long)l_AutoRate );
|
|
}
|
|
|
|
short T_PDO_LIST::AutoRateZi() const{
|
|
return( s_AutoRateZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_AutoRate( long arg ){
|
|
l_AutoRate = arg;
|
|
s_AutoRateZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_AutoRateZi( short arg ) {
|
|
s_AutoRateZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::Energy() const{
|
|
return((long)l_Energy );
|
|
}
|
|
|
|
short T_PDO_LIST::EnergyZi() const{
|
|
return( s_EnergyZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_Energy( long arg ){
|
|
l_Energy = arg;
|
|
s_EnergyZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_EnergyZi( short arg ) {
|
|
s_EnergyZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::Quality() const{
|
|
return((long)l_Quality );
|
|
}
|
|
|
|
short T_PDO_LIST::QualityZi() const{
|
|
return( s_QualityZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_Quality( long arg ){
|
|
l_Quality = arg;
|
|
s_QualityZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_QualityZi( short arg ) {
|
|
s_QualityZi = arg;
|
|
}
|
|
|
|
long T_PDO_LIST::AlarmScore() const{
|
|
return((long)l_AlarmScore );
|
|
}
|
|
|
|
short T_PDO_LIST::AlarmScoreZi() const{
|
|
return( s_AlarmScoreZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_AlarmScore( long arg ){
|
|
l_AlarmScore = arg;
|
|
s_AlarmScoreZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_AlarmScoreZi( short arg ) {
|
|
s_AlarmScoreZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::OverallScore() const{
|
|
return((char*)c_OverallScore );
|
|
}
|
|
|
|
short T_PDO_LIST::OverallScoreZi() const{
|
|
return( s_OverallScoreZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_OverallScore( const char* arg ){
|
|
strncpy((char*)c_OverallScore , arg , sizeof(c_OverallScore));
|
|
c_OverallScore[sizeof(c_OverallScore)-1] = '\0';
|
|
s_OverallScoreZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_OverallScoreZi( short arg ) {
|
|
s_OverallScoreZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::Elong() const{
|
|
return((char*)c_Elong );
|
|
}
|
|
|
|
short T_PDO_LIST::ElongZi() const{
|
|
return( s_ElongZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_Elong( const char* arg ){
|
|
strncpy((char*)c_Elong , arg , sizeof(c_Elong));
|
|
c_Elong[sizeof(c_Elong)-1] = '\0';
|
|
s_ElongZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_ElongZi( short arg ) {
|
|
s_ElongZi = arg;
|
|
}
|
|
|
|
char* T_PDO_LIST::TC() const{
|
|
return((char*)c_TC );
|
|
}
|
|
|
|
short T_PDO_LIST::TCZi() const{
|
|
return( s_TCZi);
|
|
}
|
|
|
|
void T_PDO_LIST::set_TC( char* arg ){
|
|
strncpy((char*)c_TC , arg , sizeof(c_TC));
|
|
c_TC[sizeof(c_TC)-1] = '\0';
|
|
s_TCZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_PDO_LIST::set_TCZi( short arg ) {
|
|
s_TCZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
char* T_PDO_LIST::k_extId(){
|
|
return((char*)c_k_extId );
|
|
}
|
|
|
|
void T_PDO_LIST::set_k_extId( char* arg ){
|
|
strncpy((char*)c_k_extId , arg , sizeof(c_k_extId));
|
|
c_k_extId[sizeof(c_k_extId)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_PDO_LIST::fillStructure(){
|
|
strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
|
|
strncpy ( structTable.entId , entId(),sizeof(structTable.entId));
|
|
strncpy ( structTable.steelgrade , steelgrade(),sizeof(structTable.steelgrade));
|
|
structTable.start = start();
|
|
structTable.end = end();
|
|
strncpy ( structTable.starttime , starttime(),sizeof(structTable.starttime));
|
|
strncpy ( structTable.endtime , endtime(),sizeof(structTable.endtime));
|
|
strncpy ( structTable.decision , decision(),sizeof(structTable.decision));
|
|
structTable.SpeedRate = SpeedRate();
|
|
structTable.Yield = Yield();
|
|
structTable.AutoRate = AutoRate();
|
|
structTable.Energy = Energy();
|
|
structTable.Quality = Quality();
|
|
structTable.AlarmScore = AlarmScore();
|
|
strncpy ( structTable.OverallScore , OverallScore(),sizeof(structTable.OverallScore));
|
|
strncpy ( structTable.Elong , Elong(),sizeof(structTable.Elong));
|
|
strncpy ( structTable.TC , TC(),sizeof(structTable.TC));
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_PDO_LIST::fillStructureZi(){
|
|
structTableZi.entIdZi = entIdZi();
|
|
structTableZi.steelgradeZi = steelgradeZi();
|
|
structTableZi.startZi = startZi();
|
|
structTableZi.endZi = endZi();
|
|
structTableZi.starttimeZi = starttimeZi();
|
|
structTableZi.endtimeZi = endtimeZi();
|
|
structTableZi.decisionZi = decisionZi();
|
|
structTableZi.SpeedRateZi = SpeedRateZi();
|
|
structTableZi.YieldZi = YieldZi();
|
|
structTableZi.AutoRateZi = AutoRateZi();
|
|
structTableZi.EnergyZi = EnergyZi();
|
|
structTableZi.QualityZi = QualityZi();
|
|
structTableZi.AlarmScoreZi = AlarmScoreZi();
|
|
structTableZi.OverallScoreZi = OverallScoreZi();
|
|
structTableZi.ElongZi = ElongZi();
|
|
structTableZi.TCZi = TCZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_PDO_LIST::setStructure() {
|
|
set_entId( structTable.entId);
|
|
set_steelgrade( structTable.steelgrade);
|
|
set_start( structTable.start);
|
|
set_end( structTable.end);
|
|
set_starttime( structTable.starttime);
|
|
set_endtime( structTable.endtime);
|
|
set_decision( structTable.decision);
|
|
set_SpeedRate( structTable.SpeedRate);
|
|
set_Yield( structTable.Yield);
|
|
set_AutoRate( structTable.AutoRate);
|
|
set_Energy( structTable.Energy);
|
|
set_Quality( structTable.Quality);
|
|
set_AlarmScore( structTable.AlarmScore);
|
|
set_OverallScore( structTable.OverallScore);
|
|
set_Elong( structTable.Elong);
|
|
set_TC( structTable.TC);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_PDO_LIST::setStructureZi() {
|
|
set_entIdZi( structTableZi.entIdZi);
|
|
set_steelgradeZi( structTableZi.steelgradeZi);
|
|
set_startZi( structTableZi.startZi);
|
|
set_endZi( structTableZi.endZi);
|
|
set_starttimeZi( structTableZi.starttimeZi);
|
|
set_endtimeZi( structTableZi.endtimeZi);
|
|
set_decisionZi( structTableZi.decisionZi);
|
|
set_SpeedRateZi( structTableZi.SpeedRateZi);
|
|
set_YieldZi( structTableZi.YieldZi);
|
|
set_AutoRateZi( structTableZi.AutoRateZi);
|
|
set_EnergyZi( structTableZi.EnergyZi);
|
|
set_QualityZi( structTableZi.QualityZi);
|
|
set_AlarmScoreZi( structTableZi.AlarmScoreZi);
|
|
set_OverallScoreZi( structTableZi.OverallScoreZi);
|
|
set_ElongZi( structTableZi.ElongZi);
|
|
set_TCZi( structTableZi.TCZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_PDO_LIST::getName(){
|
|
return((char*)"T_PDO_LIST");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_PDO_LIST::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_PDO_LIST::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|