// 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);
}