867 lines
26 KiB
C++
867 lines
26 KiB
C++
// Version: 2019.4.23 13:40:42
|
|
|
|
// File: T_ROLLPER_DATA.cpp
|
|
|
|
#include "T_ROLLPER_DATA.h"
|
|
|
|
T_ROLLPER_DATA::T_ROLLPER_DATA(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_ROLLPER_DATA::~T_ROLLPER_DATA(){
|
|
}
|
|
void T_ROLLPER_DATA::initial(){
|
|
// initialise all membervariables
|
|
set_entId((char*)"");
|
|
set_extId((char*)"");
|
|
set_extIdZi(-1);
|
|
set_work_roll_dia_t(0.0);
|
|
set_work_roll_dia_tZi(-1);
|
|
set_work_roll_dia_b(0.0);
|
|
set_work_roll_dia_bZi(-1);
|
|
set_work_roll_no_t(0.0);
|
|
set_work_roll_no_tZi(-1);
|
|
set_work_roll_no_b(0.0);
|
|
set_work_roll_no_bZi(-1);
|
|
set_mill_roll_rough_t(0.0);
|
|
set_mill_roll_rough_tZi(-1);
|
|
set_mill_roll_rough_b(0.0);
|
|
set_mill_roll_rough_bZi(-1);
|
|
set_work_roll_shape_t(0.0);
|
|
set_work_roll_shape_tZi(-1);
|
|
set_work_roll_shape_b(0.0);
|
|
set_work_roll_shape_bZi(-1);
|
|
set_work_roll_coate_t(0.0);
|
|
set_work_roll_coate_tZi(-1);
|
|
set_work_roll_coate_b(0.0);
|
|
set_work_roll_coate_bZi(-1);
|
|
set_roll_weight(0.0);
|
|
set_roll_weightZi(-1);
|
|
set_roll_length(0);
|
|
set_roll_lengthZi(-1);
|
|
set_spm_mode(0);
|
|
set_spm_modeZi(-1);
|
|
set_spm_operate(0);
|
|
set_spm_operateZi(-1);
|
|
set_spm_roll_mode(0);
|
|
set_spm_roll_modeZi(-1);
|
|
set_spm_wr_crown_t(0.0);
|
|
set_spm_wr_crown_tZi(-1);
|
|
set_spm_wr_crown_b(0.0);
|
|
set_spm_wr_crown_bZi(-1);
|
|
set_TC((char*)"");
|
|
set_TCZi(-1);
|
|
// initialies Primary key members
|
|
set_k_entId((char*)"");
|
|
}
|
|
T_ROLLPER_DATA::T_ROLLPER_DATA(const char* arg1)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_ROLLPER_DATA:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::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_ROLLPER_DATA
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_ROLLPER_DATA::setPrimKey( const char* arg1 ){
|
|
strncpy( (char*)c_k_entId , arg1 , sizeof(c_k_entId) );
|
|
c_k_entId[sizeof(c_k_entId)-1] = '\0';
|
|
} // end of methode
|
|
|
|
void T_ROLLPER_DATA::initInsertKeys( const char* arg1 ){
|
|
setPrimKey ( arg1);
|
|
strncpy( (char*)c_entId , arg1 , sizeof(c_entId) );
|
|
c_entId[sizeof(c_entId)-1] = '\0';
|
|
} // end of methode
|
|
void T_ROLLPER_DATA::setKeysFromRecord(){
|
|
set_k_entId( entId() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_ROLLPER_DATA T_ROLLPER_DATA::operator+(const T_ROLLPER_DATA &inst) const{
|
|
T_ROLLPER_DATA ptrT_ROLLPER_DATA(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_ROLLPER_DATA.set_entId(inst.entId());
|
|
//----------------------------------------------------------
|
|
if(inst.extIdZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_extId(inst.extId());
|
|
ptrT_ROLLPER_DATA.set_extIdZi(inst.extIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_dia_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_dia_t(inst.work_roll_dia_t());
|
|
ptrT_ROLLPER_DATA.set_work_roll_dia_tZi(inst.work_roll_dia_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_dia_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_dia_b(inst.work_roll_dia_b());
|
|
ptrT_ROLLPER_DATA.set_work_roll_dia_bZi(inst.work_roll_dia_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_no_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_no_t(inst.work_roll_no_t());
|
|
ptrT_ROLLPER_DATA.set_work_roll_no_tZi(inst.work_roll_no_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_no_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_no_b(inst.work_roll_no_b());
|
|
ptrT_ROLLPER_DATA.set_work_roll_no_bZi(inst.work_roll_no_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mill_roll_rough_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_mill_roll_rough_t(inst.mill_roll_rough_t());
|
|
ptrT_ROLLPER_DATA.set_mill_roll_rough_tZi(inst.mill_roll_rough_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mill_roll_rough_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_mill_roll_rough_b(inst.mill_roll_rough_b());
|
|
ptrT_ROLLPER_DATA.set_mill_roll_rough_bZi(inst.mill_roll_rough_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_shape_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_shape_t(inst.work_roll_shape_t());
|
|
ptrT_ROLLPER_DATA.set_work_roll_shape_tZi(inst.work_roll_shape_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_shape_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_shape_b(inst.work_roll_shape_b());
|
|
ptrT_ROLLPER_DATA.set_work_roll_shape_bZi(inst.work_roll_shape_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_coate_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_coate_t(inst.work_roll_coate_t());
|
|
ptrT_ROLLPER_DATA.set_work_roll_coate_tZi(inst.work_roll_coate_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.work_roll_coate_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_work_roll_coate_b(inst.work_roll_coate_b());
|
|
ptrT_ROLLPER_DATA.set_work_roll_coate_bZi(inst.work_roll_coate_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.roll_weightZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_roll_weight(inst.roll_weight());
|
|
ptrT_ROLLPER_DATA.set_roll_weightZi(inst.roll_weightZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.roll_lengthZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_roll_length(inst.roll_length());
|
|
ptrT_ROLLPER_DATA.set_roll_lengthZi(inst.roll_lengthZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.spm_modeZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_spm_mode(inst.spm_mode());
|
|
ptrT_ROLLPER_DATA.set_spm_modeZi(inst.spm_modeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.spm_operateZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_spm_operate(inst.spm_operate());
|
|
ptrT_ROLLPER_DATA.set_spm_operateZi(inst.spm_operateZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.spm_roll_modeZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_spm_roll_mode(inst.spm_roll_mode());
|
|
ptrT_ROLLPER_DATA.set_spm_roll_modeZi(inst.spm_roll_modeZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.spm_wr_crown_tZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_spm_wr_crown_t(inst.spm_wr_crown_t());
|
|
ptrT_ROLLPER_DATA.set_spm_wr_crown_tZi(inst.spm_wr_crown_tZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.spm_wr_crown_bZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_spm_wr_crown_b(inst.spm_wr_crown_b());
|
|
ptrT_ROLLPER_DATA.set_spm_wr_crown_bZi(inst.spm_wr_crown_bZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.TCZi() != -1){
|
|
ptrT_ROLLPER_DATA.set_TC(inst.TC());
|
|
ptrT_ROLLPER_DATA.set_TCZi(inst.TCZi());
|
|
}
|
|
return (ptrT_ROLLPER_DATA);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_ROLLPER_DATA& T_ROLLPER_DATA::operator=(const T_ROLLPER_DATA &inst){
|
|
//----------------------------------------------------------
|
|
this->set_entId(inst.entId());
|
|
//----------------------------------------------------------
|
|
this->set_extId(inst.extId());
|
|
this->set_extIdZi(inst.extIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_dia_t(inst.work_roll_dia_t());
|
|
this->set_work_roll_dia_tZi(inst.work_roll_dia_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_dia_b(inst.work_roll_dia_b());
|
|
this->set_work_roll_dia_bZi(inst.work_roll_dia_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_no_t(inst.work_roll_no_t());
|
|
this->set_work_roll_no_tZi(inst.work_roll_no_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_no_b(inst.work_roll_no_b());
|
|
this->set_work_roll_no_bZi(inst.work_roll_no_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_mill_roll_rough_t(inst.mill_roll_rough_t());
|
|
this->set_mill_roll_rough_tZi(inst.mill_roll_rough_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_mill_roll_rough_b(inst.mill_roll_rough_b());
|
|
this->set_mill_roll_rough_bZi(inst.mill_roll_rough_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_shape_t(inst.work_roll_shape_t());
|
|
this->set_work_roll_shape_tZi(inst.work_roll_shape_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_shape_b(inst.work_roll_shape_b());
|
|
this->set_work_roll_shape_bZi(inst.work_roll_shape_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_coate_t(inst.work_roll_coate_t());
|
|
this->set_work_roll_coate_tZi(inst.work_roll_coate_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_coate_b(inst.work_roll_coate_b());
|
|
this->set_work_roll_coate_bZi(inst.work_roll_coate_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_roll_weight(inst.roll_weight());
|
|
this->set_roll_weightZi(inst.roll_weightZi());
|
|
//----------------------------------------------------------
|
|
this->set_roll_length(inst.roll_length());
|
|
this->set_roll_lengthZi(inst.roll_lengthZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_mode(inst.spm_mode());
|
|
this->set_spm_modeZi(inst.spm_modeZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_operate(inst.spm_operate());
|
|
this->set_spm_operateZi(inst.spm_operateZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_roll_mode(inst.spm_roll_mode());
|
|
this->set_spm_roll_modeZi(inst.spm_roll_modeZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_wr_crown_t(inst.spm_wr_crown_t());
|
|
this->set_spm_wr_crown_tZi(inst.spm_wr_crown_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_wr_crown_b(inst.spm_wr_crown_b());
|
|
this->set_spm_wr_crown_bZi(inst.spm_wr_crown_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_TC(inst.TC());
|
|
this->set_TCZi(inst.TCZi());
|
|
return (*this);
|
|
}
|
|
//
|
|
//C O P Y - C O N S T R U C T O R
|
|
//===================
|
|
//
|
|
T_ROLLPER_DATA::T_ROLLPER_DATA(const T_ROLLPER_DATA &inst){
|
|
//----------------------------------------------------------
|
|
this->set_entId(inst.entId());
|
|
//----------------------------------------------------------
|
|
this->set_extId(inst.extId());
|
|
this->set_extIdZi(inst.extIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_dia_t(inst.work_roll_dia_t());
|
|
this->set_work_roll_dia_tZi(inst.work_roll_dia_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_dia_b(inst.work_roll_dia_b());
|
|
this->set_work_roll_dia_bZi(inst.work_roll_dia_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_no_t(inst.work_roll_no_t());
|
|
this->set_work_roll_no_tZi(inst.work_roll_no_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_no_b(inst.work_roll_no_b());
|
|
this->set_work_roll_no_bZi(inst.work_roll_no_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_mill_roll_rough_t(inst.mill_roll_rough_t());
|
|
this->set_mill_roll_rough_tZi(inst.mill_roll_rough_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_mill_roll_rough_b(inst.mill_roll_rough_b());
|
|
this->set_mill_roll_rough_bZi(inst.mill_roll_rough_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_shape_t(inst.work_roll_shape_t());
|
|
this->set_work_roll_shape_tZi(inst.work_roll_shape_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_shape_b(inst.work_roll_shape_b());
|
|
this->set_work_roll_shape_bZi(inst.work_roll_shape_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_coate_t(inst.work_roll_coate_t());
|
|
this->set_work_roll_coate_tZi(inst.work_roll_coate_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_work_roll_coate_b(inst.work_roll_coate_b());
|
|
this->set_work_roll_coate_bZi(inst.work_roll_coate_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_roll_weight(inst.roll_weight());
|
|
this->set_roll_weightZi(inst.roll_weightZi());
|
|
//----------------------------------------------------------
|
|
this->set_roll_length(inst.roll_length());
|
|
this->set_roll_lengthZi(inst.roll_lengthZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_mode(inst.spm_mode());
|
|
this->set_spm_modeZi(inst.spm_modeZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_operate(inst.spm_operate());
|
|
this->set_spm_operateZi(inst.spm_operateZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_roll_mode(inst.spm_roll_mode());
|
|
this->set_spm_roll_modeZi(inst.spm_roll_modeZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_wr_crown_t(inst.spm_wr_crown_t());
|
|
this->set_spm_wr_crown_tZi(inst.spm_wr_crown_tZi());
|
|
//----------------------------------------------------------
|
|
this->set_spm_wr_crown_b(inst.spm_wr_crown_b());
|
|
this->set_spm_wr_crown_bZi(inst.spm_wr_crown_bZi());
|
|
//----------------------------------------------------------
|
|
this->set_TC(inst.TC());
|
|
this->set_TCZi(inst.TCZi());
|
|
}
|
|
char* T_ROLLPER_DATA::entId() const{
|
|
return((char*)c_entId );
|
|
}
|
|
|
|
|
|
void T_ROLLPER_DATA::set_entId( const char* arg ){
|
|
strncpy((char*)c_entId , arg , sizeof(c_entId));
|
|
c_entId[sizeof(c_entId)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_ROLLPER_DATA::extId() const{
|
|
return((char*)c_extId );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::extIdZi() const{
|
|
return( s_extIdZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::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 T_ROLLPER_DATA::set_extIdZi( short arg ) {
|
|
s_extIdZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_dia_t() const{
|
|
return((double)d_work_roll_dia_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_dia_tZi() const{
|
|
return( s_work_roll_dia_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_dia_t( double arg ){
|
|
d_work_roll_dia_t = arg;
|
|
s_work_roll_dia_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_dia_tZi( short arg ) {
|
|
s_work_roll_dia_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_dia_b() const{
|
|
return((double)d_work_roll_dia_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_dia_bZi() const{
|
|
return( s_work_roll_dia_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_dia_b( double arg ){
|
|
d_work_roll_dia_b = arg;
|
|
s_work_roll_dia_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_dia_bZi( short arg ) {
|
|
s_work_roll_dia_bZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_no_t() const{
|
|
return((double)d_work_roll_no_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_no_tZi() const{
|
|
return( s_work_roll_no_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_no_t( double arg ){
|
|
d_work_roll_no_t = arg;
|
|
s_work_roll_no_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_no_tZi( short arg ) {
|
|
s_work_roll_no_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_no_b() const{
|
|
return((double)d_work_roll_no_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_no_bZi() const{
|
|
return( s_work_roll_no_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_no_b( double arg ){
|
|
d_work_roll_no_b = arg;
|
|
s_work_roll_no_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_no_bZi( short arg ) {
|
|
s_work_roll_no_bZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::mill_roll_rough_t() const{
|
|
return((double)d_mill_roll_rough_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::mill_roll_rough_tZi() const{
|
|
return( s_mill_roll_rough_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_mill_roll_rough_t( double arg ){
|
|
d_mill_roll_rough_t = arg;
|
|
s_mill_roll_rough_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_mill_roll_rough_tZi( short arg ) {
|
|
s_mill_roll_rough_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::mill_roll_rough_b() const{
|
|
return((double)d_mill_roll_rough_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::mill_roll_rough_bZi() const{
|
|
return( s_mill_roll_rough_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_mill_roll_rough_b( double arg ){
|
|
d_mill_roll_rough_b = arg;
|
|
s_mill_roll_rough_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_mill_roll_rough_bZi( short arg ) {
|
|
s_mill_roll_rough_bZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_shape_t() const{
|
|
return((double)d_work_roll_shape_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_shape_tZi() const{
|
|
return( s_work_roll_shape_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_shape_t( double arg ){
|
|
d_work_roll_shape_t = arg;
|
|
s_work_roll_shape_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_shape_tZi( short arg ) {
|
|
s_work_roll_shape_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_shape_b() const{
|
|
return((double)d_work_roll_shape_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_shape_bZi() const{
|
|
return( s_work_roll_shape_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_shape_b( double arg ){
|
|
d_work_roll_shape_b = arg;
|
|
s_work_roll_shape_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_shape_bZi( short arg ) {
|
|
s_work_roll_shape_bZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_coate_t() const{
|
|
return((double)d_work_roll_coate_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_coate_tZi() const{
|
|
return( s_work_roll_coate_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_coate_t( double arg ){
|
|
d_work_roll_coate_t = arg;
|
|
s_work_roll_coate_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_coate_tZi( short arg ) {
|
|
s_work_roll_coate_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::work_roll_coate_b() const{
|
|
return((double)d_work_roll_coate_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::work_roll_coate_bZi() const{
|
|
return( s_work_roll_coate_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_coate_b( double arg ){
|
|
d_work_roll_coate_b = arg;
|
|
s_work_roll_coate_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_work_roll_coate_bZi( short arg ) {
|
|
s_work_roll_coate_bZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::roll_weight() const{
|
|
return((double)d_roll_weight );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::roll_weightZi() const{
|
|
return( s_roll_weightZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_roll_weight( double arg ){
|
|
d_roll_weight = arg;
|
|
s_roll_weightZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_roll_weightZi( short arg ) {
|
|
s_roll_weightZi = arg;
|
|
}
|
|
|
|
long T_ROLLPER_DATA::roll_length() const{
|
|
return((long)l_roll_length );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::roll_lengthZi() const{
|
|
return( s_roll_lengthZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_roll_length( long arg ){
|
|
l_roll_length = arg;
|
|
s_roll_lengthZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_roll_lengthZi( short arg ) {
|
|
s_roll_lengthZi = arg;
|
|
}
|
|
|
|
long T_ROLLPER_DATA::spm_mode() const{
|
|
return((long)l_spm_mode );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::spm_modeZi() const{
|
|
return( s_spm_modeZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_mode( long arg ){
|
|
l_spm_mode = arg;
|
|
s_spm_modeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_modeZi( short arg ) {
|
|
s_spm_modeZi = arg;
|
|
}
|
|
|
|
long T_ROLLPER_DATA::spm_operate() const{
|
|
return((long)l_spm_operate );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::spm_operateZi() const{
|
|
return( s_spm_operateZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_operate( long arg ){
|
|
l_spm_operate = arg;
|
|
s_spm_operateZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_operateZi( short arg ) {
|
|
s_spm_operateZi = arg;
|
|
}
|
|
|
|
long T_ROLLPER_DATA::spm_roll_mode() const{
|
|
return((long)l_spm_roll_mode );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::spm_roll_modeZi() const{
|
|
return( s_spm_roll_modeZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_roll_mode( long arg ){
|
|
l_spm_roll_mode = arg;
|
|
s_spm_roll_modeZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_roll_modeZi( short arg ) {
|
|
s_spm_roll_modeZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::spm_wr_crown_t() const{
|
|
return((double)d_spm_wr_crown_t );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::spm_wr_crown_tZi() const{
|
|
return( s_spm_wr_crown_tZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_wr_crown_t( double arg ){
|
|
d_spm_wr_crown_t = arg;
|
|
s_spm_wr_crown_tZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_wr_crown_tZi( short arg ) {
|
|
s_spm_wr_crown_tZi = arg;
|
|
}
|
|
|
|
double T_ROLLPER_DATA::spm_wr_crown_b() const{
|
|
return((double)d_spm_wr_crown_b );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::spm_wr_crown_bZi() const{
|
|
return( s_spm_wr_crown_bZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_wr_crown_b( double arg ){
|
|
d_spm_wr_crown_b = arg;
|
|
s_spm_wr_crown_bZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_spm_wr_crown_bZi( short arg ) {
|
|
s_spm_wr_crown_bZi = arg;
|
|
}
|
|
|
|
char* T_ROLLPER_DATA::TC() const{
|
|
return((char*)c_TC );
|
|
}
|
|
|
|
short T_ROLLPER_DATA::TCZi() const{
|
|
return( s_TCZi);
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_TC( char* arg ){
|
|
strncpy((char*)c_TC , arg , sizeof(c_TC));
|
|
c_TC[sizeof(c_TC)-1] = '\0';
|
|
s_TCZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_TCZi( short arg ) {
|
|
s_TCZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
char* T_ROLLPER_DATA::k_entId(){
|
|
return((char*)c_k_entId );
|
|
}
|
|
|
|
void T_ROLLPER_DATA::set_k_entId( char* arg ){
|
|
strncpy((char*)c_k_entId , arg , sizeof(c_k_entId));
|
|
c_k_entId[sizeof(c_k_entId)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_ROLLPER_DATA::fillStructure(){
|
|
strncpy ( structTable.entId , entId(),sizeof(structTable.entId));
|
|
strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
|
|
structTable.work_roll_dia_t = work_roll_dia_t();
|
|
structTable.work_roll_dia_b = work_roll_dia_b();
|
|
structTable.work_roll_no_t = work_roll_no_t();
|
|
structTable.work_roll_no_b = work_roll_no_b();
|
|
structTable.mill_roll_rough_t = mill_roll_rough_t();
|
|
structTable.mill_roll_rough_b = mill_roll_rough_b();
|
|
structTable.work_roll_shape_t = work_roll_shape_t();
|
|
structTable.work_roll_shape_b = work_roll_shape_b();
|
|
structTable.work_roll_coate_t = work_roll_coate_t();
|
|
structTable.work_roll_coate_b = work_roll_coate_b();
|
|
structTable.roll_weight = roll_weight();
|
|
structTable.roll_length = roll_length();
|
|
structTable.spm_mode = spm_mode();
|
|
structTable.spm_operate = spm_operate();
|
|
structTable.spm_roll_mode = spm_roll_mode();
|
|
structTable.spm_wr_crown_t = spm_wr_crown_t();
|
|
structTable.spm_wr_crown_b = spm_wr_crown_b();
|
|
strncpy ( structTable.TC , TC(),sizeof(structTable.TC));
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_ROLLPER_DATA::fillStructureZi(){
|
|
structTableZi.extIdZi = extIdZi();
|
|
structTableZi.work_roll_dia_tZi = work_roll_dia_tZi();
|
|
structTableZi.work_roll_dia_bZi = work_roll_dia_bZi();
|
|
structTableZi.work_roll_no_tZi = work_roll_no_tZi();
|
|
structTableZi.work_roll_no_bZi = work_roll_no_bZi();
|
|
structTableZi.mill_roll_rough_tZi = mill_roll_rough_tZi();
|
|
structTableZi.mill_roll_rough_bZi = mill_roll_rough_bZi();
|
|
structTableZi.work_roll_shape_tZi = work_roll_shape_tZi();
|
|
structTableZi.work_roll_shape_bZi = work_roll_shape_bZi();
|
|
structTableZi.work_roll_coate_tZi = work_roll_coate_tZi();
|
|
structTableZi.work_roll_coate_bZi = work_roll_coate_bZi();
|
|
structTableZi.roll_weightZi = roll_weightZi();
|
|
structTableZi.roll_lengthZi = roll_lengthZi();
|
|
structTableZi.spm_modeZi = spm_modeZi();
|
|
structTableZi.spm_operateZi = spm_operateZi();
|
|
structTableZi.spm_roll_modeZi = spm_roll_modeZi();
|
|
structTableZi.spm_wr_crown_tZi = spm_wr_crown_tZi();
|
|
structTableZi.spm_wr_crown_bZi = spm_wr_crown_bZi();
|
|
structTableZi.TCZi = TCZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_ROLLPER_DATA::setStructure() {
|
|
set_extId( structTable.extId);
|
|
set_work_roll_dia_t( structTable.work_roll_dia_t);
|
|
set_work_roll_dia_b( structTable.work_roll_dia_b);
|
|
set_work_roll_no_t( structTable.work_roll_no_t);
|
|
set_work_roll_no_b( structTable.work_roll_no_b);
|
|
set_mill_roll_rough_t( structTable.mill_roll_rough_t);
|
|
set_mill_roll_rough_b( structTable.mill_roll_rough_b);
|
|
set_work_roll_shape_t( structTable.work_roll_shape_t);
|
|
set_work_roll_shape_b( structTable.work_roll_shape_b);
|
|
set_work_roll_coate_t( structTable.work_roll_coate_t);
|
|
set_work_roll_coate_b( structTable.work_roll_coate_b);
|
|
set_roll_weight( structTable.roll_weight);
|
|
set_roll_length( structTable.roll_length);
|
|
set_spm_mode( structTable.spm_mode);
|
|
set_spm_operate( structTable.spm_operate);
|
|
set_spm_roll_mode( structTable.spm_roll_mode);
|
|
set_spm_wr_crown_t( structTable.spm_wr_crown_t);
|
|
set_spm_wr_crown_b( structTable.spm_wr_crown_b);
|
|
set_TC( structTable.TC);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_ROLLPER_DATA::setStructureZi() {
|
|
set_extIdZi( structTableZi.extIdZi);
|
|
set_work_roll_dia_tZi( structTableZi.work_roll_dia_tZi);
|
|
set_work_roll_dia_bZi( structTableZi.work_roll_dia_bZi);
|
|
set_work_roll_no_tZi( structTableZi.work_roll_no_tZi);
|
|
set_work_roll_no_bZi( structTableZi.work_roll_no_bZi);
|
|
set_mill_roll_rough_tZi( structTableZi.mill_roll_rough_tZi);
|
|
set_mill_roll_rough_bZi( structTableZi.mill_roll_rough_bZi);
|
|
set_work_roll_shape_tZi( structTableZi.work_roll_shape_tZi);
|
|
set_work_roll_shape_bZi( structTableZi.work_roll_shape_bZi);
|
|
set_work_roll_coate_tZi( structTableZi.work_roll_coate_tZi);
|
|
set_work_roll_coate_bZi( structTableZi.work_roll_coate_bZi);
|
|
set_roll_weightZi( structTableZi.roll_weightZi);
|
|
set_roll_lengthZi( structTableZi.roll_lengthZi);
|
|
set_spm_modeZi( structTableZi.spm_modeZi);
|
|
set_spm_operateZi( structTableZi.spm_operateZi);
|
|
set_spm_roll_modeZi( structTableZi.spm_roll_modeZi);
|
|
set_spm_wr_crown_tZi( structTableZi.spm_wr_crown_tZi);
|
|
set_spm_wr_crown_bZi( structTableZi.spm_wr_crown_bZi);
|
|
set_TCZi( structTableZi.TCZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_ROLLPER_DATA::getName(){
|
|
return((char*)"T_ROLLPER_DATA");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_ROLLPER_DATA::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_ROLLPER_DATA::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|