source: tags/0.55/tmp/gdbm_pool.cpp @ 9

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include "gdbm_pool.h"
#include "gdbm.h"
#include <string.h>
#include <stdlib.h>
#include "utils.h"

gdbm_pool::gdbm_pool()
{
  this->statuskey = "status";
  this->genkey(this->zerokey,(intkeytype)0);
  this->file_name = 0;
}

gdbm_pool::~gdbm_pool()
{
  if (this->file_name)
    free(this->file_name);
}

#if 0
void gdbm_pool::genkey(charkeytype key,const intkeytype n)
{
  std::ostringstream s;
  s << std::setfill('0');
  s << std::setw(keylen-1) << n << '\0';
  strncpy(key,s.str().c_str(),this->keylen);
}

#endif
void gdbm_pool::genkey(charkeytype &key,const charkeytype n)
{
  key = n;
}

void gdbm_pool::set_file_name(std::string filename)
{
  this->file_name = strdup(filename.c_str());
}
std::string gdbm_pool::get_file_name(void)
{
  std::string s(this->file_name);
  return s;
}

int gdbm_pool::create_db(void)
{
  if (this->file_name == 0)
    return NOFILENAME;

  dbf = gdbm_open(this->file_name,0,GDBM_NEWDB|this->sync,0644,0);

  if (dbf == 0)
    return this->OPENERROR;

  genkey(zero.count,this->zerokey);
  genkey(zero.next,this->zerokey);
  genkey(zero.last,this->zerokey);
  genkey(zero.first,this->zerokey);

  int rc = put_zero();

  if (rc != 0)
  {
    this->close_db();
    return this->STOREERROR;
  }
  //this->close_db();
  return 0;
}

int gdbm_pool::add_line(std::string line)
{

  int rc = 0;
  //rc = this->open_db('w');
  if (rc != 0)
    return rc;
  rc = get_zero();
  if (rc != 0)
    goto byebye;

  intkeytype last,recordnum;

  //stsd::istringstream(this->zero.last) >> last;
  last = zero.last;
  recordnum = last + 1; // the number of the record to store

  // modify last record, only if last != 0

  if (last != 0)
  {
    datarecord lastrecord;
    rc = this->get_record(lastrecord,zero.last);
    if (rc !=0)
      goto byebye;
    this->genkey(lastrecord.next,recordnum);
    rc = this->put_record(lastrecord,this->zero.last);
    std::cerr << "WTD: lastrecord:  " << zero.last << ":"<< lastrecord.prev << " " << lastrecord.next <<
    " " << lastrecord.retrieved << std::endl;
    if (rc !=0)
      goto byebye;
  }
  // modify zero record
  this->genkey(this->zero.last,recordnum);
  this->genkey(this->zero.count,recordnum);
  intkeytype first;

  //std::istringstream(this->zero.first) >> first;
  first = zero.first;
  if (first == 0)
    this->genkey(this->zero.first,recordnum);
  intkeytype next;
  //std::istringstream(this->zero.next) >> next;
  next = zero.next;
  if (next == 0)
    this->genkey(this->zero.next,recordnum);
  rc = this->put_zero();
  if (rc != 0)
  {
    rc = this->STOREERROR;
    goto byebye;
  }

  // now put the line in the database
  struct datarecord data;
  genkey(data.prev,last);
  genkey(data.next,this->zerokey);
  genkey(data.retrieved,this->zerokey);

  strncpy(data.value,line.c_str(),maxvallen-1);
  data.value[maxvallen-1] = 0;

  charkeytype k;
  this->genkey(k,recordnum);

    std::cerr << "WTD: datarecord:  " << k << ":" << data.prev << " " << data.next <<
    " " << data.retrieved << std::endl;
  rc = put_record(data,k);

  if (rc != 0)
  {
    rc = this->STOREERROR;
    goto byebye;
  }

byebye:
  //this->close_db();
  return rc;
}

int gdbm_pool::get_zero(void)
{

  datum key, content;
  // create record with key zero
  key.dptr = &this->zerokey;
  key.dsize = this->keylen;

  content=gdbm_fetch(this->dbf,key);
  if (content.dptr == 0)
    return FETCHERROR;
  this->zero = *(struct zerorecord *) content.dptr;
  free(content.dptr);
  return 0;
}

int gdbm_pool::put_zero(void)
{
  datum key, content;
  charkeytype k;
  genkey(k,this->zerokey);
  key.dptr = &k;
  key.dsize = keylen;
  content.dptr = &zero;
  content.dsize = sizeof(zero);
  return gdbm_store(this->dbf, key, content, GDBM_REPLACE);
}

int gdbm_pool::open_db(char rw)
{
  if (this->file_name == 0)
    return this->NOFILENAME;
  switch (rw)
  {
    case 'r':
      do
      {
        dbf = gdbm_open(this->file_name,0,GDBM_READER,0644,0);
        if (dbf == 0)
          usleep(1000);
      }
      while (dbf == 0);
      break;
    case 'w':
      do
      {
        std::cerr << "opening " << this->file_name << std::endl;
        dbf = gdbm_open(this->file_name,0,GDBM_WRCREAT|this->sync,0644,0);
        if (dbf == 0)
          usleep(1000);
      }
      while (dbf == 0);
    break;
    default:
      break;
  }
  return 0;
}

int gdbm_pool::close_db(void)
{
  gdbm_close(this->dbf);
  return 0;
}

int gdbm_pool::get_record(datarecord &r, charkeytype &k)
{
  datum key,content;
  key.dptr = &k;
  key.dsize = keylen;
 
  content=gdbm_fetch(this->dbf,key);
  if (content.dptr == 0)
    return this->FETCHERROR;
  memcpy(&r,content.dptr,content.dsize);
  free(content.dptr);
  return 0;
}

int gdbm_pool::put_record(datarecord &r, charkeytype &k)
{
  datum key, content;
  key.dptr = &k;
  key.dsize = keylen;
  int lr = sizeof(r.value) + 1;
#if 0
  char buffer[sizeof(r.prev)+sizeof(r.next)+sizeof(r.retrieved) + lr];
  int p=0;
  memcpy(&buffer[p],r.prev,sizeof(r.prev));
  p += sizeof(r.prev);
  memcpy(&buffer[p],r.next,sizeof(r.next));
  p += sizeof(r.next);
  memcpy(&buffer[p],r.retrieved,sizeof(r.retrieved));
  p += sizeof(r.retrieved);
  memcpy(&buffer[p],r.value,lr);
  p += lr;
  content.dptr = (char*)buffer;
  content.dsize = p;
#endif
  content.dptr = &r;
  content.dsize = sizeof(r.prev)+ sizeof(r.next)+sizeof(r.retrieved)+lr;
  return gdbm_store(this->dbf, key, content, GDBM_REPLACE);
}

int gdbm_pool::get_line(std::string &line)
{
  int rc;
  rc = this->get_zero();
  if (rc != 0)
    return FETCHERROR;

  struct datarecord r;
  
  intkeytype next;
  //std::istringstream(this->zero.next) >> next;
  next = zero.next;
  if (next == 0)
    return  NOTFOUND;
  this->get_record(r,zero.next);
  std::cerr << "WTD: record: get  " << zero.next << ":" <<r.prev << " " << r.next <<
    " " << r.retrieved << std::endl;

  line = r.value;

  // adjust the 'retrieved' field of r, and write it

  intkeytype retr;
  //std::istringstream(r.retrieved) >> retr;
  retr = r.retrieved;
  genkey(r.retrieved,retr+1);

  rc = this->put_record(r,zero.next);
  if (rc != 0)
    return STOREERROR;

  // adjust the 'next' field of zero. this must be equal
  // to the 'next' field of r

  this->genkey(this->zero.next,r.next);

  this->put_zero();
  std::cerr << "WTD: zero in get_:"
    << zero.next << " " << zero.first << " " <<
      zero.last << " " << zero.count << std::endl;

  std::cerr << "WTD: record:      " << zero.next << ":" <<r.prev << " " << r.next <<
    " " << r.retrieved << std::endl;

  return 0;
}