msd_datatypes.h

//--------------------------------
// msd_datatypes.h
//
// Project: PDBe API Framework, EBI 
// Module: Data Layer's Data type Classes and 
// utilities for PDBe API Framework 
//
// Data Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//--------------------------------


#ifndef __MSD_DATATYPES_H__
#define __MSD_DATATYPES_H__

//#define __USE_STD_IOSTREAM //Compaq Tru64 compatibility
#include <ctype.h> 
#include <fstream>
#include <ctime>
#include <cstdio>
#include <string>
#include <unistd.h>


#ifndef __MSD_DEFS_H__
#include "msd_defs.h"
#endif


class msd_anyType
{ public:
  char * msd_item; // default is char
  let msd_sym;
  let msd_val;
  msd_anyType();
  virtual ~msd_anyType();
  virtual msd_anyType*& operator[](int i);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
};

class msd_anySimpleType: public msd_anyType
{ public:
  //char * msd_item; // default is char
  msd_anySimpleType();
  virtual ~msd_anySimpleType();
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
};
  
class msd_datetime: public msd_anySimpleType
{ public:
  otl_datetime  msd_item;               // remove time_t msd_item to use char*msd_item with "CCYY-MM-DDThh:mm:ssi" for dates outside the range 1902-2037
  msd_datetime();
  virtual ~msd_datetime();
  msd_datetime(otl_datetime &t);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
};

class msd_double: public msd_anySimpleType
{ public:
  double msd_item;
  msd_double();
  virtual ~msd_double();
  msd_double(double d);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
}; 


class msd_float: public msd_anySimpleType
{ public: 
  float msd_item;
  msd_float();
  virtual ~msd_float();
  msd_float(float f);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
}; 



class msd_string: public msd_anySimpleType
{ public:
  //char * msd_item;
  msd_string();
  msd_string(char* st);
  msd_string(int size);
  virtual ~msd_string();
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
}; 


class msd_int: public msd_anySimpleType
{ public:
  int msd_item;
  msd_int();
  virtual ~msd_int();
  msd_int(int i);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
}; 

class msd_short: public msd_anySimpleType
{ public:
  short int msd_item;
  msd_short();
  virtual ~msd_short();
  msd_short(short int h);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
}; 

//~~~~~class msd_long_string: public msd_anySimpleType
//~~~~~{ public:
//~~~~~  otl_long_string msd_item;
//~~~~~  msd_long_string();
//~~~~~  msd_long_string(otl_long_string s);
//~~~~~  virtual ~msd_long_string();
//~~~~~  virtual void print(std::ostream &s);
//~~~~~  virtual void setst(msdbStream &s);
//~~~~~  virtual void getst(msdbStream &s);
//~~~~~}; 
//~~~~~class msd_unsignedint: public msd_anySimpleType 
//~~~~~{ public:
//~~~~~  unsigned int msd_item;
//~~~~~  msd_unsignedint();
//~~~~~  virtual ~msd_unsignedint();
//~~~~~  msd_unsignedint(unsigned int ui);
//~~~~~  virtual void print(std::ostream &s);
//~~~~~  virtual void setst(msdbStream &s);
//~~~~~  virtual void getst(msdbStream &s);
//~~~~~}; 
//~~~~~class msd_long: public msd_anySimpleType 
//~~~~~{ public:
//~~~~~  long int msd_item;
//~~~~~  msd_long();
//~~~~~  virtual ~msd_long();
//~~~~~  msd_long(long int li);
//~~~~~  virtual void print(std::ostream &s);
//~~~~~  virtual void setst(msdbStream &s);
//~~~~~  virtual void getst(msdbStream &s);
//~~~~~}; 

class msd_array: public msd_anyType
{ public:
  msd_anyType **msd_ptr;
  int msd_size;
  msd_array();
  virtual ~msd_array();
  msd_array(int n);
  virtual msd_anyType*& operator[](int i);
  virtual void print(std::ostream &s);
  virtual void setst(msdbStream &s);
  virtual void getst(msdbStream &s);
  virtual let getval();
};


class MSDItemList;
class MSDItemInfo;
class MSDItem
{
 MSDItemInfo * item_data; 
 MSDItem * next;
 public:
         MSDItem(MSDItemInfo * new_item)
                            {  next = NULL;
                           item_data = new_item;};
 friend class MSDItemList;
};
class MSDItemList
{          
   MSDItem *start;
   MSDItem *end_of_list;
public:
   MSDItemList() {start = NULL;};
   void add_item(MSDItemInfo *new_item);
   void get_iteminfo(char * item_name);
};
class MSDItemInfo
{ 
  public:
  char name[32];
  char description[32];
  char comment[256];
  MSDItemList * sublist1;
  MSDItemList * sublist2;
  MSDItemList * sublist3;
  
          void display(void);
};

template <class T>

class DBBin {
        private:
                char FileName[32];
                FILE* fp;
        public:
                DBBin() {
                        strcpy(FileName,"");
                }
                DBBin(const char* fnm) {
                        strcpy(FileName,fnm);
                }
                void SetFileName(const char* fnm) {
                        strcpy(FileName,fnm);
                }
                bool Open() {
                        fp = fopen(FileName,"rb+");
                        if(fp == NULL) {
                                fp = fopen(FileName,"wb+");
                        }
                        if(fp == NULL) {
                                return false;
                        }
                        return true;
                }
                bool AddRecord(T& t) {
                        fseek(fp,0,SEEK_END);
                        if(fwrite((char*)&t,sizeof(T),1,fp)) {
                                return true;
                        }else {
                                return false;
                        }
                }
                bool FindRecord(unsigned long index, T& t) {
                        int found;
                        rewind(fp);
                        bool ret = false;
                        unsigned long pos = index * sizeof(T);
                        found = fseek(fp,pos,SEEK_CUR);
                        t.init();
                        if (found == 0)
                        {fread((char*)&t,sizeof(T),1,fp);
                         ret = true;
                        };
                        //T t;
                        //t.init();
                        
                        return ret;
                }
                
                bool FindRecord(const char* on, T& t) {
                        rewind(fp);
                        bool ret = false;
                        //T t;
                        t.init();
                        //t.username = "guest"; 
                        while((fread((char*)&t,sizeof(T),1,fp)) == 1) {
                                if(strcmp(t.name,on) == 0){
                                ret = true;
                                break;}
                                
                        }
                        
                        return ret;
                }

                bool ModifyRecord(T& newT,unsigned long index) {
                        rewind(fp);
                        unsigned long pos = index * sizeof(T);
                        fseek(fp,pos,SEEK_CUR);
                        if(fwrite((char*)&newT,sizeof(T),1,fp)) {
                                return true;
                        }else {
                                return false;
                        }
                }
                bool DeleteRecord(unsigned long index) {
                        rewind(fp);
                        FILE* tmp;
                        char tmp_fnm[36];
                        strcpy(tmp_fnm,"tmp.pln");
                        tmp = fopen(tmp_fnm,"wb");
                        if(tmp == NULL) {
                                return false;
                        }
                        unsigned long idx = 0;
                        T t;
                        //t.init();
                        while((fread((char*)&t,sizeof(T),1,fp)) == 1) {
                                if(idx != index) {
                                        fwrite((char*)&t,sizeof(T),1,tmp);
                                }//else {
                                idx++;
                        }
                        fclose(fp);
                        fclose(tmp);
                        tmp = fopen(tmp_fnm,"rb");
                        fp = fopen(FileName,"wb+");
                        if(fp != NULL) {
                                rewind(fp);
                                rewind(tmp);
                                while((fread((char*)&t,sizeof(T),1,tmp)) == 1) {
                                        fwrite((char*)&t,sizeof(T),1,fp);
                                }
                                fclose(tmp);
                                fclose(fp);
                                fopen(FileName,"rb+");
                                unlink(tmp_fnm);
                                return true;
                        }else {
                                return false;
                        }
                }
                unsigned long GetRecordCount() {
                        fseek(fp,0,SEEK_END);
                        unsigned long len = ftell(fp);
                        unsigned long recs = len / sizeof(T);
                        return recs;
                }
                void Close() {
                        fclose(fp);
                }
                unsigned long GetNextRecordNo() {
                        rewind(fp);
                        unsigned long ret = 0;
                        T t;
                        //t.init();
                        while((fread((char*)&t,sizeof(T),1,fp)) == 1) {
                                if(t.id > ret) {
                                        ret = t.id;
                                }
                        }
                        ret += 1;
                        return ret;
                }
};

//####template <typename T>
//####       inline
//####       char*
//####       to_string(char* buf, T value)
//####       {
//####         unsigned char* u_buf = reinterpret_cast<unsigned char*>(buf);
//####         unsigned char* u_buf0 = u_buf;
//####         *u_buf++ = 0;
//####         if (value != 0) {
//####           if (value < 0) {
//####             *u_buf0 = 128;
//####             value = -value;
//####           }
//####           for(int i=0;i<sizeof(T);i++) {
//####             *u_buf++ = static_cast<unsigned char>(value[i] % 256);
//####             value[i] /= 256;
//####             if (value[i] == '\0') break;
//####           }
//####           *u_buf0 += static_cast<unsigned char>(u_buf - u_buf0);
//####         }
//####         return reinterpret_cast<char*>(u_buf);
//####       }
//####




class msd_xml_element
{ 
 public:
  char * tag;
  char * data;
  msd_xml_element(){};
  ~msd_xml_element(){};
};      

class MSDDataSet {
 public:
  unsigned long id;
  char name[80];
  MSDDataSet();
  ~MSDDataSet();
  void init();
  void clean();
  int getSize() {return size;}
  void addEntity(let);
  void setValue(let, let, let);
  let getValue(let, let);
  void delEntity(let);
  //msd_array* getData(){return pData;}
  //void setData(msd_array * pDataNew){pData = pDataNew;}
 private:
  int size;
  //msd_array * pData;
  let contents;
};




class msdDumpObjects
{public:
 bool msdAddObject(MSDDataSet& obj);
 unsigned long  msdFindObject(const char* obj);
 bool msdEditObject(const char* obj);
 bool msdDelObject(const char* obj);
 MSDDataSet msdGetObject(const char* obj);
 msdDumpObjects();
 ~msdDumpObjects();
};
int  ToUpperStrArray(char* in[]);
void trimspace(char* buffer);
void trimcr(char* buffer);
void removena(char* buffer);
void lcase(char* buffer);
void ucase(char* buffer);
void midcopy(char* from,char* dest,int start_pos,int stop_pos);// middle copy (midstr)
void leftcopy(char* from,char* dest,int pos);// left copy (leftstr)
void rightcopy(char* from,char* dest,int pos);// right copy (rightstr)
bool make_select_count (char* stm,char* countstm);
bool make_select_param (char* stm ,char* paramstm);
int has_integer_name (char* name);
int  StrArrayToListStr (char* strarray[], char liststr[]);
bool isalphanum(const char* str);
bool isnum(const char* str);
bool fileexists(char* fn);
bool ssm_file_completed(char* fn, const char* endstr);
bool lsf_file_completed(char* fn);
void wait(int seconds);
char* getDateTime();
void msdPrompt(char* host);


#endif

---