// Version:		2014.10.20  14:41:0

#ifndef _T_TRK_COILPROC_H
#define _T_TRK_COILPROC_H
#include <common/BasicStruct.h>

using namespace baosight;

#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#ifdef _MSC_VER
#pragma warning(disable:4996)
#pragma warning(disable:4267)
#endif
#include "T_TRK_COILPROCDBAX.h"
class T_TRK_COILPROC{
friend class T_TRK_COILPROCDBAX;
private:
//aggregation to DB Class
T_TRK_COILPROCDBAX db;
public:
//
//A T T R I B U T E S
//===================
//
	bool dbAccess;
	char* dbMessage;// pointer for the return values of DBAX methodes
	char messageBuffer[200];// temporary message buffer
friend class PapLib;
protected:
//
//A T T R I B U T E S
//===================
//
char	c_cutTime[27];
short	s_cutTimeZi;
char	c_bookTime[27];
short	s_bookTimeZi;
char	c_EnCoilId[20+1];
short	s_EnCoilIdZi;
long	l_fasexitFlag;
short	s_fasexitFlagZi;
long	l_FinalFlag;
short	s_FinalFlagZi;
char	c_ProdStart[27];
short	s_ProdStartZi;
char	c_ProdEnd[27];
short	s_ProdEndZi;
double	d_EnHLen;
short	s_EnHLenZi;
double	d_EnTLen;
short	s_EnTLenZi;
double	d_ExHLen;
short	s_ExHLenZi;
double	d_ExTLen;
short	s_ExTLenZi;
double	d_CurLen;
short	s_CurLenZi;
double	d_CoilLen;
short	s_CoilLenZi;
long	l_EnHCutNo;
short	s_EnHCutNoZi;
long	l_ExHCutNo;
short	s_ExHCutNoZi;
long	l_EnTCutNo;
short	s_EnTCutNoZi;
long	l_ExTCutNo;
short	s_ExTCutNoZi;
long	l_muId;
char	c_muCreator[3];
short	s_musId;
char	c_toc[27];
short	s_tocZi;
char	c_tom[27];
short	s_tomZi;
char	c_mop[121];
short	s_mopZi;
char	c_mou[31];
short	s_mouZi;
// arguments for Primary key
long	l_k_muId;
char	c_k_muCreator[3];
short	s_k_musId;
public:
//
//	 LTA Structure
struct STR_T_TRK_COILPROC{
	char	cutTime[27];
	char	bookTime[27];
	char	EnCoilId[20+1];
	int	fasexitFlag;
	int	FinalFlag;
	char	ProdStart[27];
	char	ProdEnd[27];
	double	EnHLen;
	double	EnTLen;
	double	ExHLen;
	double	ExTLen;
	double	CurLen;
	double	CoilLen;
	int	EnHCutNo;
	int	ExHCutNo;
	int	EnTCutNo;
	int	ExTCutNo;
	int	muId;
	char	muCreator[3];
	short	musId;
	char	toc[27];
	char	tom[27];
	char	mop[121];
	char	mou[31];
}structTable;
//	 LTA Structure Zi
struct STR_T_TRK_COILPROCZi{
	short	cutTimeZi;
	short	bookTimeZi;
	short	EnCoilIdZi;
	short	fasexitFlagZi;
	short	FinalFlagZi;
	short	ProdStartZi;
	short	ProdEndZi;
	short	EnHLenZi;
	short	EnTLenZi;
	short	ExHLenZi;
	short	ExTLenZi;
	short	CurLenZi;
	short	CoilLenZi;
	short	EnHCutNoZi;
	short	ExHCutNoZi;
	short	EnTCutNoZi;
	short	ExTCutNoZi;
	short	tocZi;
	short	tomZi;
	short	mopZi;
	short	mouZi;
}structTableZi;
//
//C O N S T R U C T O R S
//=======================
//
public:
T_TRK_COILPROC();
//D E S T R U C T O R S
//=======================
//
virtual ~T_TRK_COILPROC();
//
//C O P Y  -  C O N S T R U C T O R 
//=======================
T_TRK_COILPROC(const T_TRK_COILPROC &inst);
// For Constructors with parameters the flag dbAccess
// informs you if the access was successfully or not
T_TRK_COILPROC( MU_CODE muCode );

//methods
public:
char* getCreationTime() {return "2014.10.20  14:41:0";};
//initial data
void  initial();
//read data
	char*  readDB();
//update data
	char*  updateDB();
//insert data
	char*  insertDB();
//this methode tries to update a DB record , when the update fails , the methode
//tries an insert of the failed record
	char*  storeDB();
//delete data
	char*  deleteDB();
//delete data
	char*  deleteDB(const char* where , long* count );
//openSetDB data
	char*  openSetDB(const char* where ,const char* order );
//getSetDB data
	char*  getSetDB();
//closeSetDB data
	char*  closeSetDB();
//countDB data
	char*  countDB(const char* where , long* count );

	char*  execute(const char* sql , long* count  );

	char*  dbCommit();

	char*  dbRollback();
public:
//
//	 public methode setPrimKey
//
//	this methode stores the unique key attributes
//
void setPrimKey(long arg1 , const char* arg2 , short arg3);

void setPrimKey( MU_CODE muCode );

//	 public methode initInsertKeys
//
//	this methode stores the unique key attributes
//
void initInsertKeys( long arg1 , const char* arg2 , short arg3 );

void initInsertKeys( MU_CODE muCode );

public:
//
//	 public methode setKeysFromRecord
//
//	this methode set the unique key attributes from the DB Record Attributes
//
void setKeysFromRecord();

//
//O P E R A T O R  + 
//===================
//
public:
T_TRK_COILPROC operator+(const T_TRK_COILPROC &inst) const;

//
//O P E R A T O R  = 
//===================
//
public:
const T_TRK_COILPROC& operator=(const T_TRK_COILPROC &inst);
char* cutTime() const;//{
	//return((char*)c_cutTime );
//}

short cutTimeZi() const;//{
	//return( s_cutTimeZi);
//}

void set_cutTime( char* arg );//{ 
	//strncpy((char*)c_cutTime , arg , sizeof(c_cutTime));
	//c_cutTime[sizeof(c_cutTime)-1] = '\0';
	//s_cutTimeZi=  0;
	//return;
//}

void set_cutTimeZi( short arg ) ;//{
	//s_cutTimeZi =  arg;
//}

char* bookTime() const;//{
	//return((char*)c_bookTime );
//}

short bookTimeZi() const;//{
	//return( s_bookTimeZi);
//}

void set_bookTime( char* arg );//{ 
	//strncpy((char*)c_bookTime , arg , sizeof(c_bookTime));
	//c_bookTime[sizeof(c_bookTime)-1] = '\0';
	//s_bookTimeZi=  0;
	//return;
//}

void set_bookTimeZi( short arg ) ;//{
	//s_bookTimeZi =  arg;
//}

char* EnCoilId() const;//{
	//return((char*)c_EnCoilId );
//}

short EnCoilIdZi() const;//{
	//return( s_EnCoilIdZi);
//}

void set_EnCoilId( const char* arg );//{ 
	//strncpy((char*)c_EnCoilId , arg , sizeof(c_EnCoilId));
	//c_EnCoilId[sizeof(c_EnCoilId)-1] = '\0';
	//s_EnCoilIdZi=  0;
	//return;
//}

void set_EnCoilIdZi( short arg ) ;//{
	//s_EnCoilIdZi =  arg;
//}

long fasexitFlag() const;//{
	//return((long)l_fasexitFlag );
//}

short fasexitFlagZi() const;//{
	//return( s_fasexitFlagZi);
//}

void set_fasexitFlag( long arg );//{ 
	//l_fasexitFlag = arg;
	//s_fasexitFlagZi=  0;
	//return;
//}

void set_fasexitFlagZi( short arg ) ;//{
	//s_fasexitFlagZi =  arg;
//}

long FinalFlag() const;//{
	//return((long)l_FinalFlag );
//}

short FinalFlagZi() const;//{
	//return( s_FinalFlagZi);
//}

void set_FinalFlag( long arg );//{ 
	//l_FinalFlag = arg;
	//s_FinalFlagZi=  0;
	//return;
//}

void set_FinalFlagZi( short arg ) ;//{
	//s_FinalFlagZi =  arg;
//}

char* ProdStart() const;//{
	//return((char*)c_ProdStart );
//}

short ProdStartZi() const;//{
	//return( s_ProdStartZi);
//}

void set_ProdStart( char* arg );//{ 
	//strncpy((char*)c_ProdStart , arg , sizeof(c_ProdStart));
	//c_ProdStart[sizeof(c_ProdStart)-1] = '\0';
	//s_ProdStartZi=  0;
	//return;
//}

void set_ProdStartZi( short arg ) ;//{
	//s_ProdStartZi =  arg;
//}

char* ProdEnd() const;//{
	//return((char*)c_ProdEnd );
//}

short ProdEndZi() const;//{
	//return( s_ProdEndZi);
//}

void set_ProdEnd( char* arg );//{ 
	//strncpy((char*)c_ProdEnd , arg , sizeof(c_ProdEnd));
	//c_ProdEnd[sizeof(c_ProdEnd)-1] = '\0';
	//s_ProdEndZi=  0;
	//return;
//}

void set_ProdEndZi( short arg ) ;//{
	//s_ProdEndZi =  arg;
//}

double EnHLen() const;//{
	//return((double)d_EnHLen );
//}

short EnHLenZi() const;//{
	//return( s_EnHLenZi);
//}

void set_EnHLen( double arg );//{ 
	//d_EnHLen = arg;
	//s_EnHLenZi=  0;
	//return;
//}

void set_EnHLenZi( short arg ) ;//{
	//s_EnHLenZi =  arg;
//}

double EnTLen() const;//{
	//return((double)d_EnTLen );
//}

short EnTLenZi() const;//{
	//return( s_EnTLenZi);
//}

void set_EnTLen( double arg );//{ 
	//d_EnTLen = arg;
	//s_EnTLenZi=  0;
	//return;
//}

void set_EnTLenZi( short arg ) ;//{
	//s_EnTLenZi =  arg;
//}

double ExHLen() const;//{
	//return((double)d_ExHLen );
//}

short ExHLenZi() const;//{
	//return( s_ExHLenZi);
//}

void set_ExHLen( double arg );//{ 
	//d_ExHLen = arg;
	//s_ExHLenZi=  0;
	//return;
//}

void set_ExHLenZi( short arg ) ;//{
	//s_ExHLenZi =  arg;
//}

double ExTLen() const;//{
	//return((double)d_ExTLen );
//}

short ExTLenZi() const;//{
	//return( s_ExTLenZi);
//}

void set_ExTLen( double arg );//{ 
	//d_ExTLen = arg;
	//s_ExTLenZi=  0;
	//return;
//}

void set_ExTLenZi( short arg ) ;//{
	//s_ExTLenZi =  arg;
//}

double CurLen() const;//{
	//return((double)d_CurLen );
//}

short CurLenZi() const;//{
	//return( s_CurLenZi);
//}

void set_CurLen( double arg );//{ 
	//d_CurLen = arg;
	//s_CurLenZi=  0;
	//return;
//}

void set_CurLenZi( short arg ) ;//{
	//s_CurLenZi =  arg;
//}

double CoilLen() const;//{
	//return((double)d_CoilLen );
//}

short CoilLenZi() const;//{
	//return( s_CoilLenZi);
//}

void set_CoilLen( double arg );//{ 
	//d_CoilLen = arg;
	//s_CoilLenZi=  0;
	//return;
//}

void set_CoilLenZi( short arg ) ;//{
	//s_CoilLenZi =  arg;
//}

long EnHCutNo() const;//{
	//return((long)l_EnHCutNo );
//}

short EnHCutNoZi() const;//{
	//return( s_EnHCutNoZi);
//}

void set_EnHCutNo( long arg );//{ 
	//l_EnHCutNo = arg;
	//s_EnHCutNoZi=  0;
	//return;
//}

void set_EnHCutNoZi( short arg ) ;//{
	//s_EnHCutNoZi =  arg;
//}

long ExHCutNo() const;//{
	//return((long)l_ExHCutNo );
//}

short ExHCutNoZi() const;//{
	//return( s_ExHCutNoZi);
//}

void set_ExHCutNo( long arg );//{ 
	//l_ExHCutNo = arg;
	//s_ExHCutNoZi=  0;
	//return;
//}

void set_ExHCutNoZi( short arg ) ;//{
	//s_ExHCutNoZi =  arg;
//}

long EnTCutNo() const;//{
	//return((long)l_EnTCutNo );
//}

short EnTCutNoZi() const;//{
	//return( s_EnTCutNoZi);
//}

void set_EnTCutNo( long arg );//{ 
	//l_EnTCutNo = arg;
	//s_EnTCutNoZi=  0;
	//return;
//}

void set_EnTCutNoZi( short arg ) ;//{
	//s_EnTCutNoZi =  arg;
//}

long ExTCutNo() const;//{
	//return((long)l_ExTCutNo );
//}

short ExTCutNoZi() const;//{
	//return( s_ExTCutNoZi);
//}

void set_ExTCutNo( long arg );//{ 
	//l_ExTCutNo = arg;
	//s_ExTCutNoZi=  0;
	//return;
//}

void set_ExTCutNoZi( short arg ) ;//{
	//s_ExTCutNoZi =  arg;
//}

long	muId() const;//{
	//return((long)l_muId );
//}

void	set_muId( long arg );//{
	//l_muId =  arg;
	//return;
//}

char*	muCreator() const;//{
	//return((char*)c_muCreator );
//}

void	set_muCreator( const char* arg );//{
	//strncpy((char*)c_muCreator , arg , sizeof(c_muCreator));
	//c_muCreator[sizeof(c_muCreator)-1] = '\0';
	//return;
//}

short	musId() const;//{
	//return((short)s_musId );
//}

void	set_musId( short arg );//{
	//s_musId =  arg;
	//return;
//}

public:
char* toc() const;//{
	//return((char*)c_toc );
//}

short tocZi() const;//{
	//return( s_tocZi);
//}

protected:
void set_toc( char* arg );//{
	//strncpy((char*)c_toc , arg , sizeof(c_toc));
	//c_toc[sizeof(c_toc)-1] = '\0';
	//s_tocZi=  0;
	//return;
//}

void set_tocZi( short arg );//{
	//s_tocZi =  arg;
//}

public:
char* tom() const;//{
	//return((char*)c_tom );
//}

short tomZi() const;//{
	//return( s_tomZi);
//}

protected:
void set_tom( char* arg );//{
	//strncpy((char*)c_tom , arg , sizeof(c_tom));
	//c_tom[sizeof(c_tom)-1] = '\0';
	//s_tomZi=  0;
	//return;
//}

void set_tomZi( short arg );//{
	//s_tomZi =  arg;
//}

public:
char* mop() const;//{
	//return((char*)c_mop );
//}

short mopZi() const;//{
	//return( s_mopZi);
//}

protected:
void set_mop( char* arg );//{
	//strncpy((char*)c_mop , arg , sizeof(c_mop));
	//c_mop[sizeof(c_mop)-1] = '\0';
	//s_mopZi=  0;
	//return;
//}

void set_mopZi( short arg );//{
	//s_mopZi =  arg;
//}

public:
char* mou() const;//{
	//return((char*)c_mou );
//}

short mouZi() const;//{
	//return( s_mouZi);
//}

protected:
void set_mou( char* arg );//{
	//strncpy((char*)c_mou , arg , sizeof(c_mou));
	//c_mou[sizeof(c_mou)-1] = '\0';
	//s_mouZi=  0;
	//return;
//}

void set_mouZi( short arg );//{
	//s_mouZi =  arg;
//}

public:
// methodes for Primary key
long k_muId();//{
	//return((long)l_k_muId );
//}

void set_k_muId( long arg );//{
	//l_k_muId =  arg;
	//return;
//}

char* k_muCreator();//{
	//return((char*)c_k_muCreator );
//}

void 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 k_musId();//{
	//return((short)s_k_musId );
//}

void set_k_musId( short arg );//{
	//s_k_musId =  arg;
	//return;
//}

public:
//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void fillStructure();//{
//}
///////////////////////////////////////////////////
void fillStructureZi();//{
//}
///////////////////////////////////////////////////
void setStructure();// {
	//return;
//}
///////////////////////////////////////////////////
void setStructureZi() ;//{
//}
///////////////////////////////////////////////////
char* getName();//{
	//return("T_TRK_COILPROC");
//}
///////////////////////////////////////////////////
int getSqlCode();//{
	//return( db.dbSqlCode);
//}
///////////////////////////////////////////////////
int getRowsProcessed();//{
	//return( db.dbRowsProcessed);
//}
};
#endif