// Version:		2014.12.2  13:0:0

#ifndef _T_ROL_HISTORY_H
#define _T_ROL_HISTORY_H
#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#ifdef _MSC_VER
#pragma warning(disable:4996)
#pragma warning(disable:4267)
#endif
#include "T_ROL_HISTORYDBAX.h"
class T_ROL_HISTORY{
friend class T_ROL_HISTORYDBAX;
private:
//aggregation to DB Class
T_ROL_HISTORYDBAX 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
//===================
//
long	l_Seq;
char	c_RollNo[10+1];
long	l_StandNo;
short	s_StandNoZi;
char	c_RollType[1+1];
char	c_RollPosition[1+1];
short	s_RollPositionZi;
char	c_RollStatus[1+1];
short	s_RollStatusZi;
double	d_DiameterMiddle;
short	s_DiameterMiddleZi;
double	d_RollCrown;
short	s_RollCrownZi;
long	l_RollGroupNo;
short	s_RollGroupNoZi;
char	c_RollAssemblyNo[6+1];
short	s_RollAssemblyNoZi;
char	c_RollMaterial[2+1];
short	s_RollMaterialZi;
char	c_RollSteelGrade[8+1];
short	s_RollSteelGradeZi;
double	d_DiameterHead;
short	s_DiameterHeadZi;
double	d_DiameterTail;
short	s_DiameterTailZi;
long	l_PositionHead;
short	s_PositionHeadZi;
long	l_PositionMiddle;
short	s_PositionMiddleZi;
long	l_PositionTail;
short	s_PositionTailZi;
long	l_CrownSigh;
short	s_CrownSighZi;
double	d_RollRough;
short	s_RollRoughZi;
char	c_RollRoughMethod[1+1];
short	s_RollRoughMethodZi;
char	c_RollSurfaceMethod[1+1];
short	s_RollSurfaceMethodZi;
char	c_ChockOperate[9+1];
short	s_ChockOperateZi;
char	c_ChockDrive[9+1];
short	s_ChockDriveZi;
double	d_DiameterTaperStart;
short	s_DiameterTaperStartZi;
double	d_DiameterTaperEnd;
short	s_DiameterTaperEndZi;
double	d_TaperLength;
short	s_TaperLengthZi;
char	c_RollMaterialClass[1+1];
short	s_RollMaterialClassZi;
char	c_RollEllipse[5+1];
short	s_RollEllipseZi;
char	c_RollCrownCoeff1[5+1];
short	s_RollCrownCoeff1Zi;
char	c_RollCrownCoeff2[5+1];
short	s_RollCrownCoeff2Zi;
char	c_RollCrownCoeff3[5+1];
short	s_RollCrownCoeff3Zi;
char	c_RollCrownCoeff4[5+1];
short	s_RollCrownCoeff4Zi;
char	c_RollCrownCoeff5[5+1];
short	s_RollCrownCoeff5Zi;
char	c_RollShapeCode[2+1];
short	s_RollShapeCodeZi;
char	c_OperatorSideChockNo[4+1];
short	s_OperatorSideChockNoZi;
char	c_DriveSideChockNo[4+1];
short	s_DriveSideChockNoZi;
char	c_MountTime[27];
short	s_MountTimeZi;
char	c_MountShiftNo[1+1];
short	s_MountShiftNoZi;
char	c_MountGroupNo[1+1];
short	s_MountGroupNoZi;
char	c_UnMountTime[27];
short	s_UnMountTimeZi;
char	c_UnMountShiftNo[1+1];
short	s_UnMountShiftNoZi;
char	c_UnMountGroupNo[1+1];
short	s_UnMountGroupNoZi;
long	l_RunTime;
short	s_RunTimeZi;
long	l_RolledTime;
short	s_RolledTimeZi;
long	l_RolledWeight;
short	s_RolledWeightZi;
long	l_RolledLength;
short	s_RolledLengthZi;
char	c_RemoveReason[4+1];
short	s_RemoveReasonZi;
char	c_Remark[10+1];
short	s_RemarkZi;
char	c_extId[20+1];
short	s_extIdZi;
char	c_MatchRollNo[15+1];
short	s_MatchRollNoZi;
char	c_Ok[1+1];
short	s_OkZi;
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_Seq;
public:
//
//	 LTA Structure
struct STR_T_ROL_HISTORY{
	int	Seq;
	char	RollNo[10+1];
	int	StandNo;
	char	RollType[1+1];
	char	RollPosition[1+1];
	char	RollStatus[1+1];
	double	DiameterMiddle;
	double	RollCrown;
	int	RollGroupNo;
	char	RollAssemblyNo[6+1];
	char	RollMaterial[2+1];
	char	RollSteelGrade[8+1];
	double	DiameterHead;
	double	DiameterTail;
	int	PositionHead;
	int	PositionMiddle;
	int	PositionTail;
	int	CrownSigh;
	double	RollRough;
	char	RollRoughMethod[1+1];
	char	RollSurfaceMethod[1+1];
	char	ChockOperate[9+1];
	char	ChockDrive[9+1];
	double	DiameterTaperStart;
	double	DiameterTaperEnd;
	double	TaperLength;
	char	RollMaterialClass[1+1];
	char	RollEllipse[5+1];
	char	RollCrownCoeff1[5+1];
	char	RollCrownCoeff2[5+1];
	char	RollCrownCoeff3[5+1];
	char	RollCrownCoeff4[5+1];
	char	RollCrownCoeff5[5+1];
	char	RollShapeCode[2+1];
	char	OperatorSideChockNo[4+1];
	char	DriveSideChockNo[4+1];
	char	MountTime[27];
	char	MountShiftNo[1+1];
	char	MountGroupNo[1+1];
	char	UnMountTime[27];
	char	UnMountShiftNo[1+1];
	char	UnMountGroupNo[1+1];
	int	RunTime;
	int	RolledTime;
	int	RolledWeight;
	int	RolledLength;
	char	RemoveReason[4+1];
	char	Remark[10+1];
	char	extId[20+1];
	char	MatchRollNo[15+1];
	char	Ok[1+1];
	char	toc[27];
	char	tom[27];
	char	mop[121];
	char	mou[31];
}structTable;
//	 LTA Structure Zi
struct STR_T_ROL_HISTORYZi{
	short	StandNoZi;
	short	RollPositionZi;
	short	RollStatusZi;
	short	DiameterMiddleZi;
	short	RollCrownZi;
	short	RollGroupNoZi;
	short	RollAssemblyNoZi;
	short	RollMaterialZi;
	short	RollSteelGradeZi;
	short	DiameterHeadZi;
	short	DiameterTailZi;
	short	PositionHeadZi;
	short	PositionMiddleZi;
	short	PositionTailZi;
	short	CrownSighZi;
	short	RollRoughZi;
	short	RollRoughMethodZi;
	short	RollSurfaceMethodZi;
	short	ChockOperateZi;
	short	ChockDriveZi;
	short	DiameterTaperStartZi;
	short	DiameterTaperEndZi;
	short	TaperLengthZi;
	short	RollMaterialClassZi;
	short	RollEllipseZi;
	short	RollCrownCoeff1Zi;
	short	RollCrownCoeff2Zi;
	short	RollCrownCoeff3Zi;
	short	RollCrownCoeff4Zi;
	short	RollCrownCoeff5Zi;
	short	RollShapeCodeZi;
	short	OperatorSideChockNoZi;
	short	DriveSideChockNoZi;
	short	MountTimeZi;
	short	MountShiftNoZi;
	short	MountGroupNoZi;
	short	UnMountTimeZi;
	short	UnMountShiftNoZi;
	short	UnMountGroupNoZi;
	short	RunTimeZi;
	short	RolledTimeZi;
	short	RolledWeightZi;
	short	RolledLengthZi;
	short	RemoveReasonZi;
	short	RemarkZi;
	short	extIdZi;
	short	MatchRollNoZi;
	short	OkZi;
	short	tocZi;
	short	tomZi;
	short	mopZi;
	short	mouZi;
}structTableZi;
//
//C O N S T R U C T O R S
//=======================
//
public:
T_ROL_HISTORY();
//D E S T R U C T O R S
//=======================
//
virtual ~T_ROL_HISTORY();
//
//C O P Y  -  C O N S T R U C T O R 
//=======================
T_ROL_HISTORY(const T_ROL_HISTORY &inst);
// For Constructors with parameters the flag dbAccess
// informs you if the access was successfully or not
T_ROL_HISTORY( long arg1);

//methods
public:
char* getCreationTime() {return "2014.12.2  13:0: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 );


//	 public methode initInsertKeys
//
//	this methode stores the unique key attributes
//
void initInsertKeys( long arg1 );


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_ROL_HISTORY operator+(const T_ROL_HISTORY &inst) const;

//
//O P E R A T O R  = 
//===================
//
public:
const T_ROL_HISTORY& operator=(const T_ROL_HISTORY &inst);
long Seq() const;//{
	//return((long)l_Seq );
//}


void set_Seq( long arg );//{ 
	//l_Seq = arg;
	//return;
//}


char* RollNo() const;//{
	//return((char*)c_RollNo );
//}


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


long StandNo() const;//{
	//return((long)l_StandNo );
//}

short StandNoZi() const;//{
	//return( s_StandNoZi);
//}

void set_StandNo( long arg );//{ 
	//l_StandNo = arg;
	//s_StandNoZi=  0;
	//return;
//}

void set_StandNoZi( short arg ) ;//{
	//s_StandNoZi =  arg;
//}

char* RollType() const;//{
	//return((char*)c_RollType );
//}


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


char* RollPosition() const;//{
	//return((char*)c_RollPosition );
//}

short RollPositionZi() const;//{
	//return( s_RollPositionZi);
//}

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

void set_RollPositionZi( short arg ) ;//{
	//s_RollPositionZi =  arg;
//}

char* RollStatus() const;//{
	//return((char*)c_RollStatus );
//}

short RollStatusZi() const;//{
	//return( s_RollStatusZi);
//}

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

void set_RollStatusZi( short arg ) ;//{
	//s_RollStatusZi =  arg;
//}

double DiameterMiddle() const;//{
	//return((double)d_DiameterMiddle );
//}

short DiameterMiddleZi() const;//{
	//return( s_DiameterMiddleZi);
//}

void set_DiameterMiddle( double arg );//{ 
	//d_DiameterMiddle = arg;
	//s_DiameterMiddleZi=  0;
	//return;
//}

void set_DiameterMiddleZi( short arg ) ;//{
	//s_DiameterMiddleZi =  arg;
//}

double RollCrown() const;//{
	//return((double)d_RollCrown );
//}

short RollCrownZi() const;//{
	//return( s_RollCrownZi);
//}

void set_RollCrown( double arg );//{ 
	//d_RollCrown = arg;
	//s_RollCrownZi=  0;
	//return;
//}

void set_RollCrownZi( short arg ) ;//{
	//s_RollCrownZi =  arg;
//}

long RollGroupNo() const;//{
	//return((long)l_RollGroupNo );
//}

short RollGroupNoZi() const;//{
	//return( s_RollGroupNoZi);
//}

void set_RollGroupNo( long arg );//{ 
	//l_RollGroupNo = arg;
	//s_RollGroupNoZi=  0;
	//return;
//}

void set_RollGroupNoZi( short arg ) ;//{
	//s_RollGroupNoZi =  arg;
//}

char* RollAssemblyNo() const;//{
	//return((char*)c_RollAssemblyNo );
//}

short RollAssemblyNoZi() const;//{
	//return( s_RollAssemblyNoZi);
//}

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

void set_RollAssemblyNoZi( short arg ) ;//{
	//s_RollAssemblyNoZi =  arg;
//}

char* RollMaterial() const;//{
	//return((char*)c_RollMaterial );
//}

short RollMaterialZi() const;//{
	//return( s_RollMaterialZi);
//}

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

void set_RollMaterialZi( short arg ) ;//{
	//s_RollMaterialZi =  arg;
//}

char* RollSteelGrade() const;//{
	//return((char*)c_RollSteelGrade );
//}

short RollSteelGradeZi() const;//{
	//return( s_RollSteelGradeZi);
//}

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

void set_RollSteelGradeZi( short arg ) ;//{
	//s_RollSteelGradeZi =  arg;
//}

double DiameterHead() const;//{
	//return((double)d_DiameterHead );
//}

short DiameterHeadZi() const;//{
	//return( s_DiameterHeadZi);
//}

void set_DiameterHead( double arg );//{ 
	//d_DiameterHead = arg;
	//s_DiameterHeadZi=  0;
	//return;
//}

void set_DiameterHeadZi( short arg ) ;//{
	//s_DiameterHeadZi =  arg;
//}

double DiameterTail() const;//{
	//return((double)d_DiameterTail );
//}

short DiameterTailZi() const;//{
	//return( s_DiameterTailZi);
//}

void set_DiameterTail( double arg );//{ 
	//d_DiameterTail = arg;
	//s_DiameterTailZi=  0;
	//return;
//}

void set_DiameterTailZi( short arg ) ;//{
	//s_DiameterTailZi =  arg;
//}

long PositionHead() const;//{
	//return((long)l_PositionHead );
//}

short PositionHeadZi() const;//{
	//return( s_PositionHeadZi);
//}

void set_PositionHead( long arg );//{ 
	//l_PositionHead = arg;
	//s_PositionHeadZi=  0;
	//return;
//}

void set_PositionHeadZi( short arg ) ;//{
	//s_PositionHeadZi =  arg;
//}

long PositionMiddle() const;//{
	//return((long)l_PositionMiddle );
//}

short PositionMiddleZi() const;//{
	//return( s_PositionMiddleZi);
//}

void set_PositionMiddle( long arg );//{ 
	//l_PositionMiddle = arg;
	//s_PositionMiddleZi=  0;
	//return;
//}

void set_PositionMiddleZi( short arg ) ;//{
	//s_PositionMiddleZi =  arg;
//}

long PositionTail() const;//{
	//return((long)l_PositionTail );
//}

short PositionTailZi() const;//{
	//return( s_PositionTailZi);
//}

void set_PositionTail( long arg );//{ 
	//l_PositionTail = arg;
	//s_PositionTailZi=  0;
	//return;
//}

void set_PositionTailZi( short arg ) ;//{
	//s_PositionTailZi =  arg;
//}

long CrownSigh() const;//{
	//return((long)l_CrownSigh );
//}

short CrownSighZi() const;//{
	//return( s_CrownSighZi);
//}

void set_CrownSigh( long arg );//{ 
	//l_CrownSigh = arg;
	//s_CrownSighZi=  0;
	//return;
//}

void set_CrownSighZi( short arg ) ;//{
	//s_CrownSighZi =  arg;
//}

double RollRough() const;//{
	//return((double)d_RollRough );
//}

short RollRoughZi() const;//{
	//return( s_RollRoughZi);
//}

void set_RollRough( double arg );//{ 
	//d_RollRough = arg;
	//s_RollRoughZi=  0;
	//return;
//}

void set_RollRoughZi( short arg ) ;//{
	//s_RollRoughZi =  arg;
//}

char* RollRoughMethod() const;//{
	//return((char*)c_RollRoughMethod );
//}

short RollRoughMethodZi() const;//{
	//return( s_RollRoughMethodZi);
//}

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

void set_RollRoughMethodZi( short arg ) ;//{
	//s_RollRoughMethodZi =  arg;
//}

char* RollSurfaceMethod() const;//{
	//return((char*)c_RollSurfaceMethod );
//}

short RollSurfaceMethodZi() const;//{
	//return( s_RollSurfaceMethodZi);
//}

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

void set_RollSurfaceMethodZi( short arg ) ;//{
	//s_RollSurfaceMethodZi =  arg;
//}

char* ChockOperate() const;//{
	//return((char*)c_ChockOperate );
//}

short ChockOperateZi() const;//{
	//return( s_ChockOperateZi);
//}

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

void set_ChockOperateZi( short arg ) ;//{
	//s_ChockOperateZi =  arg;
//}

char* ChockDrive() const;//{
	//return((char*)c_ChockDrive );
//}

short ChockDriveZi() const;//{
	//return( s_ChockDriveZi);
//}

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

void set_ChockDriveZi( short arg ) ;//{
	//s_ChockDriveZi =  arg;
//}

double DiameterTaperStart() const;//{
	//return((double)d_DiameterTaperStart );
//}

short DiameterTaperStartZi() const;//{
	//return( s_DiameterTaperStartZi);
//}

void set_DiameterTaperStart( double arg );//{ 
	//d_DiameterTaperStart = arg;
	//s_DiameterTaperStartZi=  0;
	//return;
//}

void set_DiameterTaperStartZi( short arg ) ;//{
	//s_DiameterTaperStartZi =  arg;
//}

double DiameterTaperEnd() const;//{
	//return((double)d_DiameterTaperEnd );
//}

short DiameterTaperEndZi() const;//{
	//return( s_DiameterTaperEndZi);
//}

void set_DiameterTaperEnd( double arg );//{ 
	//d_DiameterTaperEnd = arg;
	//s_DiameterTaperEndZi=  0;
	//return;
//}

void set_DiameterTaperEndZi( short arg ) ;//{
	//s_DiameterTaperEndZi =  arg;
//}

double TaperLength() const;//{
	//return((double)d_TaperLength );
//}

short TaperLengthZi() const;//{
	//return( s_TaperLengthZi);
//}

void set_TaperLength( double arg );//{ 
	//d_TaperLength = arg;
	//s_TaperLengthZi=  0;
	//return;
//}

void set_TaperLengthZi( short arg ) ;//{
	//s_TaperLengthZi =  arg;
//}

char* RollMaterialClass() const;//{
	//return((char*)c_RollMaterialClass );
//}

short RollMaterialClassZi() const;//{
	//return( s_RollMaterialClassZi);
//}

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

void set_RollMaterialClassZi( short arg ) ;//{
	//s_RollMaterialClassZi =  arg;
//}

char* RollEllipse() const;//{
	//return((char*)c_RollEllipse );
//}

short RollEllipseZi() const;//{
	//return( s_RollEllipseZi);
//}

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

void set_RollEllipseZi( short arg ) ;//{
	//s_RollEllipseZi =  arg;
//}

char* RollCrownCoeff1() const;//{
	//return((char*)c_RollCrownCoeff1 );
//}

short RollCrownCoeff1Zi() const;//{
	//return( s_RollCrownCoeff1Zi);
//}

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

void set_RollCrownCoeff1Zi( short arg ) ;//{
	//s_RollCrownCoeff1Zi =  arg;
//}

char* RollCrownCoeff2() const;//{
	//return((char*)c_RollCrownCoeff2 );
//}

short RollCrownCoeff2Zi() const;//{
	//return( s_RollCrownCoeff2Zi);
//}

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

void set_RollCrownCoeff2Zi( short arg ) ;//{
	//s_RollCrownCoeff2Zi =  arg;
//}

char* RollCrownCoeff3() const;//{
	//return((char*)c_RollCrownCoeff3 );
//}

short RollCrownCoeff3Zi() const;//{
	//return( s_RollCrownCoeff3Zi);
//}

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

void set_RollCrownCoeff3Zi( short arg ) ;//{
	//s_RollCrownCoeff3Zi =  arg;
//}

char* RollCrownCoeff4() const;//{
	//return((char*)c_RollCrownCoeff4 );
//}

short RollCrownCoeff4Zi() const;//{
	//return( s_RollCrownCoeff4Zi);
//}

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

void set_RollCrownCoeff4Zi( short arg ) ;//{
	//s_RollCrownCoeff4Zi =  arg;
//}

char* RollCrownCoeff5() const;//{
	//return((char*)c_RollCrownCoeff5 );
//}

short RollCrownCoeff5Zi() const;//{
	//return( s_RollCrownCoeff5Zi);
//}

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

void set_RollCrownCoeff5Zi( short arg ) ;//{
	//s_RollCrownCoeff5Zi =  arg;
//}

char* RollShapeCode() const;//{
	//return((char*)c_RollShapeCode );
//}

short RollShapeCodeZi() const;//{
	//return( s_RollShapeCodeZi);
//}

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

void set_RollShapeCodeZi( short arg ) ;//{
	//s_RollShapeCodeZi =  arg;
//}

char* OperatorSideChockNo() const;//{
	//return((char*)c_OperatorSideChockNo );
//}

short OperatorSideChockNoZi() const;//{
	//return( s_OperatorSideChockNoZi);
//}

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

void set_OperatorSideChockNoZi( short arg ) ;//{
	//s_OperatorSideChockNoZi =  arg;
//}

char* DriveSideChockNo() const;//{
	//return((char*)c_DriveSideChockNo );
//}

short DriveSideChockNoZi() const;//{
	//return( s_DriveSideChockNoZi);
//}

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

void set_DriveSideChockNoZi( short arg ) ;//{
	//s_DriveSideChockNoZi =  arg;
//}

char* MountTime() const;//{
	//return((char*)c_MountTime );
//}

short MountTimeZi() const;//{
	//return( s_MountTimeZi);
//}

void set_MountTime( char* arg );//{ 
	//strncpy((char*)c_MountTime , arg , sizeof(c_MountTime));
	//c_MountTime[sizeof(c_MountTime)-1] = '\0';
	//s_MountTimeZi=  0;
	//return;
//}

void set_MountTimeZi( short arg ) ;//{
	//s_MountTimeZi =  arg;
//}

char* MountShiftNo() const;//{
	//return((char*)c_MountShiftNo );
//}

short MountShiftNoZi() const;//{
	//return( s_MountShiftNoZi);
//}

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

void set_MountShiftNoZi( short arg ) ;//{
	//s_MountShiftNoZi =  arg;
//}

char* MountGroupNo() const;//{
	//return((char*)c_MountGroupNo );
//}

short MountGroupNoZi() const;//{
	//return( s_MountGroupNoZi);
//}

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

void set_MountGroupNoZi( short arg ) ;//{
	//s_MountGroupNoZi =  arg;
//}

char* UnMountTime() const;//{
	//return((char*)c_UnMountTime );
//}

short UnMountTimeZi() const;//{
	//return( s_UnMountTimeZi);
//}

void set_UnMountTime( char* arg );//{ 
	//strncpy((char*)c_UnMountTime , arg , sizeof(c_UnMountTime));
	//c_UnMountTime[sizeof(c_UnMountTime)-1] = '\0';
	//s_UnMountTimeZi=  0;
	//return;
//}

void set_UnMountTimeZi( short arg ) ;//{
	//s_UnMountTimeZi =  arg;
//}

char* UnMountShiftNo() const;//{
	//return((char*)c_UnMountShiftNo );
//}

short UnMountShiftNoZi() const;//{
	//return( s_UnMountShiftNoZi);
//}

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

void set_UnMountShiftNoZi( short arg ) ;//{
	//s_UnMountShiftNoZi =  arg;
//}

char* UnMountGroupNo() const;//{
	//return((char*)c_UnMountGroupNo );
//}

short UnMountGroupNoZi() const;//{
	//return( s_UnMountGroupNoZi);
//}

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

void set_UnMountGroupNoZi( short arg ) ;//{
	//s_UnMountGroupNoZi =  arg;
//}

long RunTime() const;//{
	//return((long)l_RunTime );
//}

short RunTimeZi() const;//{
	//return( s_RunTimeZi);
//}

void set_RunTime( long arg );//{ 
	//l_RunTime = arg;
	//s_RunTimeZi=  0;
	//return;
//}

void set_RunTimeZi( short arg ) ;//{
	//s_RunTimeZi =  arg;
//}

long RolledTime() const;//{
	//return((long)l_RolledTime );
//}

short RolledTimeZi() const;//{
	//return( s_RolledTimeZi);
//}

void set_RolledTime( long arg );//{ 
	//l_RolledTime = arg;
	//s_RolledTimeZi=  0;
	//return;
//}

void set_RolledTimeZi( short arg ) ;//{
	//s_RolledTimeZi =  arg;
//}

long RolledWeight() const;//{
	//return((long)l_RolledWeight );
//}

short RolledWeightZi() const;//{
	//return( s_RolledWeightZi);
//}

void set_RolledWeight( long arg );//{ 
	//l_RolledWeight = arg;
	//s_RolledWeightZi=  0;
	//return;
//}

void set_RolledWeightZi( short arg ) ;//{
	//s_RolledWeightZi =  arg;
//}

long RolledLength() const;//{
	//return((long)l_RolledLength );
//}

short RolledLengthZi() const;//{
	//return( s_RolledLengthZi);
//}

void set_RolledLength( long arg );//{ 
	//l_RolledLength = arg;
	//s_RolledLengthZi=  0;
	//return;
//}

void set_RolledLengthZi( short arg ) ;//{
	//s_RolledLengthZi =  arg;
//}

char* RemoveReason() const;//{
	//return((char*)c_RemoveReason );
//}

short RemoveReasonZi() const;//{
	//return( s_RemoveReasonZi);
//}

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

void set_RemoveReasonZi( short arg ) ;//{
	//s_RemoveReasonZi =  arg;
//}

char* Remark() const;//{
	//return((char*)c_Remark );
//}

short RemarkZi() const;//{
	//return( s_RemarkZi);
//}

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

void set_RemarkZi( short arg ) ;//{
	//s_RemarkZi =  arg;
//}

char* extId() const;//{
	//return((char*)c_extId );
//}

short extIdZi() const;//{
	//return( s_extIdZi);
//}

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

void set_extIdZi( short arg ) ;//{
	//s_extIdZi =  arg;
//}

char* MatchRollNo() const;//{
	//return((char*)c_MatchRollNo );
//}

short MatchRollNoZi() const;//{
	//return( s_MatchRollNoZi);
//}

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

void set_MatchRollNoZi( short arg ) ;//{
	//s_MatchRollNoZi =  arg;
//}

char* Ok() const;//{
	//return((char*)c_Ok );
//}

short OkZi() const;//{
	//return( s_OkZi);
//}

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

void set_OkZi( short arg ) ;//{
	//s_OkZi =  arg;
//}

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_Seq();//{
	//return((long)l_k_Seq );
//}

void set_k_Seq( long arg );//{
	//l_k_Seq =  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_ROL_HISTORY");
//}
///////////////////////////////////////////////////
int getSqlCode();//{
	//return( db.dbSqlCode);
//}
///////////////////////////////////////////////////
int getRowsProcessed();//{
	//return( db.dbRowsProcessed);
//}
};
#endif