source: trunk/gsdl/src/library/gdbmclass.cpp@ 22

#include "text_t.h"
#include "gdbmclass.h"
#include <ctype.h>

#ifndef USE_OBJECTSPACE
#  include <algorithm>
#else
#  include <ospace\std\algorithm>
#endif


void gdbm_info::clear () {
  d = 0;
  t.clear();
  p.clear();
  x.clear();
  c.clear();
  j.clear();
  o.clear();
  a.clear();
}

// checks if key is present in infodb.
// returns 1 on success 0 on failure
int gdbmclass::exists (text_t key, text_t collection) {

  datum key_data;
  datum return_data;

  // try to open the database if it's not already open
  if (!open_database(collection)) {
    if (logout != NULL) (*logout) << "gdbmclass: can't open database\n"; 
    return 0;
  }
  
  // sanity check
  if (gdbm_file == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: failed sanity check\n";    
    return 0;
  }

  char *db_key = key.getcstr();

  if (db_key == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: failed sanity check\n";
    return 0;
  }

  key_data.dptr = db_key;
  key_data.dsize = strlen (db_key);
  return_data = gdbm_fetch (gdbm_file, key_data);
  delete db_key;
  db_key = NULL;

  if (return_data.dptr == NULL) {
    if (logout != NULL) {
      (*logout) << "gdbmclass: null data pointer\n";
      outconvertclass text_t2ascii;
      (*logout) << text_t2ascii << "gdbmclass: key was \"" << key << "\"\n";
    }
    return 0;
  }
  free (return_data.dptr);
  return 1;
}


// returns 0 on success, -1 on failure
// key and collection aren't references as they might be aliases to
// something in info
int gdbmclass::getinfo (text_t key, text_t collection, gdbm_info &info) {

  info.clear (); // reset info
  
  datum key_data;
  datum return_data;
  char ikey[256];
  char ivalue[16384];
  int pos = 0;

  // try to open the database if it's not already open
  if (!open_database(collection)) {
    if (logout != NULL) (*logout) << "gdbmclass: can't open database\n"; 
    return -1;
  }
  
  // sanity check
  if (gdbm_file == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: failed sanity check\n";    
    return -1;
  }

  char *db_key = key.getcstr();

  if (db_key == NULL) {
    if (logout != NULL) (*logout) << "gdbmclass: failed sanity check\n";
    return -1;
  }

  key_data.dptr = db_key;
  key_data.dsize = strlen (db_key);
  return_data = gdbm_fetch (gdbm_file, key_data);
  delete db_key;
  db_key = NULL;

  if (return_data.dptr == NULL) {
    if (logout != NULL) {
      (*logout) << "gdbmclass: null data pointer\n";
      outconvertclass text_t2ascii;
      (*logout) << text_t2ascii << "gdbmclass: key was \"" << key << "\"\n";
    }
    return -1;
  }
  
  while ((pos = get_infoline(return_data.dptr, return_data.dsize, 
                 pos, ikey, ivalue)) >= 0) {

    if (strcmp (ikey, "d") == 0) {
      info.d = atoi(ivalue);
      
    } else if (strcmp (ikey, "p") == 0) {
      info.p = ivalue;

    } else if (strcmp (ikey, "t") == 0) {
      info.t = ivalue;
      
    } else if (strcmp (ikey, "x") == 0) {
      info.x = ivalue;
      
    } else if (strcmp (ikey, "c") == 0) {
      info.c = ivalue;
      
    } else if (strcmp (ikey, "j") == 0) {
      info.j = ivalue;

    } else if (strcmp (ikey, "o") == 0) {
      info.o = ivalue;

    } else if (strcmp (ikey, "a") == 0) {
      info.a = ivalue;
    }
  }
  
  free (return_data.dptr);
  
  return 0;
}

void gdbmclass::setgdbmhome (const text_t &thegdbmhome)
{
  gdbmhome = thegdbmhome;
}

// parses a line of the form <key>value\n
// returns next position, -1 if there was nothing left to process
// in the string, -2 if there was an error
int gdbmclass::get_infoline (char *str, int len, int pos, char *key, char *value) {
  int keylen = 0;
  int valuelen = 0;
  
  key[0] = '\0';
  value[0] = '\0';
  
  // ignore white space
  while (pos < len && isspace(str[pos])) pos++;
  
  // get the '<'
  if (pos >= len) return -1;
  if (str[pos] != '<') return -2;
  pos++;
  
  // get the key
  while (pos < len && str[pos] != '>')
    key[keylen++] = str[pos++];
  
  key[keylen] = '\0';
  
  // get the '>'
  if (pos >= len || str[pos] != '>') return -2;
  pos++;
  
  // get the value
  while (pos < len && str[pos] != '\n') 
    value[valuelen++] = str[pos++];
  
  value[valuelen] = '\0';
  
  return pos; 
}


// returns 0 if failed, 1 if opened
int gdbmclass::open_database (const text_t &collection) {
  text_t data_location, text_dir;
  int block_size = 0;
  
  if (gdbm_file != NULL) {
    if (collection != gdbm_open_name) {
      close_database();
    }
  }
  if (gdbm_file == NULL) {
    gdbm_open_name = collection;
    gettextsuffix (collection, text_dir);

#ifdef __WIN32__
    data_location = gdbmhome + "\\" + text_dir;
#else
    data_location = gdbmhome + "/" + text_dir;
#endif
        
#ifdef _LITTLE_ENDIAN
    data_location += ".ldb"; // little endian version of the gdbm database
#else
    data_location += ".bdb"; // big endian version on the gdbm database
#endif
    char *namebuffer = data_location.getcstr(); 
    gdbm_file = gdbm_open (namebuffer, block_size, GDBM_READER, 00664, NULL);
    delete namebuffer;
  }
  return (gdbm_file != NULL);
}


void gdbmclass::close_database () {
  
  if (gdbm_file == NULL) return;
  
  gdbm_close (gdbm_file);
  gdbm_file = NULL;
}



// a few useful functions

//////////////////////////////////////////////////////////////////////////////////////////
// functions for testing classification strings


// returns 1 if targetdoc is top level of a book (i.e. =~ /B\.\d+$/) - otherwise 0;
int is_top_level (const text_t &targetdoc) {

  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();

  // look for the 'B'
  here = findchar (here, end, 'B');

  // there must be exactly one dot after the 'B'
  if ((here != end) && (countchar (here, end, '.') == 1))
    return 1;

  return 0;
}

// returns 1 if targetdoc is any level of a book (i.e. contains 'B') - otherwise 0 
int is_book (const text_t &targetdoc) {

  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();
  
  here = findchar (here, end, 'B');
  if (here != end) return 1;
  return 0;
}

// returns (in book_top) the top level of the book in targetdoc 
void get_book_top (const text_t &targetdoc, text_t &book_top) {

  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();

  book_top.clear();

  // look for the 'B'
  here = findchar (here, end, 'B');

  // copy up to the second '.'
  int founddot = 0;
  while (here != end) {
    if (*here == '.') {
      if (founddot) return;
      founddot = 1;
    }
    book_top.push_back(*here);
    here++;
  }
}   

// returns (in book) the book section part of the classification
// contained in targetdoc
void get_book (const text_t &targetdoc, text_t &book) {

  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();
  
  book.clear ();

  // look for the 'B'
  here = findchar (here, end, 'B');

  // copy the rest of the string
  while (here != end) {
    book.push_back(*here);
    here ++;
  }
}

// get_parent_section removes the last part from section (i.e.=~ s/\.\d+$//)  
void get_parent_section (text_t &section) {
  int founddot = 0;
  text_t::iterator end;
  while (!founddot && !section.empty()) {
    end = section.end();
    end --;
    if (*end == '.') founddot = 1;
    section.pop_back();
  }
}

// same as above but also returns ths child section that's removed
void get_parent_section (text_t &parentsection, text_t &childsection) {
 int founddot = 0;
 text_t tmp;
 childsection.clear();
  text_t::iterator end;
  while (!founddot && !parentsection.empty()) {
    end = parentsection.end();
    end --;
    if (*end == '.') founddot = 1;
    else tmp.push_back(*end); childsection = tmp + childsection; tmp.clear();
    parentsection.pop_back();
  }
}

// count_dots returns the number of dots ('.') there are
// in a range of a targetdoc string
int count_dots(text_t::const_iterator first, text_t::const_iterator last) {
  return countchar (first, last, '.');
}

int count_dots (const text_t &targetdoc) {
  return count_dots(targetdoc.begin(), targetdoc.end());
}

// returns 1 if targetdoc is a first level descendant
// (i.e. B.n.1, B.n.1.1, B.n.1.1.1 etc.) - otherwise 0
int is_section_top(const text_t &targetdoc) {
  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();
  
  // look for the 'B'
  here = findchar (here, end, 'B');
  here = findchar (here, end, '.');
  if (here != end) here++; // skip over the '.'
  here = findchar (here, end, '.');

  // make sure that all '.' are followed by a '1'
  while (here != end) {
    if (*here != '.') return 0;
    here ++;

    if (here != end) {
      if (*here != '1') return 0;
      here ++;
    }
  }
  return 1;
}

// seperate_parts seperates targetdoc into its classification and booksection
// if classification isn't supplied it gets the first classification for the 
// book from the gdbm
// if booksection doesn't exist it remains blank
void seperate_parts(const text_t &targetdoc, gdbmclass &gdbm, const text_t &collection, 
            text_t &classification, text_t &booksection) {
  
  split_targetdoc (targetdoc, classification, booksection);

  if (classification.empty()) {
    // no classification included so get first one for this book
    gdbm_info info;
    text_t book_top;
    vector<text_t> classarray;
    get_book_top (targetdoc, book_top);
    gdbm.getinfo(book_top, collection, info);
    splitstring (info.x, classarray);
    if (!classarray.empty()) classification = classarray[0];
    else classification = "C.1";
  }
}

// split_targetdoc splits up a string containing a classification
// and book (or one or the other)
void split_targetdoc(const text_t &targetdoc, text_t &classification, 
             text_t &booksection) {
  
  classification.clear ();
  booksection.clear();

  text_t::const_iterator here = targetdoc.begin();
  text_t::const_iterator end = targetdoc.end();

  // copy everything up to the first 'B'
  while (here != end) {
    if (*here == 'B') break;
    classification.push_back(*here);
    here++;
  }

  // remove middle '.'
  if (!classification.empty() && 
      classification[classification.size()-1] == '.') 
    classification.pop_back();

  // copy the rest of the string
  while (here != end) {
    booksection.push_back(*here);
    here++;
  }
}

// splitstring splits a colon seperated string into an array
void splitstring (const text_t &string, vector<text_t> &array) {
  splitchar (string.begin(), string.end(), ':', array);
}

// get_parents returns the parents array containing all the parents of the
// document specified by classification and booksection
void get_parents (const text_t &targetdoc, vector<text_t> &parents)
{
  text_t::const_iterator here = targetdoc.begin ();
  text_t::const_iterator end = targetdoc.end ();

  text_t currentparent;
  text_t newsuffixpart;
  text_t newsuffix;
  bool first = true;
  while (here != end)
    {
      // if there is a newsuffix add it to the current parent
      // and add that parent to the parents vector
      if (!newsuffix.empty())
    {
      currentparent += newsuffix;
      parents.push_back (currentparent);
    }
      
      // keep getting suffixes until one is found which starts with
      // a number
      newsuffix.clear();
      do 
    {
      here = getdelimitstr (here, end, '.', newsuffixpart);
      if (!first) newsuffix.push_back ('.');
      first = false;
      newsuffix += newsuffixpart;
    } 
      while ((here != end) && !newsuffixpart.empty() && 
         (newsuffixpart[0] < '0' || newsuffixpart[0] > '9'));
    }
}


// get_siblings returns the siblings array containing all the siblings of the current
// classification or booksection
void get_siblings (const text_t &classification, const text_t &booksection, 
           gdbmclass &gdbm, const text_t &collection, 
           vector<text_t> &siblings) {
  
  gdbm_info info;
  
  if (booksection.empty() &&  classification.size() == 1) {
    // top level classification has no siblings
    return;

  } else if (booksection.empty()) {
    // get classification siblings
    gdbm.getinfo(classification, collection, info);
    gdbm.getinfo(info.p, collection, info); // info is now parent info
    splitstring(info.c, siblings);
    return;

  } else {
    // get book section siblings
    if (is_top_level(booksection)) {
      // top level of book so siblings are children of classification
      gdbm.getinfo(classification, collection, info);
      splitstring(info.c, siblings);

      // add classifications to book sections
      for (unsigned int i = 0; i < siblings.size(); i++) {
    if (is_book(siblings[i])) siblings[i] = classification + "." + siblings[i];
      } 

    } else {
      // siblings come from immediate parent
      gdbm.getinfo(booksection, collection, info);
      gdbm.getinfo(info.p, collection, info); // info is now parent info
      splitstring(info.c, siblings);

      // add classifications to book sections
      for (unsigned int i = 0; i < siblings.size(); i++) {
    if (is_book(siblings[i])) siblings[i] = classification + "." + siblings[i];
      } 
    }
  }
}

// compares section 1 and section 2 and returns 1 if section2 belongs to 
// the same chapter as section1 (i.e. is sibling of or child of or child of sibling) 
int are_same_chapter(text_t section1, text_t section2)
{
  get_parent_section(section1);

  while (!section2.empty()) {
    get_parent_section(section2);
    if (section2 == section1) return 1;
  }
  return 0;
}

// get_first_section gets the first section from a colon separated
// list (instring)
void get_first_section(const text_t &instring, text_t &returnstring) {

  returnstring.clear();
  
  text_t::const_iterator here = instring.begin();
  text_t::const_iterator end = instring.end();
  
  while (here != end) {
    if (*here == ':') return;
    returnstring.push_back(*here);
    here ++;
  }
}


// removes html tags from string - everything after < will be removed
// if < occurs without >
void remove_tags (text_t &text) 
{
  text_t::const_iterator here = text.begin ();
  text_t::const_iterator end = text.end ();
  int found = 0;
  text_t tmp;

  while (here != end) {
    if (*here == '<') {found = 1; here ++; continue;}
    if (*here == '>') {found = 0; here ++; continue;}

    if (!found) tmp.push_back(*here);
    here ++;
  }
  text = tmp;
}

// checks text to see if it is a number (i.e. contains only 0-9)
// returns 1 if true, 0 if false
int is_number (text_t &text) {

  text_t::const_iterator here = text.begin();
  text_t::const_iterator end = text.end();

  while (here != end) {
    if ((*here!='0') && (*here!='1') && (*here!='2') &&
    (*here!='3') && (*here!='4') && (*here!='5') &&
    (*here!='6') && (*here!='7') && (*here!='8') &&
    (*here!='9')) return 0;
    here ++;
  }
  return 1;
}

// functions related to sorting

// returns whatever comes after ':#:' in str
// -- this is a nasty hack that I'm sure Rodger will want to change ;-)
text_t get_section_str(const text_t &str) {

  text_t ret;
  int found = 0;

  text_t::const_iterator here = str.begin();
  text_t::const_iterator end = str.end();

  while (here != end) {
    if (found) {
      ret.push_back(*here);
    } else {
      here = findchar (here, end, ':');
      if ((*(here+1) == '#') && (*(here+2) == ':')) {
    found = 1;
    here = here+2;
      }
    }
    here ++;
  }
  return ret;
}

// removes leading spaces and leading 'the' 'a' and 'an' 
// from string
void alphabetize_string_english (text_t &text) {
  
  if (text.empty()) return;

  text_t firstword;
  char *word;

  text_t::iterator here = text.begin();
  text_t::const_iterator end = text.end();

  if ((*here != ' ') && (*here != 'a') && (*here != 'A') &&
      (*here != 't') && (*here != 'T')) return;

  int foundchar = 0;
  while (here != end) {
    if (*here == ' ' && !foundchar) {here ++; continue;}
    if (*here == ' ' && foundchar) {
      text.erase(text.begin(), (here+1));
      break;
    }
    foundchar ++;
    if (foundchar == 1) {
      getdelimitstr (here, end, ' ', firstword);
      word = firstword.getcstr();
      if ((_stricmp(word, "the") != 0) && (_stricmp(word, "a") != 0) &&
      (_stricmp(word, "an") != 0)) break;
    }
    here ++;
  }
  delete word;
}

// removes leading space, puts last name before 
// any preceeding names
void alphabetize_string_name (text_t &text) {
  
  if (text.empty()) return;
  
  text_t lastname;
  char *lname;
  vector<text_t> words;
  splitchar (text.begin(), text.end(), ' ', words);
  lastname = words.back();
  words.pop_back();
  lname = lastname.getcstr();
  
  while ((_stricmp(lname, "jnr") == 0) || (_stricmp(lname, "snr") == 0) ||
     (_stricmp(lname, "esq") == 0)) {
    lastname = words.back();
    words.pop_back();
    lname = lastname.getcstr();
  }

  text.clear();
  joinchar (words, ' ', text);
  text = lastname + text;
}

char ** string_add (char **array, int *len, char *str) {
  char **ret;

  ret = (char**)realloc(array, (*len+1)*sizeof(char*));
  ret[*len] = (char*)strdup(str);
  (*len) ++;

  return ret;
}

void string_sort (char **array, int len) {
  qsort((void*)array, (unsigned int)(len), sizeof(char*), compare_str);
}

static int compare_str (const void *e1, const void *e2) {
  return _stricmp(*((char**)e1), *((char**)e2));
}

void string_free(char **array, int len) {
  for (int i = 0; i < len; i++)
    free (array[i]);
  free (array);
}