1230 lines
33 KiB
C++
1230 lines
33 KiB
C++
// Version: 2019.4.4 10:22:45
|
|
|
|
// File: T_LOV_TELEITEM.cpp
|
|
|
|
#include "T_LOV_TELEITEM.h"
|
|
|
|
T_LOV_TELEITEM::T_LOV_TELEITEM(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_LOV_TELEITEM::~T_LOV_TELEITEM(){
|
|
}
|
|
void T_LOV_TELEITEM::initial(){
|
|
// initialise all membervariables
|
|
set_majNo(0);
|
|
set_minNo(0);
|
|
set_eventno(0);
|
|
set_item((char*)"");
|
|
set_itemZi(-1);
|
|
set_teleId((char*)"");
|
|
set_teleIdZi(-1);
|
|
set_chinese((char*)"");
|
|
set_chineseZi(-1);
|
|
set_factor((char*)"");
|
|
set_factorZi(-1);
|
|
set_length(0);
|
|
set_lengthZi(-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_limitDB((char*)"");
|
|
set_limitDBZi(-1);
|
|
set_limitMin((char*)"");
|
|
set_limitMinZi(-1);
|
|
set_limitMax((char*)"");
|
|
set_limitMaxZi(-1);
|
|
set_Print((char*)"");
|
|
set_PrintZi(-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_TELEITEM::T_LOV_TELEITEM(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_TELEITEM:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::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_TELEITEM
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_LOV_TELEITEM::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_TELEITEM::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_TELEITEM::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_TELEITEM T_LOV_TELEITEM::operator+(const T_LOV_TELEITEM &inst) const{
|
|
T_LOV_TELEITEM ptrT_LOV_TELEITEM(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_TELEITEM.set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_TELEITEM.set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
ptrT_LOV_TELEITEM.set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
if(inst.itemZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_item(inst.item());
|
|
ptrT_LOV_TELEITEM.set_itemZi(inst.itemZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.teleIdZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_teleId(inst.teleId());
|
|
ptrT_LOV_TELEITEM.set_teleIdZi(inst.teleIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.chineseZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_chinese(inst.chinese());
|
|
ptrT_LOV_TELEITEM.set_chineseZi(inst.chineseZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.factorZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_factor(inst.factor());
|
|
ptrT_LOV_TELEITEM.set_factorZi(inst.factorZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.lengthZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_length(inst.length());
|
|
ptrT_LOV_TELEITEM.set_lengthZi(inst.lengthZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.repeatZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_repeat(inst.repeat());
|
|
ptrT_LOV_TELEITEM.set_repeatZi(inst.repeatZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.datatypeZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_datatype(inst.datatype());
|
|
ptrT_LOV_TELEITEM.set_datatypeZi(inst.datatypeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defaultValueZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_defaultValue(inst.defaultValue());
|
|
ptrT_LOV_TELEITEM.set_defaultValueZi(inst.defaultValueZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.flagZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_flag(inst.flag());
|
|
ptrT_LOV_TELEITEM.set_flagZi(inst.flagZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table1Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Table1(inst.Table1());
|
|
ptrT_LOV_TELEITEM.set_Table1Zi(inst.Table1Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column1Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_column1(inst.column1());
|
|
ptrT_LOV_TELEITEM.set_column1Zi(inst.column1Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table2Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Table2(inst.Table2());
|
|
ptrT_LOV_TELEITEM.set_Table2Zi(inst.Table2Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column2Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_column2(inst.column2());
|
|
ptrT_LOV_TELEITEM.set_column2Zi(inst.column2Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table3Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Table3(inst.Table3());
|
|
ptrT_LOV_TELEITEM.set_Table3Zi(inst.Table3Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column3Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_column3(inst.column3());
|
|
ptrT_LOV_TELEITEM.set_column3Zi(inst.column3Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table4Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Table4(inst.Table4());
|
|
ptrT_LOV_TELEITEM.set_Table4Zi(inst.Table4Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column4Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_column4(inst.column4());
|
|
ptrT_LOV_TELEITEM.set_column4Zi(inst.column4Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.Table5Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Table5(inst.Table5());
|
|
ptrT_LOV_TELEITEM.set_Table5Zi(inst.Table5Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.column5Zi() != -1){
|
|
ptrT_LOV_TELEITEM.set_column5(inst.column5());
|
|
ptrT_LOV_TELEITEM.set_column5Zi(inst.column5Zi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitDBZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_limitDB(inst.limitDB());
|
|
ptrT_LOV_TELEITEM.set_limitDBZi(inst.limitDBZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitMinZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_limitMin(inst.limitMin());
|
|
ptrT_LOV_TELEITEM.set_limitMinZi(inst.limitMinZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.limitMaxZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_limitMax(inst.limitMax());
|
|
ptrT_LOV_TELEITEM.set_limitMaxZi(inst.limitMaxZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.PrintZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_Print(inst.Print());
|
|
ptrT_LOV_TELEITEM.set_PrintZi(inst.PrintZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_toc(inst.toc());
|
|
ptrT_LOV_TELEITEM.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_tom(inst.tom());
|
|
ptrT_LOV_TELEITEM.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_mop(inst.mop());
|
|
ptrT_LOV_TELEITEM.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_LOV_TELEITEM.set_mou(inst.mou());
|
|
ptrT_LOV_TELEITEM.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_LOV_TELEITEM);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_LOV_TELEITEM& T_LOV_TELEITEM::operator=(const T_LOV_TELEITEM &inst){
|
|
//----------------------------------------------------------
|
|
this->set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
this->set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
this->set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
this->set_item(inst.item());
|
|
this->set_itemZi(inst.itemZi());
|
|
//----------------------------------------------------------
|
|
this->set_teleId(inst.teleId());
|
|
this->set_teleIdZi(inst.teleIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_chinese(inst.chinese());
|
|
this->set_chineseZi(inst.chineseZi());
|
|
//----------------------------------------------------------
|
|
this->set_factor(inst.factor());
|
|
this->set_factorZi(inst.factorZi());
|
|
//----------------------------------------------------------
|
|
this->set_length(inst.length());
|
|
this->set_lengthZi(inst.lengthZi());
|
|
//----------------------------------------------------------
|
|
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_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_Print(inst.Print());
|
|
this->set_PrintZi(inst.PrintZi());
|
|
//----------------------------------------------------------
|
|
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_TELEITEM::T_LOV_TELEITEM(const T_LOV_TELEITEM &inst){
|
|
//----------------------------------------------------------
|
|
this->set_majNo(inst.majNo());
|
|
//----------------------------------------------------------
|
|
this->set_minNo(inst.minNo());
|
|
//----------------------------------------------------------
|
|
this->set_eventno(inst.eventno());
|
|
//----------------------------------------------------------
|
|
this->set_item(inst.item());
|
|
this->set_itemZi(inst.itemZi());
|
|
//----------------------------------------------------------
|
|
this->set_teleId(inst.teleId());
|
|
this->set_teleIdZi(inst.teleIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_chinese(inst.chinese());
|
|
this->set_chineseZi(inst.chineseZi());
|
|
//----------------------------------------------------------
|
|
this->set_factor(inst.factor());
|
|
this->set_factorZi(inst.factorZi());
|
|
//----------------------------------------------------------
|
|
this->set_length(inst.length());
|
|
this->set_lengthZi(inst.lengthZi());
|
|
//----------------------------------------------------------
|
|
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_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_Print(inst.Print());
|
|
this->set_PrintZi(inst.PrintZi());
|
|
//----------------------------------------------------------
|
|
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_TELEITEM::majNo() const{
|
|
return((long)l_majNo );
|
|
}
|
|
|
|
|
|
void T_LOV_TELEITEM::set_majNo( long arg ){
|
|
l_majNo = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
long T_LOV_TELEITEM::minNo() const{
|
|
return((long)l_minNo );
|
|
}
|
|
|
|
|
|
void T_LOV_TELEITEM::set_minNo( long arg ){
|
|
l_minNo = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
long T_LOV_TELEITEM::eventno() const{
|
|
return((long)l_eventno );
|
|
}
|
|
|
|
|
|
void T_LOV_TELEITEM::set_eventno( long arg ){
|
|
l_eventno = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_LOV_TELEITEM::item() const{
|
|
return((char*)c_item );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::itemZi() const{
|
|
return( s_itemZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_itemZi( short arg ) {
|
|
s_itemZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::teleId() const{
|
|
return((char*)c_teleId );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::teleIdZi() const{
|
|
return( s_teleIdZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_teleIdZi( short arg ) {
|
|
s_teleIdZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::chinese() const{
|
|
return((char*)c_chinese );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::chineseZi() const{
|
|
return( s_chineseZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_chineseZi( short arg ) {
|
|
s_chineseZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::factor() const{
|
|
return((char*)c_factor );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::factorZi() const{
|
|
return( s_factorZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_factorZi( short arg ) {
|
|
s_factorZi = arg;
|
|
}
|
|
|
|
long T_LOV_TELEITEM::length() const{
|
|
return((long)l_length );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::lengthZi() const{
|
|
return( s_lengthZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_length( long arg ){
|
|
l_length = arg;
|
|
s_lengthZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_lengthZi( short arg ) {
|
|
s_lengthZi = arg;
|
|
}
|
|
|
|
long T_LOV_TELEITEM::repeat() const{
|
|
return((long)l_repeat );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::repeatZi() const{
|
|
return( s_repeatZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_repeat( long arg ){
|
|
l_repeat = arg;
|
|
s_repeatZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_repeatZi( short arg ) {
|
|
s_repeatZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::datatype() const{
|
|
return((char*)c_datatype );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::datatypeZi() const{
|
|
return( s_datatypeZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_datatypeZi( short arg ) {
|
|
s_datatypeZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::defaultValue() const{
|
|
return((char*)c_defaultValue );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::defaultValueZi() const{
|
|
return( s_defaultValueZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_defaultValueZi( short arg ) {
|
|
s_defaultValueZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::flag() const{
|
|
return((char*)c_flag );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::flagZi() const{
|
|
return( s_flagZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_flagZi( short arg ) {
|
|
s_flagZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Table1() const{
|
|
return((char*)c_Table1 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::Table1Zi() const{
|
|
return( s_Table1Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_Table1Zi( short arg ) {
|
|
s_Table1Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::column1() const{
|
|
return((char*)c_column1 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::column1Zi() const{
|
|
return( s_column1Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_column1Zi( short arg ) {
|
|
s_column1Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Table2() const{
|
|
return((char*)c_Table2 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::Table2Zi() const{
|
|
return( s_Table2Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_Table2Zi( short arg ) {
|
|
s_Table2Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::column2() const{
|
|
return((char*)c_column2 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::column2Zi() const{
|
|
return( s_column2Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_column2Zi( short arg ) {
|
|
s_column2Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Table3() const{
|
|
return((char*)c_Table3 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::Table3Zi() const{
|
|
return( s_Table3Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_Table3Zi( short arg ) {
|
|
s_Table3Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::column3() const{
|
|
return((char*)c_column3 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::column3Zi() const{
|
|
return( s_column3Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_column3Zi( short arg ) {
|
|
s_column3Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Table4() const{
|
|
return((char*)c_Table4 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::Table4Zi() const{
|
|
return( s_Table4Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_Table4Zi( short arg ) {
|
|
s_Table4Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::column4() const{
|
|
return((char*)c_column4 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::column4Zi() const{
|
|
return( s_column4Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_column4Zi( short arg ) {
|
|
s_column4Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Table5() const{
|
|
return((char*)c_Table5 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::Table5Zi() const{
|
|
return( s_Table5Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_Table5Zi( short arg ) {
|
|
s_Table5Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::column5() const{
|
|
return((char*)c_column5 );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::column5Zi() const{
|
|
return( s_column5Zi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_column5Zi( short arg ) {
|
|
s_column5Zi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::limitDB() const{
|
|
return((char*)c_limitDB );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::limitDBZi() const{
|
|
return( s_limitDBZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_limitDBZi( short arg ) {
|
|
s_limitDBZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::limitMin() const{
|
|
return((char*)c_limitMin );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::limitMinZi() const{
|
|
return( s_limitMinZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_limitMinZi( short arg ) {
|
|
s_limitMinZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::limitMax() const{
|
|
return((char*)c_limitMax );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::limitMaxZi() const{
|
|
return( s_limitMaxZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_limitMaxZi( short arg ) {
|
|
s_limitMaxZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::Print() const{
|
|
return((char*)c_Print );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::PrintZi() const{
|
|
return( s_PrintZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_Print( const char* arg ){
|
|
strncpy((char*)c_Print , arg , sizeof(c_Print));
|
|
c_Print[sizeof(c_Print)-1] = '\0';
|
|
s_PrintZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_PrintZi( short arg ) {
|
|
s_PrintZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_LOV_TELEITEM::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_LOV_TELEITEM::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_LOV_TELEITEM::k_majNo(){
|
|
return((long)l_k_majNo );
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_k_majNo( long arg ){
|
|
l_k_majNo = arg;
|
|
return;
|
|
}
|
|
|
|
long T_LOV_TELEITEM::k_minNo(){
|
|
return((long)l_k_minNo );
|
|
}
|
|
|
|
void T_LOV_TELEITEM::set_k_minNo( long arg ){
|
|
l_k_minNo = arg;
|
|
return;
|
|
}
|
|
|
|
long T_LOV_TELEITEM::k_eventno(){
|
|
return((long)l_k_eventno );
|
|
}
|
|
|
|
void T_LOV_TELEITEM::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_TELEITEM::fillStructure(){
|
|
structTable.majNo = majNo();
|
|
structTable.minNo = minNo();
|
|
structTable.eventno = eventno();
|
|
strncpy ( structTable.item , item(),sizeof(structTable.item));
|
|
strncpy ( structTable.teleId , teleId(),sizeof(structTable.teleId));
|
|
strncpy ( structTable.chinese , chinese(),sizeof(structTable.chinese));
|
|
strncpy ( structTable.factor , factor(),sizeof(structTable.factor));
|
|
structTable.length = length();
|
|
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.limitDB , limitDB(),sizeof(structTable.limitDB));
|
|
strncpy ( structTable.limitMin , limitMin(),sizeof(structTable.limitMin));
|
|
strncpy ( structTable.limitMax , limitMax(),sizeof(structTable.limitMax));
|
|
strncpy ( structTable.Print , Print(),sizeof(structTable.Print));
|
|
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_TELEITEM::fillStructureZi(){
|
|
structTableZi.itemZi = itemZi();
|
|
structTableZi.teleIdZi = teleIdZi();
|
|
structTableZi.chineseZi = chineseZi();
|
|
structTableZi.factorZi = factorZi();
|
|
structTableZi.lengthZi = lengthZi();
|
|
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.limitDBZi = limitDBZi();
|
|
structTableZi.limitMinZi = limitMinZi();
|
|
structTableZi.limitMaxZi = limitMaxZi();
|
|
structTableZi.PrintZi = PrintZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_TELEITEM::setStructure() {
|
|
set_item( structTable.item);
|
|
set_teleId( structTable.teleId);
|
|
set_chinese( structTable.chinese);
|
|
set_factor( structTable.factor);
|
|
set_length( structTable.length);
|
|
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_limitDB( structTable.limitDB);
|
|
set_limitMin( structTable.limitMin);
|
|
set_limitMax( structTable.limitMax);
|
|
set_Print( structTable.Print);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_LOV_TELEITEM::setStructureZi() {
|
|
set_itemZi( structTableZi.itemZi);
|
|
set_teleIdZi( structTableZi.teleIdZi);
|
|
set_chineseZi( structTableZi.chineseZi);
|
|
set_factorZi( structTableZi.factorZi);
|
|
set_lengthZi( structTableZi.lengthZi);
|
|
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_limitDBZi( structTableZi.limitDBZi);
|
|
set_limitMinZi( structTableZi.limitMinZi);
|
|
set_limitMaxZi( structTableZi.limitMaxZi);
|
|
set_PrintZi( structTableZi.PrintZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_LOV_TELEITEM::getName(){
|
|
return((char*)"T_LOV_TELEITEM");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_LOV_TELEITEM::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_LOV_TELEITEM::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|