869 lines
23 KiB
C++
869 lines
23 KiB
C++
// Version: 2014.7.30 16:47:28
|
|
|
|
// File: T_DEF_LINE.cpp
|
|
|
|
#include "T_DEF_LINE.h"
|
|
|
|
T_DEF_LINE::T_DEF_LINE(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_DEF_LINE::~T_DEF_LINE(){
|
|
}
|
|
void T_DEF_LINE::initial(){
|
|
// initialise all membervariables
|
|
set_SID(0);
|
|
set_defEnd(0);
|
|
set_defEndZi(-1);
|
|
set_defType("");
|
|
set_defTypeZi(-1);
|
|
set_defSide("");
|
|
set_defSideZi(-1);
|
|
set_lengthPos("");
|
|
set_lengthPosZi(-1);
|
|
set_inputUnit("");
|
|
set_inputUnitZi(-1);
|
|
set_controlType("");
|
|
set_controlTypeZi(-1);
|
|
set_defectText("");
|
|
set_defectTextZi(-1);
|
|
set_defClass("");
|
|
set_defClassZi(-1);
|
|
set_defLateralDis(0);
|
|
set_defLateralDisZi(-1);
|
|
set_defWidthPos("");
|
|
set_defWidthPosZi(-1);
|
|
set_defCreator("");
|
|
set_defCreatorZi(-1);
|
|
set_defStart(0);
|
|
set_defStartZi(-1);
|
|
set_muId(0);
|
|
set_muCreator("");
|
|
set_musId(0);
|
|
set_toc("");
|
|
set_tocZi(-1);
|
|
set_tom("");
|
|
set_tomZi(-1);
|
|
set_mop("");
|
|
set_mopZi(-1);
|
|
set_mou("");
|
|
set_mouZi(-1);
|
|
// initialies Primary key members
|
|
set_k_muId(0);
|
|
set_k_muCreator("");
|
|
set_k_musId(0);
|
|
set_k_SID(0);
|
|
}
|
|
T_DEF_LINE::T_DEF_LINE(MU_CODE muCode , long arg1)
|
|
{
|
|
initial();
|
|
setPrimKey (muCode , arg1);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_DEF_LINE:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_DEF_LINE:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_DEF_LINE:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_DEF_LINE::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_DEF_LINE::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_DEF_LINE::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_DEF_LINE::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_DEF_LINE::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_DEF_LINE::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_DEF_LINE::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_DEF_LINE::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_DEF_LINE::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_DEF_LINE::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_DEF_LINE
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_DEF_LINE::setPrimKey( long arg1 , const char* arg2 , short arg3 , long arg4 ){
|
|
l_k_muId = arg1;
|
|
strncpy( (char*)c_k_muCreator , arg2 , sizeof(c_k_muCreator) );
|
|
c_k_muCreator[sizeof(c_k_muCreator)-1] = '\0';
|
|
s_k_musId = arg3;
|
|
l_k_SID = arg4;
|
|
} // end of methode
|
|
void T_DEF_LINE::setPrimKey( MU_CODE muCode , long arg1 ){
|
|
setPrimKey ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId , arg1);
|
|
} // end of methode
|
|
|
|
void T_DEF_LINE::initInsertKeys( long arg1 , const char* arg2 , short arg3 , long arg4 ){
|
|
setPrimKey ( arg1 , arg2 , arg3 , arg4);
|
|
l_muId = arg1;
|
|
strncpy( (char*)c_muCreator , arg2 , sizeof(c_muCreator) );
|
|
c_muCreator[sizeof(c_muCreator)-1] = '\0';
|
|
s_musId = arg3;
|
|
l_SID = arg4;
|
|
} // end of methode
|
|
void T_DEF_LINE::initInsertKeys( MU_CODE muCode , long arg1 ){
|
|
initInsertKeys ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId , arg1);
|
|
} // end of methode
|
|
void T_DEF_LINE::setKeysFromRecord(){
|
|
set_k_muId( muId() );
|
|
set_k_muCreator( muCreator() );
|
|
set_k_musId( musId() );
|
|
set_k_SID( SID() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_DEF_LINE T_DEF_LINE::operator+(const T_DEF_LINE &inst) const{
|
|
T_DEF_LINE ptrT_DEF_LINE(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_DEF_LINE.set_SID(inst.SID());
|
|
//----------------------------------------------------------
|
|
if(inst.defEndZi() != -1){
|
|
ptrT_DEF_LINE.set_defEnd(inst.defEnd());
|
|
ptrT_DEF_LINE.set_defEndZi(inst.defEndZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defTypeZi() != -1){
|
|
ptrT_DEF_LINE.set_defType(inst.defType());
|
|
ptrT_DEF_LINE.set_defTypeZi(inst.defTypeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defSideZi() != -1){
|
|
ptrT_DEF_LINE.set_defSide(inst.defSide());
|
|
ptrT_DEF_LINE.set_defSideZi(inst.defSideZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.lengthPosZi() != -1){
|
|
ptrT_DEF_LINE.set_lengthPos(inst.lengthPos());
|
|
ptrT_DEF_LINE.set_lengthPosZi(inst.lengthPosZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.inputUnitZi() != -1){
|
|
ptrT_DEF_LINE.set_inputUnit(inst.inputUnit());
|
|
ptrT_DEF_LINE.set_inputUnitZi(inst.inputUnitZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.controlTypeZi() != -1){
|
|
ptrT_DEF_LINE.set_controlType(inst.controlType());
|
|
ptrT_DEF_LINE.set_controlTypeZi(inst.controlTypeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defectTextZi() != -1){
|
|
ptrT_DEF_LINE.set_defectText(inst.defectText());
|
|
ptrT_DEF_LINE.set_defectTextZi(inst.defectTextZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defClassZi() != -1){
|
|
ptrT_DEF_LINE.set_defClass(inst.defClass());
|
|
ptrT_DEF_LINE.set_defClassZi(inst.defClassZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defLateralDisZi() != -1){
|
|
ptrT_DEF_LINE.set_defLateralDis(inst.defLateralDis());
|
|
ptrT_DEF_LINE.set_defLateralDisZi(inst.defLateralDisZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defWidthPosZi() != -1){
|
|
ptrT_DEF_LINE.set_defWidthPos(inst.defWidthPos());
|
|
ptrT_DEF_LINE.set_defWidthPosZi(inst.defWidthPosZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defCreatorZi() != -1){
|
|
ptrT_DEF_LINE.set_defCreator(inst.defCreator());
|
|
ptrT_DEF_LINE.set_defCreatorZi(inst.defCreatorZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.defStartZi() != -1){
|
|
ptrT_DEF_LINE.set_defStart(inst.defStart());
|
|
ptrT_DEF_LINE.set_defStartZi(inst.defStartZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
ptrT_DEF_LINE.set_muId(inst.muId());
|
|
//----------------------------------------------------------
|
|
ptrT_DEF_LINE.set_muCreator(inst.muCreator());
|
|
//----------------------------------------------------------
|
|
ptrT_DEF_LINE.set_musId(inst.musId());
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_DEF_LINE.set_toc(inst.toc());
|
|
ptrT_DEF_LINE.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_DEF_LINE.set_tom(inst.tom());
|
|
ptrT_DEF_LINE.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_DEF_LINE.set_mop(inst.mop());
|
|
ptrT_DEF_LINE.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_DEF_LINE.set_mou(inst.mou());
|
|
ptrT_DEF_LINE.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_DEF_LINE);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_DEF_LINE& T_DEF_LINE::operator=(const T_DEF_LINE &inst){
|
|
//----------------------------------------------------------
|
|
this->set_SID(inst.SID());
|
|
//----------------------------------------------------------
|
|
this->set_defEnd(inst.defEnd());
|
|
this->set_defEndZi(inst.defEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_defType(inst.defType());
|
|
this->set_defTypeZi(inst.defTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defSide(inst.defSide());
|
|
this->set_defSideZi(inst.defSideZi());
|
|
//----------------------------------------------------------
|
|
this->set_lengthPos(inst.lengthPos());
|
|
this->set_lengthPosZi(inst.lengthPosZi());
|
|
//----------------------------------------------------------
|
|
this->set_inputUnit(inst.inputUnit());
|
|
this->set_inputUnitZi(inst.inputUnitZi());
|
|
//----------------------------------------------------------
|
|
this->set_controlType(inst.controlType());
|
|
this->set_controlTypeZi(inst.controlTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defectText(inst.defectText());
|
|
this->set_defectTextZi(inst.defectTextZi());
|
|
//----------------------------------------------------------
|
|
this->set_defClass(inst.defClass());
|
|
this->set_defClassZi(inst.defClassZi());
|
|
//----------------------------------------------------------
|
|
this->set_defLateralDis(inst.defLateralDis());
|
|
this->set_defLateralDisZi(inst.defLateralDisZi());
|
|
//----------------------------------------------------------
|
|
this->set_defWidthPos(inst.defWidthPos());
|
|
this->set_defWidthPosZi(inst.defWidthPosZi());
|
|
//----------------------------------------------------------
|
|
this->set_defCreator(inst.defCreator());
|
|
this->set_defCreatorZi(inst.defCreatorZi());
|
|
//----------------------------------------------------------
|
|
this->set_defStart(inst.defStart());
|
|
this->set_defStartZi(inst.defStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_muId(inst.muId());
|
|
//----------------------------------------------------------
|
|
this->set_muCreator(inst.muCreator());
|
|
//----------------------------------------------------------
|
|
this->set_musId(inst.musId());
|
|
//----------------------------------------------------------
|
|
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_DEF_LINE::T_DEF_LINE(const T_DEF_LINE &inst){
|
|
//----------------------------------------------------------
|
|
this->set_SID(inst.SID());
|
|
//----------------------------------------------------------
|
|
this->set_defEnd(inst.defEnd());
|
|
this->set_defEndZi(inst.defEndZi());
|
|
//----------------------------------------------------------
|
|
this->set_defType(inst.defType());
|
|
this->set_defTypeZi(inst.defTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defSide(inst.defSide());
|
|
this->set_defSideZi(inst.defSideZi());
|
|
//----------------------------------------------------------
|
|
this->set_lengthPos(inst.lengthPos());
|
|
this->set_lengthPosZi(inst.lengthPosZi());
|
|
//----------------------------------------------------------
|
|
this->set_inputUnit(inst.inputUnit());
|
|
this->set_inputUnitZi(inst.inputUnitZi());
|
|
//----------------------------------------------------------
|
|
this->set_controlType(inst.controlType());
|
|
this->set_controlTypeZi(inst.controlTypeZi());
|
|
//----------------------------------------------------------
|
|
this->set_defectText(inst.defectText());
|
|
this->set_defectTextZi(inst.defectTextZi());
|
|
//----------------------------------------------------------
|
|
this->set_defClass(inst.defClass());
|
|
this->set_defClassZi(inst.defClassZi());
|
|
//----------------------------------------------------------
|
|
this->set_defLateralDis(inst.defLateralDis());
|
|
this->set_defLateralDisZi(inst.defLateralDisZi());
|
|
//----------------------------------------------------------
|
|
this->set_defWidthPos(inst.defWidthPos());
|
|
this->set_defWidthPosZi(inst.defWidthPosZi());
|
|
//----------------------------------------------------------
|
|
this->set_defCreator(inst.defCreator());
|
|
this->set_defCreatorZi(inst.defCreatorZi());
|
|
//----------------------------------------------------------
|
|
this->set_defStart(inst.defStart());
|
|
this->set_defStartZi(inst.defStartZi());
|
|
//----------------------------------------------------------
|
|
this->set_muId(inst.muId());
|
|
//----------------------------------------------------------
|
|
this->set_muCreator(inst.muCreator());
|
|
//----------------------------------------------------------
|
|
this->set_musId(inst.musId());
|
|
//----------------------------------------------------------
|
|
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_DEF_LINE::SID() const{
|
|
return((long)l_SID );
|
|
}
|
|
|
|
|
|
void T_DEF_LINE::set_SID( long arg ){
|
|
l_SID = arg;
|
|
return;
|
|
}
|
|
|
|
|
|
long T_DEF_LINE::defEnd() const{
|
|
return((long)l_defEnd );
|
|
}
|
|
|
|
short T_DEF_LINE::defEndZi() const{
|
|
return( s_defEndZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defEnd( long arg ){
|
|
l_defEnd = arg;
|
|
s_defEndZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defEndZi( short arg ) {
|
|
s_defEndZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defType() const{
|
|
return((char*)c_defType );
|
|
}
|
|
|
|
short T_DEF_LINE::defTypeZi() const{
|
|
return( s_defTypeZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defType( const char* arg ){
|
|
strncpy((char*)c_defType , arg , sizeof(c_defType));
|
|
c_defType[sizeof(c_defType)-1] = '\0';
|
|
s_defTypeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defTypeZi( short arg ) {
|
|
s_defTypeZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defSide() const{
|
|
return((char*)c_defSide );
|
|
}
|
|
|
|
short T_DEF_LINE::defSideZi() const{
|
|
return( s_defSideZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defSide( const char* arg ){
|
|
strncpy((char*)c_defSide , arg , sizeof(c_defSide));
|
|
c_defSide[sizeof(c_defSide)-1] = '\0';
|
|
s_defSideZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defSideZi( short arg ) {
|
|
s_defSideZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::lengthPos() const{
|
|
return((char*)c_lengthPos );
|
|
}
|
|
|
|
short T_DEF_LINE::lengthPosZi() const{
|
|
return( s_lengthPosZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_lengthPos( const char* arg ){
|
|
strncpy((char*)c_lengthPos , arg , sizeof(c_lengthPos));
|
|
c_lengthPos[sizeof(c_lengthPos)-1] = '\0';
|
|
s_lengthPosZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_lengthPosZi( short arg ) {
|
|
s_lengthPosZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::inputUnit() const{
|
|
return((char*)c_inputUnit );
|
|
}
|
|
|
|
short T_DEF_LINE::inputUnitZi() const{
|
|
return( s_inputUnitZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_inputUnit( const char* arg ){
|
|
strncpy((char*)c_inputUnit , arg , sizeof(c_inputUnit));
|
|
c_inputUnit[sizeof(c_inputUnit)-1] = '\0';
|
|
s_inputUnitZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_inputUnitZi( short arg ) {
|
|
s_inputUnitZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::controlType() const{
|
|
return((char*)c_controlType );
|
|
}
|
|
|
|
short T_DEF_LINE::controlTypeZi() const{
|
|
return( s_controlTypeZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_controlType( const char* arg ){
|
|
strncpy((char*)c_controlType , arg , sizeof(c_controlType));
|
|
c_controlType[sizeof(c_controlType)-1] = '\0';
|
|
s_controlTypeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_controlTypeZi( short arg ) {
|
|
s_controlTypeZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defectText() const{
|
|
return((char*)c_defectText );
|
|
}
|
|
|
|
short T_DEF_LINE::defectTextZi() const{
|
|
return( s_defectTextZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defectText( const char* arg ){
|
|
strncpy((char*)c_defectText , arg , sizeof(c_defectText));
|
|
c_defectText[sizeof(c_defectText)-1] = '\0';
|
|
s_defectTextZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defectTextZi( short arg ) {
|
|
s_defectTextZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defClass() const{
|
|
return((char*)c_defClass );
|
|
}
|
|
|
|
short T_DEF_LINE::defClassZi() const{
|
|
return( s_defClassZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defClass( const char* arg ){
|
|
strncpy((char*)c_defClass , arg , sizeof(c_defClass));
|
|
c_defClass[sizeof(c_defClass)-1] = '\0';
|
|
s_defClassZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defClassZi( short arg ) {
|
|
s_defClassZi = arg;
|
|
}
|
|
|
|
long T_DEF_LINE::defLateralDis() const{
|
|
return((long)l_defLateralDis );
|
|
}
|
|
|
|
short T_DEF_LINE::defLateralDisZi() const{
|
|
return( s_defLateralDisZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defLateralDis( long arg ){
|
|
l_defLateralDis = arg;
|
|
s_defLateralDisZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defLateralDisZi( short arg ) {
|
|
s_defLateralDisZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defWidthPos() const{
|
|
return((char*)c_defWidthPos );
|
|
}
|
|
|
|
short T_DEF_LINE::defWidthPosZi() const{
|
|
return( s_defWidthPosZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defWidthPos( const char* arg ){
|
|
strncpy((char*)c_defWidthPos , arg , sizeof(c_defWidthPos));
|
|
c_defWidthPos[sizeof(c_defWidthPos)-1] = '\0';
|
|
s_defWidthPosZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defWidthPosZi( short arg ) {
|
|
s_defWidthPosZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::defCreator() const{
|
|
return((char*)c_defCreator );
|
|
}
|
|
|
|
short T_DEF_LINE::defCreatorZi() const{
|
|
return( s_defCreatorZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defCreator( const char* arg ){
|
|
strncpy((char*)c_defCreator , arg , sizeof(c_defCreator));
|
|
c_defCreator[sizeof(c_defCreator)-1] = '\0';
|
|
s_defCreatorZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defCreatorZi( short arg ) {
|
|
s_defCreatorZi = arg;
|
|
}
|
|
|
|
long T_DEF_LINE::defStart() const{
|
|
return((long)l_defStart );
|
|
}
|
|
|
|
short T_DEF_LINE::defStartZi() const{
|
|
return( s_defStartZi);
|
|
}
|
|
|
|
void T_DEF_LINE::set_defStart( long arg ){
|
|
l_defStart = arg;
|
|
s_defStartZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_DEF_LINE::set_defStartZi( short arg ) {
|
|
s_defStartZi = arg;
|
|
}
|
|
|
|
long T_DEF_LINE::muId() const{
|
|
return((long)l_muId );
|
|
}
|
|
|
|
void T_DEF_LINE::set_muId( long arg ){
|
|
l_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_DEF_LINE::muCreator() const{
|
|
return((char*)c_muCreator );
|
|
}
|
|
|
|
void T_DEF_LINE::set_muCreator( const char* arg ){
|
|
strncpy((char*)c_muCreator , arg , sizeof(c_muCreator));
|
|
c_muCreator[sizeof(c_muCreator)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
short T_DEF_LINE::musId() const{
|
|
return((short)s_musId );
|
|
}
|
|
|
|
void T_DEF_LINE::set_musId( short arg ){
|
|
s_musId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_DEF_LINE::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_DEF_LINE::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_DEF_LINE::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_DEF_LINE::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_DEF_LINE::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_DEF_LINE::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_DEF_LINE::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_DEF_LINE::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_DEF_LINE::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_DEF_LINE::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_DEF_LINE::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_DEF_LINE::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_DEF_LINE::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_DEF_LINE::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_DEF_LINE::k_muId(){
|
|
return((long)l_k_muId );
|
|
}
|
|
|
|
void T_DEF_LINE::set_k_muId( long arg ){
|
|
l_k_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_DEF_LINE::k_muCreator(){
|
|
return((char*)c_k_muCreator );
|
|
}
|
|
|
|
void T_DEF_LINE::set_k_muCreator( char* arg ){
|
|
strncpy((char*)c_k_muCreator , arg , sizeof(c_k_muCreator));
|
|
c_k_muCreator[sizeof(c_k_muCreator)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
short T_DEF_LINE::k_musId(){
|
|
return((short)s_k_musId );
|
|
}
|
|
|
|
void T_DEF_LINE::set_k_musId( short arg ){
|
|
s_k_musId = arg;
|
|
return;
|
|
}
|
|
|
|
long T_DEF_LINE::k_SID(){
|
|
return((long)l_k_SID );
|
|
}
|
|
|
|
void T_DEF_LINE::set_k_SID( long arg ){
|
|
l_k_SID = arg;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_DEF_LINE::fillStructure(){
|
|
structTable.SID = SID();
|
|
structTable.defEnd = defEnd();
|
|
strncpy ( structTable.defType , defType(),sizeof(structTable.defType));
|
|
strncpy ( structTable.defSide , defSide(),sizeof(structTable.defSide));
|
|
strncpy ( structTable.lengthPos , lengthPos(),sizeof(structTable.lengthPos));
|
|
strncpy ( structTable.inputUnit , inputUnit(),sizeof(structTable.inputUnit));
|
|
strncpy ( structTable.controlType , controlType(),sizeof(structTable.controlType));
|
|
strncpy ( structTable.defectText , defectText(),sizeof(structTable.defectText));
|
|
strncpy ( structTable.defClass , defClass(),sizeof(structTable.defClass));
|
|
structTable.defLateralDis = defLateralDis();
|
|
strncpy ( structTable.defWidthPos , defWidthPos(),sizeof(structTable.defWidthPos));
|
|
strncpy ( structTable.defCreator , defCreator(),sizeof(structTable.defCreator));
|
|
structTable.defStart = defStart();
|
|
structTable.muId = muId();
|
|
strncpy ( structTable.muCreator , muCreator(),sizeof(structTable.muCreator));
|
|
structTable.musId = musId();
|
|
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_DEF_LINE::fillStructureZi(){
|
|
structTableZi.defEndZi = defEndZi();
|
|
structTableZi.defTypeZi = defTypeZi();
|
|
structTableZi.defSideZi = defSideZi();
|
|
structTableZi.lengthPosZi = lengthPosZi();
|
|
structTableZi.inputUnitZi = inputUnitZi();
|
|
structTableZi.controlTypeZi = controlTypeZi();
|
|
structTableZi.defectTextZi = defectTextZi();
|
|
structTableZi.defClassZi = defClassZi();
|
|
structTableZi.defLateralDisZi = defLateralDisZi();
|
|
structTableZi.defWidthPosZi = defWidthPosZi();
|
|
structTableZi.defCreatorZi = defCreatorZi();
|
|
structTableZi.defStartZi = defStartZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_DEF_LINE::setStructure() {
|
|
set_defEnd( structTable.defEnd);
|
|
set_defType( structTable.defType);
|
|
set_defSide( structTable.defSide);
|
|
set_lengthPos( structTable.lengthPos);
|
|
set_inputUnit( structTable.inputUnit);
|
|
set_controlType( structTable.controlType);
|
|
set_defectText( structTable.defectText);
|
|
set_defClass( structTable.defClass);
|
|
set_defLateralDis( structTable.defLateralDis);
|
|
set_defWidthPos( structTable.defWidthPos);
|
|
set_defCreator( structTable.defCreator);
|
|
set_defStart( structTable.defStart);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_DEF_LINE::setStructureZi() {
|
|
set_defEndZi( structTableZi.defEndZi);
|
|
set_defTypeZi( structTableZi.defTypeZi);
|
|
set_defSideZi( structTableZi.defSideZi);
|
|
set_lengthPosZi( structTableZi.lengthPosZi);
|
|
set_inputUnitZi( structTableZi.inputUnitZi);
|
|
set_controlTypeZi( structTableZi.controlTypeZi);
|
|
set_defectTextZi( structTableZi.defectTextZi);
|
|
set_defClassZi( structTableZi.defClassZi);
|
|
set_defLateralDisZi( structTableZi.defLateralDisZi);
|
|
set_defWidthPosZi( structTableZi.defWidthPosZi);
|
|
set_defCreatorZi( structTableZi.defCreatorZi);
|
|
set_defStartZi( structTableZi.defStartZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_DEF_LINE::getName(){
|
|
return("T_DEF_LINE");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_DEF_LINE::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_DEF_LINE::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|