msd_datatypes.cc

//--------------------------------
// msd_datatypes.cc
//
// Project: PDBe API Framework, EBI 
// Module: Implementation of 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__
#include "msd_datatypes.h"
#endif


msd_anyType::msd_anyType()
{
}
msd_anyType::~msd_anyType()
{
}
msd_anyType*& msd_anyType::operator[](int i)
{ static msd_anyType *p = this; 
  return p;
}

void msd_anyType::print(std::ostream &s)
{}


void msd_anyType::setst(msdbStream &s)
{}


void msd_anyType::getst(msdbStream &s)
{}
let msd_anyType::getval()
{}


msd_anySimpleType::msd_anySimpleType()
{}
msd_anySimpleType::~msd_anySimpleType()
{}
void msd_anySimpleType::print(std::ostream &s) 
{}

void msd_anySimpleType::setst(msdbStream &s)
{}


void msd_anySimpleType::getst(msdbStream &s)
{}
let msd_anySimpleType::getval()
{}


msd_datetime::msd_datetime()
{}
msd_datetime::~msd_datetime()
{}
msd_datetime::msd_datetime(otl_datetime &t)
{ msd_item = t; }

void msd_datetime::print(std::ostream &s) 
{ s << msd_item.year;}
void msd_datetime::setst(msdbStream &s) 
{ s << msd_item; }

void msd_datetime::getst(msdbStream &s)
{ s >> msd_item;
}
let msd_datetime::getval()
{ 
return  msdConst(msd_item.year);
}

msd_double::msd_double()
{ }
msd_double::~msd_double()
{ }
msd_double::msd_double(double d)
{ msd_item = d; }

void msd_double::print(std::ostream &s) 
{ s << msd_item;}
void msd_double::setst(msdbStream &s) 
{ s << msd_item; }

void msd_double::getst(msdbStream &s) 
{ s >> msd_item;
}
let msd_double::getval() 
{ 
return  msdConst(msd_item);
}

msd_float::msd_float()
{ }
msd_float::~msd_float()
{ }
msd_float::msd_float(float f)
{ msd_item = f; }

void msd_float::print(std::ostream &s) 
{ s << msd_item;}
void msd_float::setst(msdbStream &s) 
{ s << msd_item; }

void msd_float::getst(msdbStream &s) 
{ s >> msd_item;
}
let msd_float::getval() 
{ 
return  msdConst(msd_item);
}


msd_string::msd_string()
{}
msd_string::~msd_string()
{if (msd_item)
 free(msd_item);
}

msd_string::msd_string(int size)
{ 
  msd_item=(char*)malloc(size);
 
}

msd_string::msd_string(char* st)
{ 
  msd_item=(char*)malloc(strlen(st)+1);
  sprintf(msd_item,"%s",st);
}

void msd_string::print(std::ostream &s) 
{ s << msd_item;}
void msd_string::setst(msdbStream &s) 
{ s << msd_item; }

void msd_string::getst(msdbStream &s) 
{ s >> msd_item;
}
let msd_string::getval() 
{
return  msdConst(msd_item);
}


msd_int::msd_int()
{ }
msd_int::~msd_int()
{ }
msd_int::msd_int(int i)
{ msd_item = i; }

void msd_int::print(std::ostream &s) 
{ s << msd_item;}
void msd_int::setst(msdbStream &s) 
{ s <<  msd_item; }

void msd_int::getst(msdbStream &s) 
{ s >> msd_item;
}
let msd_int::getval() 
{
return  msdConst(msd_item);
}

msd_short::msd_short()
{ }
msd_short::~msd_short()
{ }
msd_short::msd_short(short int h)
{ msd_item = h; }

void msd_short::print(std::ostream &s) 
{ s << msd_item;}
void msd_short::setst(msdbStream &s) 
{ s <<  msd_item ; }

void msd_short::getst(msdbStream &s)
{ s >> msd_item;
}
let msd_short::getval()
{
return  msdConst(msd_item);
}

msd_array::msd_array()
{ }
msd_array::~msd_array()
{if (msd_ptr)
{for (int i=0;i < msd_size ; i++)
{ free(msd_ptr[i]);
}
} 
}
msd_array::msd_array(int n)
{ msd_size = n;
  msd_ptr = (msd_anyType**)malloc(n*sizeof(msd_anyType*));
}
msd_anyType*& msd_array::operator[](int i)
{ return msd_ptr[i];
}
void msd_array::print(std::ostream &s)
{ for (int i = 0; i < msd_size; i++)
    msd_ptr[i]->print(s);}

void msd_array::setst(msdbStream &s)
{
  for (int i = 0; i < msd_size; i++)
    msd_ptr[i]->setst(s);

}
void msd_array::getst(msdbStream &s) 
{
  for (int i = 0; i < msd_size; i++)
    msd_ptr[i]->getst(s);
 
}

let msd_array::getval() 
{ stringstream arrliststr;
  arrliststr << "(";
  let arrlist = listEM( msdEnd);
  for (int i = 0; i < msd_size; i++){
        arrliststr << " "; 
    arrliststr << msd_ptr[i]->getval();
  }
 arrliststr << ")";
 arrlist = read(arrliststr);
 return arrlist;
}






void MSDItemInfo::display(void)
{
 cout << "MSDItemInfo::display - missing subclass method\n";
}

void MSDItemList::add_item(MSDItemInfo * new_item)
{
MSDItem *temp;

   temp = new MSDItem(new_item);
   if (start == NULL)
      start = end_of_list = temp;
   else {
      end_of_list->next = temp;
      end_of_list = temp;
   }
}




void MSDItemList::get_iteminfo(char * item_name){
 MSDItem *temp;
 int found = 0; 
   temp = start;
   while ((temp != NULL) && !found) 
    {if (!strcmp(temp->item_data->name, item_name)) { 
                        found = 1;
                } else { 
                        temp = temp->next; 
                } 
   }
   if (temp != NULL) {
                  printf("OK");
               // printitem(temp);
        } else { 
                printf("No item by that name exists in the database\n"); 
        } 

}
int ToUpperStrArray(char* in[]){
 int j=0;
 while (in[j]){
   for (int i=0;i<strlen(in[j]);i++){
      in[j][i]=toupper(in[j][i]);}
  j++;
 } 
 return (0);
}
void trimspace(char* buffer)
{
        int len;
        len = strlen(buffer);
        char* ptemp;
        ptemp = new char[len+1];
        strcpy(ptemp,buffer);

        int index = 0;
        for(int z = 0; z < len; z++)
        {
                if(ptemp[z] != ' ')
                {
                        buffer[index] = ptemp[z];
                        index++;
                }
        }
        buffer[index] = '\0';

        delete [] ptemp;
}
void removena(char* buffer)
{
        int len;
        len = strlen(buffer);
        char* ptemp;
        ptemp = new char[len+1];
        strcpy(ptemp,buffer);

        int index = 0;
        for(int z = 0; z < len; z++)
        {
                if(((ptemp[z] >= 'A')&& (ptemp[z] <= 'Z')) ||((ptemp[z] >= 'a')&& (ptemp[z] <= 'z')))
                {
                        buffer[index] = ptemp[z];
                        index++;
                }
        }
        buffer[index] = '\0';

        delete [] ptemp;
}
bool isalphanum(const char* str){
        bool res;
        for(int i = 0; i < strlen(str); i++)
        {
                if(!isalpha(str[i]) && !isdigit(str[i]))
                {
                        res = false;
                }else
                        res = true;
        }
 return res;
}
bool isnum(const char* str){
        bool res;
        for(int i = 0; i < strlen(str); i++)
        {
                if(!isdigit(str[i])) //(str[i] != '.') || !isdigit(str[i]))
                {
                        res = false;
                }else
                        res = true;
        }
 return res;
}
void trimcr(char* buffer)
{
        int len;
        len = strlen(buffer);
        char* ptemp;
        ptemp = new char[len+1];
        strcpy(ptemp,buffer);

        int index = 0;
        for(int z = 0; z < len; z++)
        {
                if(ptemp[z] != '\n')
                {
                        buffer[index] = ptemp[z];
                        index++;
                }
        }
        buffer[index] = '\0';

        delete [] ptemp;
}


// lower case
void lcase(char* buffer)
{
        int len = strlen(buffer);

        for(int i = 0; i < len; i++)
        {
                buffer[i] = tolower(buffer[i]);
        }
}
// upercase
void ucase(char* buffer)
{
        int len = strlen(buffer);

        for(int i = 0; i < len; i++)
        {
                buffer[i] = toupper(buffer[i]);
        }
}

// mid copy
void midcopy(char* from,char* dest,int start_pos, int stop_pos)
{
        int index = 0;
        for(int i = start_pos; i < stop_pos; i++)
        {
                dest[index] = from[i];
                index++;
        }

        dest[index] = '\0';
}
void leftcopy(char* from,char* dest,int pos)
{
        int index = 0;
        for(int i = 0; i < pos; i++)
        {
                dest[index] = from[i];
                index++;
        }
        dest[index] = '\0';
}
// right copy
void rightcopy(char* from,char* dest,int pos)
{
        int index = 0;
        int len = strlen(from);
        for(int i = pos; i < len; i++)
        {
                dest[index] = from[i];
                index++;
        }
        dest[index] = '\0';

}
bool make_select_count (char* stm ,char* countstm){
        bool ret;
        int start,end,index=0;
        size_t len;
        //char * ustm=(char*)malloc(sizeof(stm)+1);
        char * ustm= new char[4096];
        sprintf(ustm,"%s",stm);
        ucase(ustm);
        char * tok = strstr (ustm,"SELECT");
        char * per = strstr (ustm,"FROM");
        if ((tok != NULL) && (per != NULL))
        {start=per-tok;
         end=strlen(stm);
         char* midbuff=new char[4096];//(char*)malloc(sizeof(ustm));
         midcopy(stm,midbuff,start,end);
         char* res=new char[4096]; //(char*)malloc(sizeof(midbuff)+17);
         sprintf(res,"select count(*) %s", midbuff);
         len = strlen(res);
         for(int i = 0; i < len; i++)
         {      countstm[index] = res[i];
                index++;
         }
         countstm[index] = '\0';
         ret = true;
         delete midbuff;
         delete res;
        }else{
         len = strlen(ustm);
         for(int i = 0; i < len; i++)
         {      countstm[index] = ustm[i];
                index++;
         }
         countstm[index] = '\0';
         ret = false;
        }
        delete ustm;
        return ret;
  }

bool make_select_param (char* stm ,char* paramstm){
        bool ret;
        int index=0;
        size_t len;
        char * ustm=new char[4096]; //(char*)malloc(sizeof(stm)+1);
        sprintf(ustm,"%s",stm);
        char * tok = (char*) memchr (ustm,':',strlen(ustm));
        if (tok != NULL)
                {
         len = strlen(ustm);
         for(int i = 0; i < len; i++)
         {
                paramstm[index] = ustm[i];
                index++;
         }
         paramstm[index] = '\0';
         ret = false;
        }else
        {char* res=new char[4096]; // (char*)malloc(sizeof(ustm)+20);
         sprintf(res," %s and :f<int> = 1 ", ustm);
         len = strlen(res);
         for(int i = 0; i < len; i++)
         {
                paramstm[index] = res[i];
                index++;
     }
         paramstm[index] = '\0';
         ret = true;
         delete res;
        }
        delete ustm;
        return ret;
  }
int has_integer_name (char* name){
    int r = 0;
        char * tok;
        char * tok_list[4]={"_ID","SEQ","NUM","SERIAL"};
        char  ustm[64]; //=(char*)malloc(sizeof(name)+1);
        sprintf(ustm,"%s",name);
        ucase(ustm);
        for (int i=0;i<4 ;i++ )
        {tok = strstr (ustm,tok_list[i]);
         if (tok){
          r = 1;
          break;
         }
        }
        //free(ustm);
        return r;
}




int StrArrayToListStr (char* strarray[], char liststr[]){
 char tmp[5];
 int j=1;
 strcpy(tmp, "', '");
 sprintf(liststr,"('%s", strarray[0]);
  while (strarray[j]) //
 {   
   sprintf(liststr, "%s%s%s",liststr,tmp,strarray[j]); 
   j++;
 }
 sprintf(liststr, "%s')",liststr);
 return (0);
}
 bool fileexists(char* fn){
   char filename[256];
   sprintf(filename,"%s", fn);
   bool result;
  fstream file;
  file.open(filename,ios::in);
  if(file.fail())
   result=false;
   else{
   file.close();
   result=true;}
   return result;
 }

 bool ssm_file_completed(char* fn, const char* endstr){
   char filename[256];
   char buffer[32];
   char * pchs;
   sprintf(filename,"%s", fn);
   bool result;
  fstream file;
  file.open(filename,ios::in);
  if(file.fail())
   result=false;
   else{
   file.seekg (32, ios::end);
   file.read (buffer,32);
   pchs = strstr (buffer,endstr); // "</SSMResults>"
   if (pchs != NULL)
    result=true;
   else
    result=false;
   file.close();
   }
   return result;
 }


 bool lsf_file_completed(char* fn){
  int lno=0;
  int got=0;
  fstream file;
  char* filename;
  filename = (char *)malloc(strlen(fn)+1);
  sprintf(filename,"%s", fn);
  bool result=false;
  char * pchs;
  char * linebuf = (char *)malloc(100);
  char * tempbuf = (char *)malloc(100);
  file.open(filename,ios::in);
  if(!file.fail())
  {do
    {file.getline(linebuf, 100);
         if(linebuf != NULL)
         {strcpy(tempbuf, linebuf);
          pchs = strstr (tempbuf, "Sender: LSF System");
          if (pchs != NULL)
          got =1;
         }
          lno++; 
   } while (!file.eof() && (got == 0) && lno < 3);
    if (got == 1){   
      result=true;
        }
  file.close();
  }
   free(filename);
   free(linebuf);
   free(tempbuf);
   return result;
 }



void wait( int seconds )
{clock_t endwait;
  endwait = clock() + seconds * CLOCKS_PER_SEC; // or CLK_TCK 
  while (clock() < endwait) {}
}


char* getDateTime(){
 time_t rawtime;
 struct tm * timeinfo;
 time ( &rawtime );
 timeinfo = localtime(&rawtime);
 return asctime (timeinfo);    
}


void msdPrompt(char* host){
 char prompt[64];
 char dt[32];
 sprintf(dt,"%s", getDateTime());
 trimcr(dt);
 sprintf(prompt,"\n[msdsoap@%s %s]:", host, dt);
 fprintf(stderr, prompt);
}



// MSDDataSet class methods.
// Data Base constructor.
MSDDataSet::MSDDataSet() {size = 0; contents = makeHashTable();}
MSDDataSet::~MSDDataSet() {clrhash(contents); gc(contents);}
void MSDDataSet::init() {size = 0; contents = makeHashTable();}
void MSDDataSet::clean() {clrhash(contents); gc(contents);}
// Add an entity to the Data Base.
void MSDDataSet::addEntity(let entity) {
  if (!gethash(entity, contents)) {
    puthash(entity, contents, 0);
    size++;}}

// Set the value of an attribute for given entity.
void MSDDataSet::setValue(let entity, let attribute, let value) {
  let attributes = gethash(entity, contents);
  let old = assoc(attribute, attributes);
  if (old) rplacd(old, value);
  else {
    push(cons(attribute, value), attributes);
    puthash(entity, contents, attributes);}}

// Return the value of an attribute for given entity.
let MSDDataSet::getValue(let entity, let attribute) {
  return cdr(assoc(attribute, gethash(entity, contents)));}

// Delete an entity to the Data Base.
void MSDDataSet::delEntity(let entity) {
  if (!gethash(entity, contents)) {
    remhash(entity, contents);
    size--;}}

msdDumpObjects::msdDumpObjects(){}

msdDumpObjects::~msdDumpObjects(){}

bool msdDumpObjects::msdAddObject(MSDDataSet& obj){
 bool res;
 DBBin <MSDDataSet> dbb("msdsoap.dmp");
 dbb.Open();
 MSDDataSet cobj= MSDDataSet();
 if (!dbb.FindRecord(obj.name, cobj))
 {fprintf (stderr, "\nAdding obj: %s.", obj.name);
  obj.id = dbb.GetNextRecordNo();
  res = dbb.AddRecord(obj);
 }else{
  cobj.init();
  fprintf (stderr,"Object: %s already exists.", obj.name);
  res = false;
 }
 dbb.Close();
 
 return res;
}

unsigned long msdDumpObjects::msdFindObject(const char* obj){
 unsigned long res;
 DBBin <MSDDataSet> dbb("msdsoap.dmp");
 dbb.Open();
  MSDDataSet cobj;
 if (!dbb.FindRecord(obj, cobj))
 {fprintf (stderr, "\nObject: %s does not exist.", obj);
  res = 2147483647;
 }else
 res = cobj.id;
 dbb.Close();
 return res;
}


MSDDataSet msdDumpObjects::msdGetObject(const char* obj){

 DBBin <MSDDataSet> dbb("msdsoap.dmp");
 dbb.Open();
 MSDDataSet cobj = MSDDataSet();
 if (!dbb.FindRecord(obj, cobj))
 {fprintf (stderr, "\nObject: %s does not exist.", obj);
  dbb.Close();
  cobj.init();
  return cobj;
 }else{
 fprintf (stderr, "\nObject: %s found.", obj);
 dbb.Close();
 cobj.init();
 return cobj;
 }
}


bool msdDumpObjects::msdEditObject(const char* obj){

 bool res;
 unsigned long idx = msdDumpObjects::msdFindObject(obj); 
 if ( idx != 2147483647)
 {DBBin <MSDDataSet> dbb("msdsoap.dmp");
  dbb.Open();
  
  MSDDataSet eobj;
  eobj.id=idx;
  res = dbb.ModifyRecord(eobj, idx-1);
  dbb.Close();
 }else{
  res =  false;
 }
  return res;
 }



bool msdDumpObjects::msdDelObject(const char* obj){
 bool res;
 DBBin <MSDDataSet> dbb("msdsoap.dmp");
 dbb.Open();
  MSDDataSet cobj;
 if (!dbb.FindRecord(obj, cobj))
 {fprintf (stderr, "\nObject: %s does not exist.", obj);
  return false;
 }else{
  res =  dbb.DeleteRecord(cobj.id - 1);
 }
 dbb.Close();
 return res;
}

---