627 lines
16 KiB
C++
627 lines
16 KiB
C++
// Version: 2019.4.4 10:22:45
|
|
|
|
// File: T_LOV_LIMIT.cpp
|
|
|
|
#include "T_LOV_LIMIT.h"
|
|
|
|
T_LOV_LIMIT::T_LOV_LIMIT(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_LOV_LIMIT::~T_LOV_LIMIT(){
|
|
}
|
|
void T_LOV_LIMIT::initial(){
|
|
// initialise all membervariables
|
|
set_plantType((char*)"");
|
|
set_limitName((char*)"");
|
|
set_CheckType(0);
|
|
set_CheckTypeZi(-1);
|
|
set_Factor(0);
|
|
set_FactorZi(-1);
|
|
set_LowerLimit(0);
|
|
set_LowerLimitZi(-1);
|
|
set_UpperLimit(0);
|
|
set_UpperLimitZi(-1);
|
|
set_Enumerate((char*)"");
|
|
set_EnumerateZi(-1);
|
|
set_WarnLevel(0);
|
|
set_WarnLevelZi(-1);
|
|
set_ModDescr((char*)"");
|
|
set_ModDescrZi(-1);
|
|
set_toc((char*)"");
|
|
set_tocZi(-1);
|
|
set_toc((char*)"");
|
|
set_tomZi(-1);
|
|
set_mop((char*)"");
|
|
set_mopZi(-1);
|
|
set_mou((char*)"");
|
|
set_mouZi(-1);
|
|
// initialies Primary key members
|
|
set_k_plantType((char*)"");
|
|
set_k_limitName((char*)"");
|
|
}
|
|
T_LOV_LIMIT::T_LOV_LIMIT(const char* arg1,const char* arg2)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1, arg2);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_LOV_LIMIT:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_LOV_LIMIT::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_LOV_LIMIT
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_LOV_LIMIT::setPrimKey( const char* arg1 , const char* arg2 ){
|
|
strncpy( (char*)c_k_plantType , arg1 , sizeof(c_k_plantType) );
|
|
c_k_plantType[sizeof(c_k_plantType)-1] = '\0';
|
|
strncpy( (char*)c_k_limitName , arg2 , sizeof(c_k_limitName) );
|
|
c_k_limitName[sizeof(c_k_limitName)-1] = '\0';
|
|
} // end of methode
|
|
|
|
void T_LOV_LIMIT::initInsertKeys( const char* arg1 , const char* arg2 ){
|
|
setPrimKey ( arg1 , arg2);
|
|
strncpy( (char*)c_plantType , arg1 , sizeof(c_plantType) );
|
|
c_plantType[sizeof(c_plantType)-1] = '\0';
|
|
strncpy( (char*)c_limitName , arg2 , sizeof(c_limitName) );
|
|
c_limitName[sizeof(c_limitName)-1] = '\0';
|
|
} // end of methode
|
|
void T_LOV_LIMIT::setKeysFromRecord(){
|
|
set_k_plantType( plantType() );
|
|
set_k_limitName( limitName() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_LOV_LIMIT T_LOV_LIMIT::operator+(const T_LOV_LIMIT &inst) const{
|
|
T_LOV_LIMIT ptrT_LOV_LIMIT(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_LIMIT.set_plantType(inst.plantType());
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_LIMIT.set_limitName(inst.limitName());
|
|
//----------------------------------------------------------
|
|
if(inst.CheckTypeZi() != -1){
|
|
ptrT_LOV_LIMIT.set_CheckType(inst.CheckType());
|
|
ptrT_LOV_LIMIT.set_CheckTypeZi(inst.CheckTypeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.FactorZi() != -1){
|
|
ptrT_LOV_LIMIT.set_Factor(inst.Factor());
|
|
ptrT_LOV_LIMIT.set_FactorZi(inst.FactorZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.LowerLimitZi() != -1){
|
|
ptrT_LOV_LIMIT.set_LowerLimit(inst.LowerLimit());
|
|
ptrT_LOV_LIMIT.set_LowerLimitZi(inst.LowerLimitZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.UpperLimitZi() != -1){
|
|
ptrT_LOV_LIMIT.set_UpperLimit(inst.UpperLimit());
|
|
ptrT_LOV_LIMIT.set_UpperLimitZi(inst.UpperLimitZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.EnumerateZi() != -1){
|
|
ptrT_LOV_LIMIT.set_Enumerate(inst.Enumerate());
|
|
ptrT_LOV_LIMIT.set_EnumerateZi(inst.EnumerateZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.WarnLevelZi() != -1){
|
|
ptrT_LOV_LIMIT.set_WarnLevel(inst.WarnLevel());
|
|
ptrT_LOV_LIMIT.set_WarnLevelZi(inst.WarnLevelZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.ModDescrZi() != -1){
|
|
ptrT_LOV_LIMIT.set_ModDescr(inst.ModDescr());
|
|
ptrT_LOV_LIMIT.set_ModDescrZi(inst.ModDescrZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_LOV_LIMIT.set_toc(inst.toc());
|
|
ptrT_LOV_LIMIT.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_LOV_LIMIT.set_tom(inst.tom());
|
|
ptrT_LOV_LIMIT.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_LOV_LIMIT.set_mop(inst.mop());
|
|
ptrT_LOV_LIMIT.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_LOV_LIMIT.set_mou(inst.mou());
|
|
ptrT_LOV_LIMIT.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_LOV_LIMIT);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_LOV_LIMIT& T_LOV_LIMIT::operator=(const T_LOV_LIMIT &inst){
|
|
//----------------------------------------------------------
|
|
this->set_plantType(inst.plantType());
|
|
//----------------------------------------------------------
|
|
this->set_limitName(inst.limitName());
|
|
//----------------------------------------------------------
|
|
this->set_CheckType(inst.CheckType());
|
|
this->set_CheckTypeZi(inst.CheckTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_Factor(inst.Factor());
|
|
this->set_FactorZi(inst.FactorZi());
|
|
//----------------------------------------------------------
|
|
this->set_LowerLimit(inst.LowerLimit());
|
|
this->set_LowerLimitZi(inst.LowerLimitZi());
|
|
//----------------------------------------------------------
|
|
this->set_UpperLimit(inst.UpperLimit());
|
|
this->set_UpperLimitZi(inst.UpperLimitZi());
|
|
//----------------------------------------------------------
|
|
this->set_Enumerate(inst.Enumerate());
|
|
this->set_EnumerateZi(inst.EnumerateZi());
|
|
//----------------------------------------------------------
|
|
this->set_WarnLevel(inst.WarnLevel());
|
|
this->set_WarnLevelZi(inst.WarnLevelZi());
|
|
//----------------------------------------------------------
|
|
this->set_ModDescr(inst.ModDescr());
|
|
this->set_ModDescrZi(inst.ModDescrZi());
|
|
//----------------------------------------------------------
|
|
this->set_toc(inst.toc());
|
|
this->set_tocZi(inst.tocZi());
|
|
//----------------------------------------------------------
|
|
this->set_tom(inst.tom());
|
|
this->set_tomZi(inst.tomZi());
|
|
//----------------------------------------------------------
|
|
this->set_mop(inst.mop());
|
|
this->set_mopZi(inst.mopZi());
|
|
//----------------------------------------------------------
|
|
this->set_mou(inst.mou());
|
|
this->set_mouZi(inst.mouZi());
|
|
return (*this);
|
|
}
|
|
//
|
|
//C O P Y - C O N S T R U C T O R
|
|
//===================
|
|
//
|
|
T_LOV_LIMIT::T_LOV_LIMIT(const T_LOV_LIMIT &inst){
|
|
//----------------------------------------------------------
|
|
this->set_plantType(inst.plantType());
|
|
//----------------------------------------------------------
|
|
this->set_limitName(inst.limitName());
|
|
//----------------------------------------------------------
|
|
this->set_CheckType(inst.CheckType());
|
|
this->set_CheckTypeZi(inst.CheckTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_Factor(inst.Factor());
|
|
this->set_FactorZi(inst.FactorZi());
|
|
//----------------------------------------------------------
|
|
this->set_LowerLimit(inst.LowerLimit());
|
|
this->set_LowerLimitZi(inst.LowerLimitZi());
|
|
//----------------------------------------------------------
|
|
this->set_UpperLimit(inst.UpperLimit());
|
|
this->set_UpperLimitZi(inst.UpperLimitZi());
|
|
//----------------------------------------------------------
|
|
this->set_Enumerate(inst.Enumerate());
|
|
this->set_EnumerateZi(inst.EnumerateZi());
|
|
//----------------------------------------------------------
|
|
this->set_WarnLevel(inst.WarnLevel());
|
|
this->set_WarnLevelZi(inst.WarnLevelZi());
|
|
//----------------------------------------------------------
|
|
this->set_ModDescr(inst.ModDescr());
|
|
this->set_ModDescrZi(inst.ModDescrZi());
|
|
//----------------------------------------------------------
|
|
this->set_toc(inst.toc());
|
|
this->set_tocZi(inst.tocZi());
|
|
//----------------------------------------------------------
|
|
this->set_tom(inst.tom());
|
|
this->set_tomZi(inst.tomZi());
|
|
//----------------------------------------------------------
|
|
this->set_mop(inst.mop());
|
|
this->set_mopZi(inst.mopZi());
|
|
//----------------------------------------------------------
|
|
this->set_mou(inst.mou());
|
|
this->set_mouZi(inst.mouZi());
|
|
}
|
|
char* T_LOV_LIMIT::plantType() const{
|
|
return((char*)c_plantType );
|
|
}
|
|
|
|
|
|
void T_LOV_LIMIT::set_plantType( const char* arg ){
|
|
strncpy((char*)c_plantType , arg , sizeof(c_plantType));
|
|
c_plantType[sizeof(c_plantType)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_LOV_LIMIT::limitName() const{
|
|
return((char*)c_limitName );
|
|
}
|
|
|
|
|
|
void T_LOV_LIMIT::set_limitName( const char* arg ){
|
|
strncpy((char*)c_limitName , arg , sizeof(c_limitName));
|
|
c_limitName[sizeof(c_limitName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
long T_LOV_LIMIT::CheckType() const{
|
|
return((long)l_CheckType );
|
|
}
|
|
|
|
short T_LOV_LIMIT::CheckTypeZi() const{
|
|
return( s_CheckTypeZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_CheckType( long arg ){
|
|
l_CheckType = arg;
|
|
s_CheckTypeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_CheckTypeZi( short arg ) {
|
|
s_CheckTypeZi = arg;
|
|
}
|
|
|
|
long T_LOV_LIMIT::Factor() const{
|
|
return((long)l_Factor );
|
|
}
|
|
|
|
short T_LOV_LIMIT::FactorZi() const{
|
|
return( s_FactorZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_Factor( long arg ){
|
|
l_Factor = arg;
|
|
s_FactorZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_FactorZi( short arg ) {
|
|
s_FactorZi = arg;
|
|
}
|
|
|
|
long T_LOV_LIMIT::LowerLimit() const{
|
|
return((long)l_LowerLimit );
|
|
}
|
|
|
|
short T_LOV_LIMIT::LowerLimitZi() const{
|
|
return( s_LowerLimitZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_LowerLimit( long arg ){
|
|
l_LowerLimit = arg;
|
|
s_LowerLimitZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_LowerLimitZi( short arg ) {
|
|
s_LowerLimitZi = arg;
|
|
}
|
|
|
|
long T_LOV_LIMIT::UpperLimit() const{
|
|
return((long)l_UpperLimit );
|
|
}
|
|
|
|
short T_LOV_LIMIT::UpperLimitZi() const{
|
|
return( s_UpperLimitZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_UpperLimit( long arg ){
|
|
l_UpperLimit = arg;
|
|
s_UpperLimitZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_UpperLimitZi( short arg ) {
|
|
s_UpperLimitZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::Enumerate() const{
|
|
return((char*)c_Enumerate );
|
|
}
|
|
|
|
short T_LOV_LIMIT::EnumerateZi() const{
|
|
return( s_EnumerateZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_Enumerate( const char* arg ){
|
|
strncpy((char*)c_Enumerate , arg , sizeof(c_Enumerate));
|
|
c_Enumerate[sizeof(c_Enumerate)-1] = '\0';
|
|
s_EnumerateZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_EnumerateZi( short arg ) {
|
|
s_EnumerateZi = arg;
|
|
}
|
|
|
|
long T_LOV_LIMIT::WarnLevel() const{
|
|
return((long)l_WarnLevel );
|
|
}
|
|
|
|
short T_LOV_LIMIT::WarnLevelZi() const{
|
|
return( s_WarnLevelZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_WarnLevel( long arg ){
|
|
l_WarnLevel = arg;
|
|
s_WarnLevelZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_WarnLevelZi( short arg ) {
|
|
s_WarnLevelZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::ModDescr() const{
|
|
return((char*)c_ModDescr );
|
|
}
|
|
|
|
short T_LOV_LIMIT::ModDescrZi() const{
|
|
return( s_ModDescrZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_ModDescr( const char* arg ){
|
|
strncpy((char*)c_ModDescr , arg , sizeof(c_ModDescr));
|
|
c_ModDescr[sizeof(c_ModDescr)-1] = '\0';
|
|
s_ModDescrZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_ModDescrZi( short arg ) {
|
|
s_ModDescrZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_LOV_LIMIT::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_toc( char* arg ){
|
|
strncpy((char*)c_toc , arg , sizeof(c_toc));
|
|
c_toc[sizeof(c_toc)-1] = '\0';
|
|
s_tocZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_LOV_LIMIT::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_tom( char* arg ){
|
|
strncpy((char*)c_tom , arg , sizeof(c_tom));
|
|
c_tom[sizeof(c_tom)-1] = '\0';
|
|
s_tomZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_LOV_LIMIT::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_mop( char* arg ){
|
|
strncpy((char*)c_mop , arg , sizeof(c_mop));
|
|
c_mop[sizeof(c_mop)-1] = '\0';
|
|
s_mopZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_LOV_LIMIT::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_mou( char* arg ){
|
|
strncpy((char*)c_mou , arg , sizeof(c_mou));
|
|
c_mou[sizeof(c_mou)-1] = '\0';
|
|
s_mouZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
char* T_LOV_LIMIT::k_plantType(){
|
|
return((char*)c_k_plantType );
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_k_plantType( char* arg ){
|
|
strncpy((char*)c_k_plantType , arg , sizeof(c_k_plantType));
|
|
c_k_plantType[sizeof(c_k_plantType)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
char* T_LOV_LIMIT::k_limitName(){
|
|
return((char*)c_k_limitName );
|
|
}
|
|
|
|
void T_LOV_LIMIT::set_k_limitName( char* arg ){
|
|
strncpy((char*)c_k_limitName , arg , sizeof(c_k_limitName));
|
|
c_k_limitName[sizeof(c_k_limitName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_LOV_LIMIT::fillStructure(){
|
|
strncpy ( structTable.plantType , plantType(),sizeof(structTable.plantType));
|
|
strncpy ( structTable.limitName , limitName(),sizeof(structTable.limitName));
|
|
structTable.CheckType = CheckType();
|
|
structTable.Factor = Factor();
|
|
structTable.LowerLimit = LowerLimit();
|
|
structTable.UpperLimit = UpperLimit();
|
|
strncpy ( structTable.Enumerate , Enumerate(),sizeof(structTable.Enumerate));
|
|
structTable.WarnLevel = WarnLevel();
|
|
strncpy ( structTable.ModDescr , ModDescr(),sizeof(structTable.ModDescr));
|
|
strncpy ( structTable.toc , toc(),sizeof(structTable.toc));
|
|
strncpy ( structTable.tom , tom(),sizeof(structTable.tom));
|
|
strncpy ( structTable.mop , mop(),sizeof(structTable.mop));
|
|
strncpy ( structTable.mou , mou(),sizeof(structTable.mou));
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_LIMIT::fillStructureZi(){
|
|
structTableZi.CheckTypeZi = CheckTypeZi();
|
|
structTableZi.FactorZi = FactorZi();
|
|
structTableZi.LowerLimitZi = LowerLimitZi();
|
|
structTableZi.UpperLimitZi = UpperLimitZi();
|
|
structTableZi.EnumerateZi = EnumerateZi();
|
|
structTableZi.WarnLevelZi = WarnLevelZi();
|
|
structTableZi.ModDescrZi = ModDescrZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_LIMIT::setStructure() {
|
|
set_CheckType( structTable.CheckType);
|
|
set_Factor( structTable.Factor);
|
|
set_LowerLimit( structTable.LowerLimit);
|
|
set_UpperLimit( structTable.UpperLimit);
|
|
set_Enumerate( structTable.Enumerate);
|
|
set_WarnLevel( structTable.WarnLevel);
|
|
set_ModDescr( structTable.ModDescr);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_LIMIT::setStructureZi() {
|
|
set_CheckTypeZi( structTableZi.CheckTypeZi);
|
|
set_FactorZi( structTableZi.FactorZi);
|
|
set_LowerLimitZi( structTableZi.LowerLimitZi);
|
|
set_UpperLimitZi( structTableZi.UpperLimitZi);
|
|
set_EnumerateZi( structTableZi.EnumerateZi);
|
|
set_WarnLevelZi( structTableZi.WarnLevelZi);
|
|
set_ModDescrZi( structTableZi.ModDescrZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_LOV_LIMIT::getName(){
|
|
return((char*)"T_LOV_LIMIT");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_LOV_LIMIT::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_LOV_LIMIT::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|