source: trunk/gsdl/src/recpt/infodbclass.cpp@ 373

/**********************************************************************
 *
 * infodbclass.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: infodbclass.cpp 368 1999-07-11 08:27:52Z rjmcnab $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.1  1999/07/11 08:27:52  rjmcnab
   Moved from src/colservr and added capability to write out data.

   Revision 1.4  1999/05/10 03:43:48  sjboddie
   lots of changes to lots of files - getting document action going

   Revision 1.3  1999/04/30 02:00:46  sjboddie
   lots of stuff to do with getting documentaction working

   Revision 1.2  1999/04/06 22:20:31  rjmcnab
   Got browsefilter working.

   Revision 1.1  1999/03/30 05:10:07  rjmcnab
   Initial revision.

 */


#include "infodbclass.h"
#include "unitool.h"
#include "gsdlunicode.h"
#include "fileutil.h"
#include "OIDtools.h"
  
// constructors
infodbclass::infodbclass () {
}

void infodbclass::setinfo (const text_t &key, const text_t &value) {
  info[key] = value;
}

void infodbclass::setintinfo (const text_t &key, int value) {
  setinfo (key, value);
}

void infodbclass::setcinfo (const text_t &key, unsigned short c) {
  text_t t;
  t.push_back(c);
  setinfo(key,t);
}

text_t *infodbclass::getinfo (const text_t &key) {
  iterator here = info.find (key);
  if (here == info.end()) return NULL;

  return &((*here).second);
}

int infodbclass::getintinfo (const text_t &key) {
  text_t *t = getinfo (key);
  if (t == NULL) return 0;
  return t->getint();
}




// returns true if opened
bool gdbmclass::opendatabase (const text_t &filename, int mode, int num_retrys) {
  text_t data_location;
  int block_size = 512;
  
  if (gdbmfile != NULL) {
    if (openfile == filename) return true;
    else closedatabase ();
  }

  openfile = filename;

  char *namebuffer = filename.getcstr();
  do {
    gdbmfile = gdbm_open (namebuffer, block_size, mode, 00664, NULL);
    num_retrys--;
  } while (num_retrys>0 && gdbmfile==NULL &&
       (gdbm_errno==GDBM_CANT_BE_READER || gdbm_errno==GDBM_CANT_BE_WRITER));
  delete namebuffer;

  if (gdbmfile == NULL && logout != NULL) {
    outconvertclass text_t2ascii;
    (*logout) << text_t2ascii << "database open failed on: " << filename << "\n";
  }

  return (gdbmfile != NULL);
}

void gdbmclass::closedatabase () {
  if (gdbmfile == NULL) return;
  
  gdbm_close (gdbmfile);
  gdbmfile = NULL;
  openfile.clear();
}


// returns true on success
bool gdbmclass::setinfo (const text_t &key, const infodbclass &info) {
  if (gdbmfile == NULL) return false;

  text_t data;

  // get all the keys and values
  infodbclass::const_iterator info_here = info.begin();
  infodbclass::const_iterator info_end = info.end();
  while (info_here != info_end) {
    // add the key
    data.push_back('<');
    text_t::const_iterator subkey_here = (*info_here).first.begin();
    text_t::const_iterator subkey_end = (*info_here).first.end();
    while (subkey_here != subkey_end) {
      if (*subkey_here == '>') {
    data.push_back('\\'); data.push_back('>');
      } else if (*subkey_here == '\n') {
    data.push_back('\\'); data.push_back('n');
      } else if (*subkey_here == '\r') {
    data.push_back('\\'); data.push_back('r');
      } else {
    data.push_back (*subkey_here);
      }
      subkey_here++;
    }
    data.push_back('>');

    // add the value
    text_t::const_iterator subvalue_here = (*info_here).second.begin();
    text_t::const_iterator subvalue_end = (*info_here).second.end();
    while (subvalue_here != subvalue_end) {
      if (*subvalue_here == '>') {
    data.push_back('\\'); data.push_back('>');
      } else if (*subvalue_here == '\n') {
    data.push_back('\\'); data.push_back('n');
      } else if (*subvalue_here == '\r') {
    data.push_back('\\'); data.push_back('r');
      } else {
    data.push_back (*subvalue_here);
      }
      subvalue_here++;
    }
    data.push_back('\n');
    
    info_here++;
  }

  // store the value
  datum key_data;
  datum data_data;

  // get a utf-8 encoded c string of the unicode key
  key_data.dptr = (to_utf8(key)).getcstr();
  if (key_data.dptr == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: out of memory\n";
    return false;
  }
  key_data.dsize = strlen (key_data.dptr);

  data_data.dptr = (to_utf8(data)).getcstr();
  if (data_data.dptr == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: out of memory\n";
    delete key_data.dptr;
  }
  data_data.dsize = strlen (data_data.dptr);

  int ret = gdbm_store (gdbmfile, key_data, data_data, GDBM_REPLACE);
  delete key_data.dptr;
  delete data_data.dptr;

  return (ret == 0);
}



// replaces the .fc, .lc, .pr, .ns and .ps syntax (first child, 
// last child, parent, next sibling, previous sibling) 
// it expects child, parent, etc. to exist if syntax has been used
// so you should test before using
text_t gdbmclass::translate_OID (const text_t &inOID, infodbclass &info) {

  if (inOID.size() < 4) return inOID;
  if (findchar (inOID.begin(), inOID.end(), '.') == inOID.end()) return inOID;

  text_t OID = inOID;
  text_tarray tailarray;
  text_t tail = substr (OID.end()-3, OID.end());
  while (tail == ".fc" || tail == ".lc" || tail == ".pr" || 
     tail == ".ns" || tail == ".ps") {
    tailarray.push_back(tail);
    OID.erase (OID.end()-3, OID.end());
    tail = substr (OID.end()-3, OID.end());
  }

  if (!tailarray.size()) return inOID;
  text_tarray::const_iterator begin = tailarray.begin();
  text_tarray::const_iterator here = tailarray.end() - 1;

  while (here >= begin) {

    if (*here == ".fc")
      get_first_child (OID, info);
    else if (*here == ".lc")
      get_last_child (OID, info);
    else if (*here == ".pr")
      OID = get_parent (OID);
    else if (*here == ".ns")
      get_next_sibling (OID, info);
    else if (*here == ".ps")
      get_previous_sibling (OID, info);
    
    here --;
  }
  return OID;
}

void gdbmclass::get_first_child (text_t &OID, infodbclass &info) {

  text_t firstchild;
  if (getinfo (OID, info)) {
    text_t &contains = info["contains"];
    if (!contains.empty()) {
      text_t parent = OID;
      getdelimitstr (contains.begin(), contains.end(), ';', firstchild);
      if (firstchild.empty()) OID = contains;
      else OID = firstchild;
      if (*(OID.begin()) == '"') translate_parent (OID, parent);
    }
  }
}

void gdbmclass::get_last_child (text_t &OID, infodbclass &info) {

  text_tarray children;
  if (getinfo (OID, info)) {
    text_t &contains = info["contains"];
    if (!contains.empty()) {
      text_t parent = OID;
      splitchar (contains.begin(), contains.end(), ';', children);
      OID = children.back();
      if (*(OID.begin()) == '"') translate_parent (OID, parent);
    }
  }
}
  
void gdbmclass::get_next_sibling (text_t &OID, infodbclass &info) {

  text_tarray siblings;
  text_t parent = get_parent (OID);
         
  if (getinfo (parent, info)) {
    text_t &contains = info["contains"];
    if (!contains.empty()) {
      splitchar (contains.begin(), contains.end(), ';', siblings);
      text_tarray::const_iterator here = siblings.begin();
      text_tarray::const_iterator end = siblings.end();
      text_t shrunk_OID = OID;
      shrink_parent (shrunk_OID);
      while (here != end) {
    if (*here == shrunk_OID && (here+1 != end)) {
      OID = *(here+1);
      if (*(OID.begin()) == '"') translate_parent (OID, parent);
      break;
    }
    here ++;
      }
    }
  }
}

void gdbmclass::get_previous_sibling (text_t &OID, infodbclass &info) {

  text_tarray siblings;
  text_t parent = get_parent (OID);

  if (getinfo (parent, info)) {
    text_t &contains = info["contains"];
    if (!contains.empty()) {
      splitchar (contains.begin(), contains.end(), ';', siblings);
      text_tarray::const_iterator here = siblings.begin();
      text_tarray::const_iterator end = siblings.end();
      text_t shrunk_OID = OID;
      shrink_parent (shrunk_OID);
      while (here != end) {
    if (*here == shrunk_OID && (here != siblings.begin())) {
      OID = *(here-1);
      if (*(OID.begin()) == '"') translate_parent (OID, parent);
      break;
    }
    here ++;
      }
    }
  }
}

// returns true on success
bool gdbmclass::getinfo (text_t key, infodbclass &info) {
  text_t data;
  
  if (!getkeydata (key, data)) return false;
  text_t::iterator here = data.begin ();
  text_t::iterator end = data.end ();
  
  text_t ikey, ivalue;
  info.clear (); // reset info
  
  while (getinfoline(here, end, ikey, ivalue)) {
    info[ikey] = ivalue;
  }
  
  return true;
}

// returns true if exists
bool gdbmclass::exists (text_t key) {
  text_t data;
  return getkeydata (key, data);
}

// returns true on success
bool gdbmclass::getkeydata (text_t key, text_t &data) {
  datum key_data;
  datum return_data;

  if (gdbmfile == NULL) return false;
  
  // get a utf-8 encoded c string of the unicode key
  key_data.dptr = (to_utf8(key)).getcstr();
  if (key_data.dptr == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: out of memory\n";
    return false;
  }
  key_data.dsize = strlen (key_data.dptr);
  
  // fetch the result
  return_data = gdbm_fetch (gdbmfile, key_data);
  delete key_data.dptr;
  
  if (return_data.dptr == NULL) return false;

  data.setcarr (return_data.dptr, return_data.dsize);
  free (return_data.dptr);
  data = to_uni(data);  // convert to unicode

  return true;
}

// returns true on success
bool gdbmclass::getinfoline (text_t::iterator &here, text_t::iterator end, 
                 text_t &key, text_t &value) {
  key.clear();
  value.clear();

  // ignore white space
  while (here != end && is_unicode_space (*here)) here++;

  // get the '<'
  if (here == end || *here != '<') return false;
  here++;
  
  // get the key
  while (here != end && *here != '>') {
    key.push_back(*here);
    here++;
  }
  
  // get the '>'
  if (here == end || *here != '>') return false;
  here++;
  
  // get the value
  while (here != end && *here != '\n') {
    if (*here == '\\') { 
      // found escape character
      here++;
      if (here != end) {
    if (*here == 'n') value.push_back ('\n');
    else if (*here == 'r') value.push_back ('\r');
    else value.push_back(*here);
      }

    } else {
      // a normal character
      value.push_back(*here);
    }

    here++;
  }

  return true;
}