548 lines
13 KiB
C++
548 lines
13 KiB
C++
// Version: 2018.7.12 9:12:50
|
|
|
|
// File: T_MUR.cpp
|
|
|
|
#include "T_MUR.h"
|
|
|
|
T_MUR::T_MUR(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_MUR::~T_MUR(){
|
|
}
|
|
void T_MUR::initial(){
|
|
// initialise all membervariables
|
|
set_compMuCreator((char*)"");
|
|
set_compMuCreatorZi(-1);
|
|
set_compMuId(0);
|
|
set_compMuIdZi(-1);
|
|
set_compMusId(0);
|
|
set_compMusIdZi(-1);
|
|
set_compPos(0);
|
|
set_compPosZi(-1);
|
|
set_muId(0);
|
|
set_muCreator((char*)"");
|
|
set_musId(0);
|
|
set_toc((char*)"");
|
|
set_tocZi(-1);
|
|
set_toc((char*)"");
|
|
set_tomZi(-1);
|
|
set_mop((char*)"");
|
|
set_mopZi(-1);
|
|
set_mou((char*)"");
|
|
set_mouZi(-1);
|
|
// initialies Primary key members
|
|
set_k_muId(0);
|
|
set_k_muCreator((char*)"");
|
|
set_k_musId(0);
|
|
}
|
|
T_MUR::T_MUR(MU_CODE muCode )
|
|
{
|
|
initial();
|
|
setPrimKey (muCode ); //read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_MUR:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_MUR:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_MUR:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_MUR::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_MUR::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_MUR::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_MUR::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_MUR::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_MUR::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_MUR::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_MUR::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_MUR::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_MUR::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_MUR
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_MUR::setPrimKey( long arg1 , const char* arg2 , short arg3 ){
|
|
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;
|
|
} // end of methode
|
|
void T_MUR::setPrimKey( MU_CODE muCode ){
|
|
setPrimKey ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
|
|
} // end of methode
|
|
|
|
void T_MUR::initInsertKeys( long arg1 , const char* arg2 , short arg3 ){
|
|
setPrimKey ( arg1 , arg2 , arg3 );
|
|
l_muId = arg1;
|
|
strncpy( (char*)c_muCreator , arg2 , sizeof(c_muCreator) );
|
|
c_muCreator[sizeof(c_muCreator)-1] = '\0';
|
|
s_musId = arg3;
|
|
} // end of methode
|
|
void T_MUR::initInsertKeys( MU_CODE muCode ){
|
|
initInsertKeys ( muCode.actual.muId , muCode.actual.muCreator , muCode.actual.musId );
|
|
} // end of methode
|
|
void T_MUR::setKeysFromRecord(){
|
|
set_k_muId( muId() );
|
|
set_k_muCreator( muCreator() );
|
|
set_k_musId( musId() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_MUR T_MUR::operator+(const T_MUR &inst) const{
|
|
T_MUR ptrT_MUR(*this);
|
|
//----------------------------------------------------------
|
|
if(inst.compMuCreatorZi() != -1){
|
|
ptrT_MUR.set_compMuCreator(inst.compMuCreator());
|
|
ptrT_MUR.set_compMuCreatorZi(inst.compMuCreatorZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.compMuIdZi() != -1){
|
|
ptrT_MUR.set_compMuId(inst.compMuId());
|
|
ptrT_MUR.set_compMuIdZi(inst.compMuIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.compMusIdZi() != -1){
|
|
ptrT_MUR.set_compMusId(inst.compMusId());
|
|
ptrT_MUR.set_compMusIdZi(inst.compMusIdZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.compPosZi() != -1){
|
|
ptrT_MUR.set_compPos(inst.compPos());
|
|
ptrT_MUR.set_compPosZi(inst.compPosZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
ptrT_MUR.set_muId(inst.muId());
|
|
//----------------------------------------------------------
|
|
ptrT_MUR.set_muCreator(inst.muCreator());
|
|
//----------------------------------------------------------
|
|
ptrT_MUR.set_musId(inst.musId());
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_MUR.set_toc(inst.toc());
|
|
ptrT_MUR.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_MUR.set_tom(inst.tom());
|
|
ptrT_MUR.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_MUR.set_mop(inst.mop());
|
|
ptrT_MUR.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_MUR.set_mou(inst.mou());
|
|
ptrT_MUR.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_MUR);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_MUR& T_MUR::operator=(const T_MUR &inst){
|
|
//----------------------------------------------------------
|
|
this->set_compMuCreator(inst.compMuCreator());
|
|
this->set_compMuCreatorZi(inst.compMuCreatorZi());
|
|
//----------------------------------------------------------
|
|
this->set_compMuId(inst.compMuId());
|
|
this->set_compMuIdZi(inst.compMuIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_compMusId(inst.compMusId());
|
|
this->set_compMusIdZi(inst.compMusIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_compPos(inst.compPos());
|
|
this->set_compPosZi(inst.compPosZi());
|
|
//----------------------------------------------------------
|
|
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_MUR::T_MUR(const T_MUR &inst){
|
|
//----------------------------------------------------------
|
|
this->set_compMuCreator(inst.compMuCreator());
|
|
this->set_compMuCreatorZi(inst.compMuCreatorZi());
|
|
//----------------------------------------------------------
|
|
this->set_compMuId(inst.compMuId());
|
|
this->set_compMuIdZi(inst.compMuIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_compMusId(inst.compMusId());
|
|
this->set_compMusIdZi(inst.compMusIdZi());
|
|
//----------------------------------------------------------
|
|
this->set_compPos(inst.compPos());
|
|
this->set_compPosZi(inst.compPosZi());
|
|
//----------------------------------------------------------
|
|
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());
|
|
}
|
|
char* T_MUR::compMuCreator() const{
|
|
return((char*)c_compMuCreator );
|
|
}
|
|
|
|
short T_MUR::compMuCreatorZi() const{
|
|
return( s_compMuCreatorZi);
|
|
}
|
|
|
|
void T_MUR::set_compMuCreator( const char* arg ){
|
|
strncpy((char*)c_compMuCreator , arg , sizeof(c_compMuCreator));
|
|
c_compMuCreator[sizeof(c_compMuCreator)-1] = '\0';
|
|
s_compMuCreatorZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_MUR::set_compMuCreatorZi( short arg ) {
|
|
s_compMuCreatorZi = arg;
|
|
}
|
|
|
|
long T_MUR::compMuId() const{
|
|
return((long)l_compMuId );
|
|
}
|
|
|
|
short T_MUR::compMuIdZi() const{
|
|
return( s_compMuIdZi);
|
|
}
|
|
|
|
void T_MUR::set_compMuId( long arg ){
|
|
l_compMuId = arg;
|
|
s_compMuIdZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_MUR::set_compMuIdZi( short arg ) {
|
|
s_compMuIdZi = arg;
|
|
}
|
|
|
|
long T_MUR::compMusId() const{
|
|
return((long)l_compMusId );
|
|
}
|
|
|
|
short T_MUR::compMusIdZi() const{
|
|
return( s_compMusIdZi);
|
|
}
|
|
|
|
void T_MUR::set_compMusId( long arg ){
|
|
l_compMusId = arg;
|
|
s_compMusIdZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_MUR::set_compMusIdZi( short arg ) {
|
|
s_compMusIdZi = arg;
|
|
}
|
|
|
|
long T_MUR::compPos() const{
|
|
return((long)l_compPos );
|
|
}
|
|
|
|
short T_MUR::compPosZi() const{
|
|
return( s_compPosZi);
|
|
}
|
|
|
|
void T_MUR::set_compPos( long arg ){
|
|
l_compPos = arg;
|
|
s_compPosZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_MUR::set_compPosZi( short arg ) {
|
|
s_compPosZi = arg;
|
|
}
|
|
|
|
long T_MUR::muId() const{
|
|
return((long)l_muId );
|
|
}
|
|
|
|
void T_MUR::set_muId( long arg ){
|
|
l_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_MUR::muCreator() const{
|
|
return((char*)c_muCreator );
|
|
}
|
|
|
|
void T_MUR::set_muCreator( const char* arg ){
|
|
strncpy((char*)c_muCreator , arg , sizeof(c_muCreator));
|
|
c_muCreator[sizeof(c_muCreator)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
short T_MUR::musId() const{
|
|
return((short)s_musId );
|
|
}
|
|
|
|
void T_MUR::set_musId( short arg ){
|
|
s_musId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_MUR::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_MUR::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_MUR::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_MUR::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_MUR::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_MUR::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_MUR::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_MUR::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_MUR::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_MUR::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_MUR::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_MUR::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_MUR::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_MUR::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_MUR::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_MUR::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
long T_MUR::k_muId(){
|
|
return((long)l_k_muId );
|
|
}
|
|
|
|
void T_MUR::set_k_muId( long arg ){
|
|
l_k_muId = arg;
|
|
return;
|
|
}
|
|
|
|
char* T_MUR::k_muCreator(){
|
|
return((char*)c_k_muCreator );
|
|
}
|
|
|
|
void T_MUR::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_MUR::k_musId(){
|
|
return((short)s_k_musId );
|
|
}
|
|
|
|
void T_MUR::set_k_musId( short arg ){
|
|
s_k_musId = arg;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_MUR::fillStructure(){
|
|
strncpy ( structTable.compMuCreator , compMuCreator(),sizeof(structTable.compMuCreator));
|
|
structTable.compMuId = compMuId();
|
|
structTable.compMusId = compMusId();
|
|
structTable.compPos = compPos();
|
|
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_MUR::fillStructureZi(){
|
|
structTableZi.compMuCreatorZi = compMuCreatorZi();
|
|
structTableZi.compMuIdZi = compMuIdZi();
|
|
structTableZi.compMusIdZi = compMusIdZi();
|
|
structTableZi.compPosZi = compPosZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_MUR::setStructure() {
|
|
set_compMuCreator( structTable.compMuCreator);
|
|
set_compMuId( structTable.compMuId);
|
|
set_compMusId( structTable.compMusId);
|
|
set_compPos( structTable.compPos);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_MUR::setStructureZi() {
|
|
set_compMuCreatorZi( structTableZi.compMuCreatorZi);
|
|
set_compMuIdZi( structTableZi.compMuIdZi);
|
|
set_compMusIdZi( structTableZi.compMusIdZi);
|
|
set_compPosZi( structTableZi.compPosZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_MUR::getName(){
|
|
return((char*)"T_MUR");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_MUR::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_MUR::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|