1517 lines
42 KiB
C++
1517 lines
42 KiB
C++
// Version: 2021.1.18 16:0:35
|
|
|
|
// File: T_LOV_FDAAITEM.cpp
|
|
|
|
#include "T_LOV_FDAAITEM.h"
|
|
|
|
T_LOV_FDAAITEM::T_LOV_FDAAITEM(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_LOV_FDAAITEM::~T_LOV_FDAAITEM(){
|
|
}
|
|
void T_LOV_FDAAITEM::initial(){
|
|
// initialise all membervariables
|
|
set_majNo(0);
|
|
set_minNo(0);
|
|
set_eventno(0);
|
|
set_teleId((char*)"");
|
|
set_teleIdZi(-1);
|
|
set_item((char*)"");
|
|
set_itemZi(-1);
|
|
set_chinese((char*)"");
|
|
set_chineseZi(-1);
|
|
set_unit((char*)"");
|
|
set_unitZi(-1);
|
|
set_blockno((char*)"");
|
|
set_blocknoZi(-1);
|
|
set_wordno((char*)"");
|
|
set_wordnoZi(-1);
|
|
set_bitno((char*)"");
|
|
set_bitnoZi(-1);
|
|
set_factor((char*)"");
|
|
set_factorZi(-1);
|
|
set_length(0);
|
|
set_lengthZi(-1);
|
|
set_offset(0);
|
|
set_offsetZi(-1);
|
|
set_repeat(0);
|
|
set_repeatZi(-1);
|
|
set_datatype((char*)"");
|
|
set_datatypeZi(-1);
|
|
set_defaultValue((char*)"");
|
|
set_defaultValueZi(-1);
|
|
set_flag((char*)"");
|
|
set_flagZi(-1);
|
|
set_Table1((char*)"");
|
|
set_Table1Zi(-1);
|
|
set_column1((char*)"");
|
|
set_column1Zi(-1);
|
|
set_Table2((char*)"");
|
|
set_Table2Zi(-1);
|
|
set_column2((char*)"");
|
|
set_column2Zi(-1);
|
|
set_Table3((char*)"");
|
|
set_Table3Zi(-1);
|
|
set_column3((char*)"");
|
|
set_column3Zi(-1);
|
|
set_Table4((char*)"");
|
|
set_Table4Zi(-1);
|
|
set_column4((char*)"");
|
|
set_column4Zi(-1);
|
|
set_Table5((char*)"");
|
|
set_Table5Zi(-1);
|
|
set_column5((char*)"");
|
|
set_column5Zi(-1);
|
|
set_fdaaAddr((char*)"");
|
|
set_fdaaAddrZi(-1);
|
|
set_fdaaItem((char*)"");
|
|
set_fdaaItemZi(-1);
|
|
set_limitDB((char*)"");
|
|
set_limitDBZi(-1);
|
|
set_limitMin((char*)"");
|
|
set_limitMinZi(-1);
|
|
set_limitMax((char*)"");
|
|
set_limitMaxZi(-1);
|
|
set_visable((char*)"");
|
|
set_visableZi(-1);
|
|
set_remark((char*)"");
|
|
set_remarkZi(-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_majNo(0);
|
|
set_k_minNo(0);
|
|
set_k_eventno(0);
|
|
}
|
|
T_LOV_FDAAITEM::T_LOV_FDAAITEM(long arg1,long arg2,long arg3)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1, arg2, arg3);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::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_FDAAITEM
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_LOV_FDAAITEM::setPrimKey( long arg1 , long arg2 , long arg3 ){
|
|
l_k_majNo = arg1;
|
|
l_k_minNo = arg2;
|
|
l_k_eventno = arg3;
|
|
} // end of methode
|
|
|
|
void T_LOV_FDAAITEM::initInsertKeys( long arg1 , long arg2 , long arg3 ){
|
|
setPrimKey ( arg1 , arg2 , arg3);
|
|
l_majNo = arg1;
|
|
l_minNo = arg2;
|
|
l_eventno = arg3;
|
|
} // end of methode
|
|
void T_LOV_FDAAITEM::setKeysFromRecord(){
|
|
set_k_majNo( majNo() );
|
|
set_k_minNo( minNo() );
|
|
set_k_eventno( eventno() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_LOV_FDAAITEM T_LOV_FDAAITEM::operator+(const T_LOV_FDAAITEM &inst) const{
|
|
T_LOV_FDAAITEM ptrT_LOV_FDAAITEM(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_FDAAITEM.set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_FDAAITEM.set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_FDAAITEM.set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
if(inst.teleIdZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_teleId(inst.teleId());
|
|
ptrT_LOV_FDAAITEM.set_teleIdZi(inst.teleIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.itemZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_item(inst.item());
|
|
ptrT_LOV_FDAAITEM.set_itemZi(inst.itemZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.chineseZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_chinese(inst.chinese());
|
|
ptrT_LOV_FDAAITEM.set_chineseZi(inst.chineseZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.unitZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_unit(inst.unit());
|
|
ptrT_LOV_FDAAITEM.set_unitZi(inst.unitZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.blocknoZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_blockno(inst.blockno());
|
|
ptrT_LOV_FDAAITEM.set_blocknoZi(inst.blocknoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.wordnoZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_wordno(inst.wordno());
|
|
ptrT_LOV_FDAAITEM.set_wordnoZi(inst.wordnoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.bitnoZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_bitno(inst.bitno());
|
|
ptrT_LOV_FDAAITEM.set_bitnoZi(inst.bitnoZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.factorZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_factor(inst.factor());
|
|
ptrT_LOV_FDAAITEM.set_factorZi(inst.factorZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.lengthZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_length(inst.length());
|
|
ptrT_LOV_FDAAITEM.set_lengthZi(inst.lengthZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.offsetZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_offset(inst.offset());
|
|
ptrT_LOV_FDAAITEM.set_offsetZi(inst.offsetZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.repeatZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_repeat(inst.repeat());
|
|
ptrT_LOV_FDAAITEM.set_repeatZi(inst.repeatZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.datatypeZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_datatype(inst.datatype());
|
|
ptrT_LOV_FDAAITEM.set_datatypeZi(inst.datatypeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defaultValueZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_defaultValue(inst.defaultValue());
|
|
ptrT_LOV_FDAAITEM.set_defaultValueZi(inst.defaultValueZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.flagZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_flag(inst.flag());
|
|
ptrT_LOV_FDAAITEM.set_flagZi(inst.flagZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table1Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_Table1(inst.Table1());
|
|
ptrT_LOV_FDAAITEM.set_Table1Zi(inst.Table1Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column1Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_column1(inst.column1());
|
|
ptrT_LOV_FDAAITEM.set_column1Zi(inst.column1Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table2Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_Table2(inst.Table2());
|
|
ptrT_LOV_FDAAITEM.set_Table2Zi(inst.Table2Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column2Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_column2(inst.column2());
|
|
ptrT_LOV_FDAAITEM.set_column2Zi(inst.column2Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table3Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_Table3(inst.Table3());
|
|
ptrT_LOV_FDAAITEM.set_Table3Zi(inst.Table3Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column3Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_column3(inst.column3());
|
|
ptrT_LOV_FDAAITEM.set_column3Zi(inst.column3Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table4Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_Table4(inst.Table4());
|
|
ptrT_LOV_FDAAITEM.set_Table4Zi(inst.Table4Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column4Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_column4(inst.column4());
|
|
ptrT_LOV_FDAAITEM.set_column4Zi(inst.column4Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table5Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_Table5(inst.Table5());
|
|
ptrT_LOV_FDAAITEM.set_Table5Zi(inst.Table5Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column5Zi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_column5(inst.column5());
|
|
ptrT_LOV_FDAAITEM.set_column5Zi(inst.column5Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.fdaaAddrZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_fdaaAddr(inst.fdaaAddr());
|
|
ptrT_LOV_FDAAITEM.set_fdaaAddrZi(inst.fdaaAddrZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.fdaaItemZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_fdaaItem(inst.fdaaItem());
|
|
ptrT_LOV_FDAAITEM.set_fdaaItemZi(inst.fdaaItemZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitDBZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_limitDB(inst.limitDB());
|
|
ptrT_LOV_FDAAITEM.set_limitDBZi(inst.limitDBZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitMinZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_limitMin(inst.limitMin());
|
|
ptrT_LOV_FDAAITEM.set_limitMinZi(inst.limitMinZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitMaxZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_limitMax(inst.limitMax());
|
|
ptrT_LOV_FDAAITEM.set_limitMaxZi(inst.limitMaxZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.visableZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_visable(inst.visable());
|
|
ptrT_LOV_FDAAITEM.set_visableZi(inst.visableZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.remarkZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_remark(inst.remark());
|
|
ptrT_LOV_FDAAITEM.set_remarkZi(inst.remarkZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_toc(inst.toc());
|
|
ptrT_LOV_FDAAITEM.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_tom(inst.tom());
|
|
ptrT_LOV_FDAAITEM.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_mop(inst.mop());
|
|
ptrT_LOV_FDAAITEM.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_LOV_FDAAITEM.set_mou(inst.mou());
|
|
ptrT_LOV_FDAAITEM.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_LOV_FDAAITEM);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_LOV_FDAAITEM& T_LOV_FDAAITEM::operator=(const T_LOV_FDAAITEM &inst){
|
|
//----------------------------------------------------------
|
|
this->set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
this->set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
this->set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
this->set_teleId(inst.teleId());
|
|
this->set_teleIdZi(inst.teleIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_item(inst.item());
|
|
this->set_itemZi(inst.itemZi());
|
|
//----------------------------------------------------------
|
|
this->set_chinese(inst.chinese());
|
|
this->set_chineseZi(inst.chineseZi());
|
|
//----------------------------------------------------------
|
|
this->set_unit(inst.unit());
|
|
this->set_unitZi(inst.unitZi());
|
|
//----------------------------------------------------------
|
|
this->set_blockno(inst.blockno());
|
|
this->set_blocknoZi(inst.blocknoZi());
|
|
//----------------------------------------------------------
|
|
this->set_wordno(inst.wordno());
|
|
this->set_wordnoZi(inst.wordnoZi());
|
|
//----------------------------------------------------------
|
|
this->set_bitno(inst.bitno());
|
|
this->set_bitnoZi(inst.bitnoZi());
|
|
//----------------------------------------------------------
|
|
this->set_factor(inst.factor());
|
|
this->set_factorZi(inst.factorZi());
|
|
//----------------------------------------------------------
|
|
this->set_length(inst.length());
|
|
this->set_lengthZi(inst.lengthZi());
|
|
//----------------------------------------------------------
|
|
this->set_offset(inst.offset());
|
|
this->set_offsetZi(inst.offsetZi());
|
|
//----------------------------------------------------------
|
|
this->set_repeat(inst.repeat());
|
|
this->set_repeatZi(inst.repeatZi());
|
|
//----------------------------------------------------------
|
|
this->set_datatype(inst.datatype());
|
|
this->set_datatypeZi(inst.datatypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defaultValue(inst.defaultValue());
|
|
this->set_defaultValueZi(inst.defaultValueZi());
|
|
//----------------------------------------------------------
|
|
this->set_flag(inst.flag());
|
|
this->set_flagZi(inst.flagZi());
|
|
//----------------------------------------------------------
|
|
this->set_Table1(inst.Table1());
|
|
this->set_Table1Zi(inst.Table1Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column1(inst.column1());
|
|
this->set_column1Zi(inst.column1Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table2(inst.Table2());
|
|
this->set_Table2Zi(inst.Table2Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column2(inst.column2());
|
|
this->set_column2Zi(inst.column2Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table3(inst.Table3());
|
|
this->set_Table3Zi(inst.Table3Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column3(inst.column3());
|
|
this->set_column3Zi(inst.column3Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table4(inst.Table4());
|
|
this->set_Table4Zi(inst.Table4Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column4(inst.column4());
|
|
this->set_column4Zi(inst.column4Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table5(inst.Table5());
|
|
this->set_Table5Zi(inst.Table5Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column5(inst.column5());
|
|
this->set_column5Zi(inst.column5Zi());
|
|
//----------------------------------------------------------
|
|
this->set_fdaaAddr(inst.fdaaAddr());
|
|
this->set_fdaaAddrZi(inst.fdaaAddrZi());
|
|
//----------------------------------------------------------
|
|
this->set_fdaaItem(inst.fdaaItem());
|
|
this->set_fdaaItemZi(inst.fdaaItemZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitDB(inst.limitDB());
|
|
this->set_limitDBZi(inst.limitDBZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitMin(inst.limitMin());
|
|
this->set_limitMinZi(inst.limitMinZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitMax(inst.limitMax());
|
|
this->set_limitMaxZi(inst.limitMaxZi());
|
|
//----------------------------------------------------------
|
|
this->set_visable(inst.visable());
|
|
this->set_visableZi(inst.visableZi());
|
|
//----------------------------------------------------------
|
|
this->set_remark(inst.remark());
|
|
this->set_remarkZi(inst.remarkZi());
|
|
//----------------------------------------------------------
|
|
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_FDAAITEM::T_LOV_FDAAITEM(const T_LOV_FDAAITEM &inst){
|
|
//----------------------------------------------------------
|
|
this->set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
this->set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
this->set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
this->set_teleId(inst.teleId());
|
|
this->set_teleIdZi(inst.teleIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_item(inst.item());
|
|
this->set_itemZi(inst.itemZi());
|
|
//----------------------------------------------------------
|
|
this->set_chinese(inst.chinese());
|
|
this->set_chineseZi(inst.chineseZi());
|
|
//----------------------------------------------------------
|
|
this->set_unit(inst.unit());
|
|
this->set_unitZi(inst.unitZi());
|
|
//----------------------------------------------------------
|
|
this->set_blockno(inst.blockno());
|
|
this->set_blocknoZi(inst.blocknoZi());
|
|
//----------------------------------------------------------
|
|
this->set_wordno(inst.wordno());
|
|
this->set_wordnoZi(inst.wordnoZi());
|
|
//----------------------------------------------------------
|
|
this->set_bitno(inst.bitno());
|
|
this->set_bitnoZi(inst.bitnoZi());
|
|
//----------------------------------------------------------
|
|
this->set_factor(inst.factor());
|
|
this->set_factorZi(inst.factorZi());
|
|
//----------------------------------------------------------
|
|
this->set_length(inst.length());
|
|
this->set_lengthZi(inst.lengthZi());
|
|
//----------------------------------------------------------
|
|
this->set_offset(inst.offset());
|
|
this->set_offsetZi(inst.offsetZi());
|
|
//----------------------------------------------------------
|
|
this->set_repeat(inst.repeat());
|
|
this->set_repeatZi(inst.repeatZi());
|
|
//----------------------------------------------------------
|
|
this->set_datatype(inst.datatype());
|
|
this->set_datatypeZi(inst.datatypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defaultValue(inst.defaultValue());
|
|
this->set_defaultValueZi(inst.defaultValueZi());
|
|
//----------------------------------------------------------
|
|
this->set_flag(inst.flag());
|
|
this->set_flagZi(inst.flagZi());
|
|
//----------------------------------------------------------
|
|
this->set_Table1(inst.Table1());
|
|
this->set_Table1Zi(inst.Table1Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column1(inst.column1());
|
|
this->set_column1Zi(inst.column1Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table2(inst.Table2());
|
|
this->set_Table2Zi(inst.Table2Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column2(inst.column2());
|
|
this->set_column2Zi(inst.column2Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table3(inst.Table3());
|
|
this->set_Table3Zi(inst.Table3Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column3(inst.column3());
|
|
this->set_column3Zi(inst.column3Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table4(inst.Table4());
|
|
this->set_Table4Zi(inst.Table4Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column4(inst.column4());
|
|
this->set_column4Zi(inst.column4Zi());
|
|
//----------------------------------------------------------
|
|
this->set_Table5(inst.Table5());
|
|
this->set_Table5Zi(inst.Table5Zi());
|
|
//----------------------------------------------------------
|
|
this->set_column5(inst.column5());
|
|
this->set_column5Zi(inst.column5Zi());
|
|
//----------------------------------------------------------
|
|
this->set_fdaaAddr(inst.fdaaAddr());
|
|
this->set_fdaaAddrZi(inst.fdaaAddrZi());
|
|
//----------------------------------------------------------
|
|
this->set_fdaaItem(inst.fdaaItem());
|
|
this->set_fdaaItemZi(inst.fdaaItemZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitDB(inst.limitDB());
|
|
this->set_limitDBZi(inst.limitDBZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitMin(inst.limitMin());
|
|
this->set_limitMinZi(inst.limitMinZi());
|
|
//----------------------------------------------------------
|
|
this->set_limitMax(inst.limitMax());
|
|
this->set_limitMaxZi(inst.limitMaxZi());
|
|
//----------------------------------------------------------
|
|
this->set_visable(inst.visable());
|
|
this->set_visableZi(inst.visableZi());
|
|
//----------------------------------------------------------
|
|
this->set_remark(inst.remark());
|
|
this->set_remarkZi(inst.remarkZi());
|
|
//----------------------------------------------------------
|
|
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());
|
|
}
|
|
long T_LOV_FDAAITEM::majNo() const{
|
|
return((long)l_majNo );
|
|
}
|
|
|
|
|
|
void T_LOV_FDAAITEM::set_majNo( long arg ){
|
|
l_majNo = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
long T_LOV_FDAAITEM::minNo() const{
|
|
return((long)l_minNo );
|
|
}
|
|
|
|
|
|
void T_LOV_FDAAITEM::set_minNo( long arg ){
|
|
l_minNo = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
long T_LOV_FDAAITEM::eventno() const{
|
|
return((long)l_eventno );
|
|
}
|
|
|
|
|
|
void T_LOV_FDAAITEM::set_eventno( long arg ){
|
|
l_eventno = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_LOV_FDAAITEM::teleId() const{
|
|
return((char*)c_teleId );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::teleIdZi() const{
|
|
return( s_teleIdZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_teleId( const char* arg ){
|
|
strncpy((char*)c_teleId , arg , sizeof(c_teleId));
|
|
c_teleId[sizeof(c_teleId)-1] = '\0';
|
|
s_teleIdZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_teleIdZi( short arg ) {
|
|
s_teleIdZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::item() const{
|
|
return((char*)c_item );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::itemZi() const{
|
|
return( s_itemZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_item( const char* arg ){
|
|
strncpy((char*)c_item , arg , sizeof(c_item));
|
|
c_item[sizeof(c_item)-1] = '\0';
|
|
s_itemZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_itemZi( short arg ) {
|
|
s_itemZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::chinese() const{
|
|
return((char*)c_chinese );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::chineseZi() const{
|
|
return( s_chineseZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_chinese( const char* arg ){
|
|
strncpy((char*)c_chinese , arg , sizeof(c_chinese));
|
|
c_chinese[sizeof(c_chinese)-1] = '\0';
|
|
s_chineseZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_chineseZi( short arg ) {
|
|
s_chineseZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::unit() const{
|
|
return((char*)c_unit );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::unitZi() const{
|
|
return( s_unitZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_unit( const char* arg ){
|
|
strncpy((char*)c_unit , arg , sizeof(c_unit));
|
|
c_unit[sizeof(c_unit)-1] = '\0';
|
|
s_unitZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_unitZi( short arg ) {
|
|
s_unitZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::blockno() const{
|
|
return((char*)c_blockno );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::blocknoZi() const{
|
|
return( s_blocknoZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_blockno( const char* arg ){
|
|
strncpy((char*)c_blockno , arg , sizeof(c_blockno));
|
|
c_blockno[sizeof(c_blockno)-1] = '\0';
|
|
s_blocknoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_blocknoZi( short arg ) {
|
|
s_blocknoZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::wordno() const{
|
|
return((char*)c_wordno );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::wordnoZi() const{
|
|
return( s_wordnoZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_wordno( const char* arg ){
|
|
strncpy((char*)c_wordno , arg , sizeof(c_wordno));
|
|
c_wordno[sizeof(c_wordno)-1] = '\0';
|
|
s_wordnoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_wordnoZi( short arg ) {
|
|
s_wordnoZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::bitno() const{
|
|
return((char*)c_bitno );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::bitnoZi() const{
|
|
return( s_bitnoZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_bitno( const char* arg ){
|
|
strncpy((char*)c_bitno , arg , sizeof(c_bitno));
|
|
c_bitno[sizeof(c_bitno)-1] = '\0';
|
|
s_bitnoZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_bitnoZi( short arg ) {
|
|
s_bitnoZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::factor() const{
|
|
return((char*)c_factor );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::factorZi() const{
|
|
return( s_factorZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_factor( const char* arg ){
|
|
strncpy((char*)c_factor , arg , sizeof(c_factor));
|
|
c_factor[sizeof(c_factor)-1] = '\0';
|
|
s_factorZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_factorZi( short arg ) {
|
|
s_factorZi = arg;
|
|
}
|
|
|
|
long T_LOV_FDAAITEM::length() const{
|
|
return((long)l_length );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::lengthZi() const{
|
|
return( s_lengthZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_length( long arg ){
|
|
l_length = arg;
|
|
s_lengthZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_lengthZi( short arg ) {
|
|
s_lengthZi = arg;
|
|
}
|
|
|
|
long T_LOV_FDAAITEM::offset() const{
|
|
return((long)l_offset );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::offsetZi() const{
|
|
return( s_offsetZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_offset( long arg ){
|
|
l_offset = arg;
|
|
s_offsetZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_offsetZi( short arg ) {
|
|
s_offsetZi = arg;
|
|
}
|
|
|
|
long T_LOV_FDAAITEM::repeat() const{
|
|
return((long)l_repeat );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::repeatZi() const{
|
|
return( s_repeatZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_repeat( long arg ){
|
|
l_repeat = arg;
|
|
s_repeatZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_repeatZi( short arg ) {
|
|
s_repeatZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::datatype() const{
|
|
return((char*)c_datatype );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::datatypeZi() const{
|
|
return( s_datatypeZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_datatype( const char* arg ){
|
|
strncpy((char*)c_datatype , arg , sizeof(c_datatype));
|
|
c_datatype[sizeof(c_datatype)-1] = '\0';
|
|
s_datatypeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_datatypeZi( short arg ) {
|
|
s_datatypeZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::defaultValue() const{
|
|
return((char*)c_defaultValue );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::defaultValueZi() const{
|
|
return( s_defaultValueZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_defaultValue( const char* arg ){
|
|
strncpy((char*)c_defaultValue , arg , sizeof(c_defaultValue));
|
|
c_defaultValue[sizeof(c_defaultValue)-1] = '\0';
|
|
s_defaultValueZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_defaultValueZi( short arg ) {
|
|
s_defaultValueZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::flag() const{
|
|
return((char*)c_flag );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::flagZi() const{
|
|
return( s_flagZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_flag( const char* arg ){
|
|
strncpy((char*)c_flag , arg , sizeof(c_flag));
|
|
c_flag[sizeof(c_flag)-1] = '\0';
|
|
s_flagZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_flagZi( short arg ) {
|
|
s_flagZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::Table1() const{
|
|
return((char*)c_Table1 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::Table1Zi() const{
|
|
return( s_Table1Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table1( const char* arg ){
|
|
strncpy((char*)c_Table1 , arg , sizeof(c_Table1));
|
|
c_Table1[sizeof(c_Table1)-1] = '\0';
|
|
s_Table1Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table1Zi( short arg ) {
|
|
s_Table1Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::column1() const{
|
|
return((char*)c_column1 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::column1Zi() const{
|
|
return( s_column1Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column1( const char* arg ){
|
|
strncpy((char*)c_column1 , arg , sizeof(c_column1));
|
|
c_column1[sizeof(c_column1)-1] = '\0';
|
|
s_column1Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column1Zi( short arg ) {
|
|
s_column1Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::Table2() const{
|
|
return((char*)c_Table2 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::Table2Zi() const{
|
|
return( s_Table2Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table2( const char* arg ){
|
|
strncpy((char*)c_Table2 , arg , sizeof(c_Table2));
|
|
c_Table2[sizeof(c_Table2)-1] = '\0';
|
|
s_Table2Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table2Zi( short arg ) {
|
|
s_Table2Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::column2() const{
|
|
return((char*)c_column2 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::column2Zi() const{
|
|
return( s_column2Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column2( const char* arg ){
|
|
strncpy((char*)c_column2 , arg , sizeof(c_column2));
|
|
c_column2[sizeof(c_column2)-1] = '\0';
|
|
s_column2Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column2Zi( short arg ) {
|
|
s_column2Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::Table3() const{
|
|
return((char*)c_Table3 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::Table3Zi() const{
|
|
return( s_Table3Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table3( const char* arg ){
|
|
strncpy((char*)c_Table3 , arg , sizeof(c_Table3));
|
|
c_Table3[sizeof(c_Table3)-1] = '\0';
|
|
s_Table3Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table3Zi( short arg ) {
|
|
s_Table3Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::column3() const{
|
|
return((char*)c_column3 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::column3Zi() const{
|
|
return( s_column3Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column3( const char* arg ){
|
|
strncpy((char*)c_column3 , arg , sizeof(c_column3));
|
|
c_column3[sizeof(c_column3)-1] = '\0';
|
|
s_column3Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column3Zi( short arg ) {
|
|
s_column3Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::Table4() const{
|
|
return((char*)c_Table4 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::Table4Zi() const{
|
|
return( s_Table4Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table4( const char* arg ){
|
|
strncpy((char*)c_Table4 , arg , sizeof(c_Table4));
|
|
c_Table4[sizeof(c_Table4)-1] = '\0';
|
|
s_Table4Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table4Zi( short arg ) {
|
|
s_Table4Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::column4() const{
|
|
return((char*)c_column4 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::column4Zi() const{
|
|
return( s_column4Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column4( const char* arg ){
|
|
strncpy((char*)c_column4 , arg , sizeof(c_column4));
|
|
c_column4[sizeof(c_column4)-1] = '\0';
|
|
s_column4Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column4Zi( short arg ) {
|
|
s_column4Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::Table5() const{
|
|
return((char*)c_Table5 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::Table5Zi() const{
|
|
return( s_Table5Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table5( const char* arg ){
|
|
strncpy((char*)c_Table5 , arg , sizeof(c_Table5));
|
|
c_Table5[sizeof(c_Table5)-1] = '\0';
|
|
s_Table5Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_Table5Zi( short arg ) {
|
|
s_Table5Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::column5() const{
|
|
return((char*)c_column5 );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::column5Zi() const{
|
|
return( s_column5Zi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column5( const char* arg ){
|
|
strncpy((char*)c_column5 , arg , sizeof(c_column5));
|
|
c_column5[sizeof(c_column5)-1] = '\0';
|
|
s_column5Zi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_column5Zi( short arg ) {
|
|
s_column5Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::fdaaAddr() const{
|
|
return((char*)c_fdaaAddr );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::fdaaAddrZi() const{
|
|
return( s_fdaaAddrZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_fdaaAddr( const char* arg ){
|
|
strncpy((char*)c_fdaaAddr , arg , sizeof(c_fdaaAddr));
|
|
c_fdaaAddr[sizeof(c_fdaaAddr)-1] = '\0';
|
|
s_fdaaAddrZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_fdaaAddrZi( short arg ) {
|
|
s_fdaaAddrZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::fdaaItem() const{
|
|
return((char*)c_fdaaItem );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::fdaaItemZi() const{
|
|
return( s_fdaaItemZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_fdaaItem( const char* arg ){
|
|
strncpy((char*)c_fdaaItem , arg , sizeof(c_fdaaItem));
|
|
c_fdaaItem[sizeof(c_fdaaItem)-1] = '\0';
|
|
s_fdaaItemZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_fdaaItemZi( short arg ) {
|
|
s_fdaaItemZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::limitDB() const{
|
|
return((char*)c_limitDB );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::limitDBZi() const{
|
|
return( s_limitDBZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitDB( const char* arg ){
|
|
strncpy((char*)c_limitDB , arg , sizeof(c_limitDB));
|
|
c_limitDB[sizeof(c_limitDB)-1] = '\0';
|
|
s_limitDBZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitDBZi( short arg ) {
|
|
s_limitDBZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::limitMin() const{
|
|
return((char*)c_limitMin );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::limitMinZi() const{
|
|
return( s_limitMinZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitMin( const char* arg ){
|
|
strncpy((char*)c_limitMin , arg , sizeof(c_limitMin));
|
|
c_limitMin[sizeof(c_limitMin)-1] = '\0';
|
|
s_limitMinZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitMinZi( short arg ) {
|
|
s_limitMinZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::limitMax() const{
|
|
return((char*)c_limitMax );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::limitMaxZi() const{
|
|
return( s_limitMaxZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitMax( const char* arg ){
|
|
strncpy((char*)c_limitMax , arg , sizeof(c_limitMax));
|
|
c_limitMax[sizeof(c_limitMax)-1] = '\0';
|
|
s_limitMaxZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_limitMaxZi( short arg ) {
|
|
s_limitMaxZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::visable() const{
|
|
return((char*)c_visable );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::visableZi() const{
|
|
return( s_visableZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_visable( const char* arg ){
|
|
strncpy((char*)c_visable , arg , sizeof(c_visable));
|
|
c_visable[sizeof(c_visable)-1] = '\0';
|
|
s_visableZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_visableZi( short arg ) {
|
|
s_visableZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::remark() const{
|
|
return((char*)c_remark );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::remarkZi() const{
|
|
return( s_remarkZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_remark( const char* arg ){
|
|
strncpy((char*)c_remark , arg , sizeof(c_remark));
|
|
c_remark[sizeof(c_remark)-1] = '\0';
|
|
s_remarkZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_remarkZi( short arg ) {
|
|
s_remarkZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::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_FDAAITEM::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::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_FDAAITEM::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::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_FDAAITEM::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_LOV_FDAAITEM::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_LOV_FDAAITEM::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::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_FDAAITEM::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_LOV_FDAAITEM::k_majNo(){
|
|
return((long)l_k_majNo );
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_k_majNo( long arg ){
|
|
l_k_majNo = arg;
|
|
return;
|
|
}
|
|
|
|
long T_LOV_FDAAITEM::k_minNo(){
|
|
return((long)l_k_minNo );
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_k_minNo( long arg ){
|
|
l_k_minNo = arg;
|
|
return;
|
|
}
|
|
|
|
long T_LOV_FDAAITEM::k_eventno(){
|
|
return((long)l_k_eventno );
|
|
}
|
|
|
|
void T_LOV_FDAAITEM::set_k_eventno( long arg ){
|
|
l_k_eventno = arg;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_LOV_FDAAITEM::fillStructure(){
|
|
structTable.majNo = majNo();
|
|
structTable.minNo = minNo();
|
|
structTable.eventno = eventno();
|
|
strncpy ( structTable.teleId , teleId(),sizeof(structTable.teleId));
|
|
strncpy ( structTable.item , item(),sizeof(structTable.item));
|
|
strncpy ( structTable.chinese , chinese(),sizeof(structTable.chinese));
|
|
strncpy ( structTable.unit , unit(),sizeof(structTable.unit));
|
|
strncpy ( structTable.blockno , blockno(),sizeof(structTable.blockno));
|
|
strncpy ( structTable.wordno , wordno(),sizeof(structTable.wordno));
|
|
strncpy ( structTable.bitno , bitno(),sizeof(structTable.bitno));
|
|
strncpy ( structTable.factor , factor(),sizeof(structTable.factor));
|
|
structTable.length = length();
|
|
structTable.offset = offset();
|
|
structTable.repeat = repeat();
|
|
strncpy ( structTable.datatype , datatype(),sizeof(structTable.datatype));
|
|
strncpy ( structTable.defaultValue , defaultValue(),sizeof(structTable.defaultValue));
|
|
strncpy ( structTable.flag , flag(),sizeof(structTable.flag));
|
|
strncpy ( structTable.Table1 , Table1(),sizeof(structTable.Table1));
|
|
strncpy ( structTable.column1 , column1(),sizeof(structTable.column1));
|
|
strncpy ( structTable.Table2 , Table2(),sizeof(structTable.Table2));
|
|
strncpy ( structTable.column2 , column2(),sizeof(structTable.column2));
|
|
strncpy ( structTable.Table3 , Table3(),sizeof(structTable.Table3));
|
|
strncpy ( structTable.column3 , column3(),sizeof(structTable.column3));
|
|
strncpy ( structTable.Table4 , Table4(),sizeof(structTable.Table4));
|
|
strncpy ( structTable.column4 , column4(),sizeof(structTable.column4));
|
|
strncpy ( structTable.Table5 , Table5(),sizeof(structTable.Table5));
|
|
strncpy ( structTable.column5 , column5(),sizeof(structTable.column5));
|
|
strncpy ( structTable.fdaaAddr , fdaaAddr(),sizeof(structTable.fdaaAddr));
|
|
strncpy ( structTable.fdaaItem , fdaaItem(),sizeof(structTable.fdaaItem));
|
|
strncpy ( structTable.limitDB , limitDB(),sizeof(structTable.limitDB));
|
|
strncpy ( structTable.limitMin , limitMin(),sizeof(structTable.limitMin));
|
|
strncpy ( structTable.limitMax , limitMax(),sizeof(structTable.limitMax));
|
|
strncpy ( structTable.visable , visable(),sizeof(structTable.visable));
|
|
strncpy ( structTable.remark , remark(),sizeof(structTable.remark));
|
|
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_FDAAITEM::fillStructureZi(){
|
|
structTableZi.teleIdZi = teleIdZi();
|
|
structTableZi.itemZi = itemZi();
|
|
structTableZi.chineseZi = chineseZi();
|
|
structTableZi.unitZi = unitZi();
|
|
structTableZi.blocknoZi = blocknoZi();
|
|
structTableZi.wordnoZi = wordnoZi();
|
|
structTableZi.bitnoZi = bitnoZi();
|
|
structTableZi.factorZi = factorZi();
|
|
structTableZi.lengthZi = lengthZi();
|
|
structTableZi.offsetZi = offsetZi();
|
|
structTableZi.repeatZi = repeatZi();
|
|
structTableZi.datatypeZi = datatypeZi();
|
|
structTableZi.defaultValueZi = defaultValueZi();
|
|
structTableZi.flagZi = flagZi();
|
|
structTableZi.Table1Zi = Table1Zi();
|
|
structTableZi.column1Zi = column1Zi();
|
|
structTableZi.Table2Zi = Table2Zi();
|
|
structTableZi.column2Zi = column2Zi();
|
|
structTableZi.Table3Zi = Table3Zi();
|
|
structTableZi.column3Zi = column3Zi();
|
|
structTableZi.Table4Zi = Table4Zi();
|
|
structTableZi.column4Zi = column4Zi();
|
|
structTableZi.Table5Zi = Table5Zi();
|
|
structTableZi.column5Zi = column5Zi();
|
|
structTableZi.fdaaAddrZi = fdaaAddrZi();
|
|
structTableZi.fdaaItemZi = fdaaItemZi();
|
|
structTableZi.limitDBZi = limitDBZi();
|
|
structTableZi.limitMinZi = limitMinZi();
|
|
structTableZi.limitMaxZi = limitMaxZi();
|
|
structTableZi.visableZi = visableZi();
|
|
structTableZi.remarkZi = remarkZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_FDAAITEM::setStructure() {
|
|
set_teleId( structTable.teleId);
|
|
set_item( structTable.item);
|
|
set_chinese( structTable.chinese);
|
|
set_unit( structTable.unit);
|
|
set_blockno( structTable.blockno);
|
|
set_wordno( structTable.wordno);
|
|
set_bitno( structTable.bitno);
|
|
set_factor( structTable.factor);
|
|
set_length( structTable.length);
|
|
set_offset( structTable.offset);
|
|
set_repeat( structTable.repeat);
|
|
set_datatype( structTable.datatype);
|
|
set_defaultValue( structTable.defaultValue);
|
|
set_flag( structTable.flag);
|
|
set_Table1( structTable.Table1);
|
|
set_column1( structTable.column1);
|
|
set_Table2( structTable.Table2);
|
|
set_column2( structTable.column2);
|
|
set_Table3( structTable.Table3);
|
|
set_column3( structTable.column3);
|
|
set_Table4( structTable.Table4);
|
|
set_column4( structTable.column4);
|
|
set_Table5( structTable.Table5);
|
|
set_column5( structTable.column5);
|
|
set_fdaaAddr( structTable.fdaaAddr);
|
|
set_fdaaItem( structTable.fdaaItem);
|
|
set_limitDB( structTable.limitDB);
|
|
set_limitMin( structTable.limitMin);
|
|
set_limitMax( structTable.limitMax);
|
|
set_visable( structTable.visable);
|
|
set_remark( structTable.remark);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_FDAAITEM::setStructureZi() {
|
|
set_teleIdZi( structTableZi.teleIdZi);
|
|
set_itemZi( structTableZi.itemZi);
|
|
set_chineseZi( structTableZi.chineseZi);
|
|
set_unitZi( structTableZi.unitZi);
|
|
set_blocknoZi( structTableZi.blocknoZi);
|
|
set_wordnoZi( structTableZi.wordnoZi);
|
|
set_bitnoZi( structTableZi.bitnoZi);
|
|
set_factorZi( structTableZi.factorZi);
|
|
set_lengthZi( structTableZi.lengthZi);
|
|
set_offsetZi( structTableZi.offsetZi);
|
|
set_repeatZi( structTableZi.repeatZi);
|
|
set_datatypeZi( structTableZi.datatypeZi);
|
|
set_defaultValueZi( structTableZi.defaultValueZi);
|
|
set_flagZi( structTableZi.flagZi);
|
|
set_Table1Zi( structTableZi.Table1Zi);
|
|
set_column1Zi( structTableZi.column1Zi);
|
|
set_Table2Zi( structTableZi.Table2Zi);
|
|
set_column2Zi( structTableZi.column2Zi);
|
|
set_Table3Zi( structTableZi.Table3Zi);
|
|
set_column3Zi( structTableZi.column3Zi);
|
|
set_Table4Zi( structTableZi.Table4Zi);
|
|
set_column4Zi( structTableZi.column4Zi);
|
|
set_Table5Zi( structTableZi.Table5Zi);
|
|
set_column5Zi( structTableZi.column5Zi);
|
|
set_fdaaAddrZi( structTableZi.fdaaAddrZi);
|
|
set_fdaaItemZi( structTableZi.fdaaItemZi);
|
|
set_limitDBZi( structTableZi.limitDBZi);
|
|
set_limitMinZi( structTableZi.limitMinZi);
|
|
set_limitMaxZi( structTableZi.limitMaxZi);
|
|
set_visableZi( structTableZi.visableZi);
|
|
set_remarkZi( structTableZi.remarkZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_LOV_FDAAITEM::getName(){
|
|
return((char*)"T_LOV_FDAAITEM");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_LOV_FDAAITEM::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_LOV_FDAAITEM::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|