/*! @module Public
 */

/*! @module Xapian
 */

#define _GNU_SOURCE

extern "C" {
#include "xapian_config.h"
#include "util.h"

}

#include 

#include 
#include 
#include 
#include 

using namespace Xapian;
using namespace std;

#include 

#define OBJ2_MSET(o) ((struct MSet_struct *)get_storage(o, MSet_program))
#define OBJ2_STEM(o) ((struct Stem_struct *)get_storage(o, Stem_program))
#define OBJ2_STOPPER(o) ((struct Stopper_struct *)get_storage(o, Stopper_program))
#define OBJ2_MSETITERATOR(o) ((struct MSetIterator_struct *)get_storage(o, MSetIterator_program))
#define OBJ2_DOCUMENT(o) ((struct Document_struct *)get_storage(o, Document_program))
#define OBJ2_DATABASE(o) ((struct Database_struct *)get_storage(o, Database_program))
#define OBJ2_QUERY(o) ((struct Query_struct *)get_storage(o, Query_program))


extern "C" struct program * Document_program;
extern "C" struct program * MSetIterator_program;
extern "C" struct program * MSet_program;
extern "C" struct program * Stem_program;
extern "C" typedef struct
{
    Database *database;
} XAPIAN_DATABASE_OBJECT_DATA;

extern "C" typedef struct
{
    Stem *stem;
} XAPIAN_STEM_OBJECT_DATA;

extern "C" typedef struct
{
    QueryParser *parser;
} XAPIAN_QUERYPARSER_OBJECT_DATA;

extern "C" typedef struct
{
    Stopper *stopper;
} XAPIAN_STOPPER_OBJECT_DATA;

extern "C" typedef struct
{
    Enquire *enquire;
} XAPIAN_ENQUIRE_OBJECT_DATA;

extern "C" typedef struct
{
    Query *query;
} XAPIAN_QUERY_OBJECT_DATA;

extern "C" typedef struct
{
    MSet *mset;
} XAPIAN_MSET_OBJECT_DATA;

extern "C" typedef struct
{
    MSetIterator *mseti;
} XAPIAN_MSETITERATOR_OBJECT_DATA;

extern "C" typedef struct
{
    Document *document;
} XAPIAN_DOCUMENT_OBJECT_DATA;


/*! @class Stopper
 */

PIKECLASS Stopper
{
CVAR XAPIAN_STOPPER_OBJECT_DATA   *object_data;

PIKEFUN int `()(string word)
{
  Stopper  *stopper;
  bool i;
  stopper = THIS->object_data->stopper;
  string str((const char *)word->str, (size_t)word->len);

  i = (*stopper)(str);  

  push_int(i?1:0);
}

PIKEFUN string get_description()
{
  Stopper  *stopper;
  stopper = THIS->object_data->stopper;

  string str = stopper->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_STOPPER_OBJECT_DATA * dta = 
	(XAPIAN_STOPPER_OBJECT_DATA*)malloc(sizeof(XAPIAN_STOPPER_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->stopper = NULL;
    THIS->object_data = dta;
}

PIKEFUN void destroy()
{

    Stopper  *stopper;
    stopper = THIS->object_data->stopper;

    if(stopper) 
    {
     delete stopper;
    }

}

EXIT 
{
  if(THIS->object_data)
  {

    Stopper  *stopper;
    stopper = THIS->object_data->stopper;
    printf("shutting down!\n");
    free(THIS->object_data);
  }
}

}

/*! @endclass
 */

/*! @class SimpleStopper
 */

PIKECLASS SimpleStopper
{
  INHERIT Stopper;

  PIKEFUN void create()
  {
    SimpleStopper * stopper = new SimpleStopper();

    THIS->object_data->stopper = (Stopper*) stopper;
    pop_n_elems(args);
  }

  PIKEFUN void create(array words)
  {
    int i;
    vector v;

    for(i = 0; i < words->size; i++)
    {  
       string str((const char *)(ITEM(words)[i].u.string->str), 
                  (size_t)(ITEM(words)[i].u.string->len));
       v.push_back(str);
    }
    
    SimpleStopper * stopper = new SimpleStopper(v.begin(), v.end());

    THIS_STOPPER->object_data->stopper = (Stopper*) stopper;
    pop_n_elems(args);
  }

  PIKEFUN void add(string word)
  {
    SimpleStopper * stopper;
    string str((const char*)word->str, (size_t)word->len);
    stopper = (SimpleStopper *)THIS_STOPPER->object_data->stopper;
    stopper->add(str);
    pop_stack();
    
  }

  
}

/*! @endclass
 */

/*! @class Stem
 */

PIKECLASS Stem
{
CVAR XAPIAN_STEM_OBJECT_DATA   *object_data;


/*! @decl void create(string language)
 *! @decl void create()
 *!   Creates a new Public.Xapian.Stem object
 *!
 */
PIKEFUN void create(string language)
{
  Stem* stem;
  const string str((const char *)language->str, (size_t)language->len);

  try
  {
    stem = new Stem(str);
  }

  catch(InvalidArgumentError &e)
  {
    pop_n_elems(args);
    Pike_error("InvalidArgumentError\n");
  }

  pop_n_elems(args);

  THIS->object_data->stem = stem;
}

PIKEFUN void create()
{
    Stem* stem = new Stem();

    pop_n_elems(args);

    THIS->object_data->stem = stem;
}

PIKEFUN string stem_word(string word)
{
  Stem  *stem;
  string foo;
  const string str((const char *)word->str, (size_t)word->len);
  stem = THIS->object_data->stem;

  foo = stem->stem_word(str);
  pop_n_elems(args);
  push_text(foo.c_str());
}

PIKEFUN string get_description()
{
  Stem  *stem;
  stem = THIS->object_data->stem;

  string str = stem->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_STEM_OBJECT_DATA * dta = 
	(XAPIAN_STEM_OBJECT_DATA*)malloc(sizeof(XAPIAN_STEM_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->stem = NULL;
    THIS->object_data = dta;
}

PIKEFUN void destroy()
{

    Stem  *stem;
    stem = THIS->object_data->stem;

    if(stem) 
    {
     delete stem;
    }

}

EXIT 
{
  if(THIS->object_data)
  {

    Stem  *stem;
    stem = THIS->object_data->stem;
    printf("shutting down!\n");
    free(THIS->object_data);
  }
}

}

/*! @endclass
 */

/*! @class Query 
 */

PIKECLASS Query
{

CVAR XAPIAN_QUERY_OBJECT_DATA   *object_data;


/*! @decl void create()
 *!   Creates a new Public.Xapian.Query object
 *!
 */
PIKEFUN void create()
{
  try
  {
    Query* query = new Query();

    pop_n_elems(args);

    THIS->object_data->query = query;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN void create(string term, int wqf, int pos)
{
  try
  {
	string str((const char *)term->str, (size_t)term->len);
    Query* query = new Query(str, (termcount)wqf, (termpos)pos);

    pop_n_elems(args);

    THIS->object_data->query = query;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN void create(int op, string left, string right)
{
  try
  {
	string lstr((const char *)left->str, (size_t)left->len);
	string rstr((const char *)right->str, (size_t)right->len);
    Query* query = new Query((Xapian::Query::op)op, lstr, rstr);

    pop_n_elems(args);

    THIS->object_data->query = query;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}


PIKEFUN void create(int op, object left, object right)
{
  Query * l;
  Query * r;

  l = OBJ2_QUERY(left)->object_data->query;
  r = OBJ2_QUERY(right)->object_data->query;

  try
  {
    Query* query = new Query((Xapian::Query::op)op, l, r);

    pop_n_elems(args);

    THIS->object_data->query = query;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN void create(int op, object query)
{
  Query * q;

  q = OBJ2_QUERY(query)->object_data->query;

  try
  {
    Query* qe = new Query((Xapian::Query::op)op, *q);

    pop_n_elems(args);

    THIS->object_data->query = qe;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN int get_length()
{
  Query  *query;
  query = THIS->object_data->query;
  termcount i = query->get_length();

  push_int(i);
}

PIKEFUN int empty()
{
  Query  *query;
  query = THIS->object_data->query;
  bool i = query->empty();

  push_int(i?1:0);
}


PIKEFUN string get_description()
{
  Query  *query;
  query = THIS->object_data->query;

  string str = query->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_QUERY_OBJECT_DATA * dta = 
	(XAPIAN_QUERY_OBJECT_DATA*)malloc(sizeof(XAPIAN_QUERY_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->query = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    Query  *query;
    query = THIS->object_data->query;
     if(query) delete query;
    free(THIS->object_data);
  }
}

EXTRA
{
add_integer_constant("OP_AND", Query::OP_AND, 0);
add_integer_constant("OP_OR", Query::OP_OR, 0);
add_integer_constant("OP_AND_NOT", Query::OP_AND_NOT, 0);
add_integer_constant("OP_XOR", Query::OP_XOR, 0);
add_integer_constant("OP_AND_MAYBE", Query::OP_AND_MAYBE, 0);
add_integer_constant("OP_FILTER", Query::OP_FILTER, 0);
add_integer_constant("OP_NEAR", Query::OP_NEAR, 0);
add_integer_constant("OP_PHRASE", Query::OP_PHRASE, 0);
add_integer_constant("OP_ELITE_SET", Query::OP_ELITE_SET, 0);
}

}

/*! @endclass
 */

/*! @class Document 
 */

PIKECLASS Document
{

CVAR XAPIAN_DOCUMENT_OBJECT_DATA   *object_data;


/*! @decl void create()
 *!   Creates a new Public.Xapian.Document object
 *!
 */
PIKEFUN void create()
{
  try
  {
    Document* document = new Document();

    pop_n_elems(args);

    THIS->object_data->document = document;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN void set_data(string data)
{
  Document  *doc;
  doc = THIS->object_data->document;
  string str((const char *)data->str, (size_t)data->len);

  doc->set_data(str);  

  pop_n_elems(args);
}

PIKEFUN void clear_terms()
{
  Document  *doc;
  doc = THIS->object_data->document;

  doc->clear_terms();
}

PIKEFUN void clear_values()
{
  Document  *doc;
  doc = THIS->object_data->document;

  doc->clear_values();
}

PIKEFUN string get_data()
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str = doc->get_data();

  push_text(str.c_str());
}

PIKEFUN string get_description()
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str = doc->get_description();

  push_text(str.c_str());
}

PIKEFUN string get_value(int val)
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str = doc->get_value(val);

  pop_n_elems(args);

  if(str.length())
    push_text(str.c_str());
  else 
    push_int(0);
}

PIKEFUN void remove_value(int val)
{
  Document  *doc;
  doc = THIS->object_data->document;

  doc->remove_value(val);

  pop_n_elems(args);
}

PIKEFUN void add_term(string tname, int termcount)
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str(tname->str, tname->len);
  
  doc->add_term(str, (unsigned int)termcount);

  pop_n_elems(args);
}

PIKEFUN void add_posting(string tname, int termpos, int termcount)
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str(tname->str, tname->len);

  try 
  {  

    doc->add_posting(str, (unsigned int)termpos, (unsigned int)termcount);
  }

  catch(InvalidArgumentError &e)
  {
    pop_n_elems(args);
    Pike_error(e.get_msg().c_str());
  }
  
  pop_n_elems(args);
}

PIKEFUN void remove_term(string tname)
{
  Document  *doc;
  doc = THIS->object_data->document;

  string str(tname->str, tname->len);
  
  try
  {
    doc->remove_term(str);
  }
  catch(InvalidArgumentError &e)
  {
    pop_n_elems(args);
    Pike_error("InvalidArgumentError\n");
  }

  pop_n_elems(args);
}

PIKEFUN void add_value(int valueno, string value)
{
  Document  *doc;
  doc = THIS->object_data->document;
  string str(value->str, value->len);

  doc->add_value(valueno, str);

  pop_n_elems(args);
}

PIKEFUN int termlist_count()
{
  Document  *doc;
  doc = THIS->object_data->document;
  unsigned int i;

  i = doc->termlist_count();

  push_int((INT_TYPE)i);

  return;
}

PIKEFUN int values_count()
{
  Document  *doc;
  doc = THIS->object_data->document;
  unsigned int i;

  i = doc->values_count();

  push_int((INT_TYPE)i);

  return;
}


INIT
{
    XAPIAN_DOCUMENT_OBJECT_DATA * dta = 
	(XAPIAN_DOCUMENT_OBJECT_DATA*)malloc(sizeof(XAPIAN_DOCUMENT_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->document = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    
    Document  *doc;
    doc = THIS->object_data->document;
    if(doc) delete doc;
// hrm... odd.
      free(THIS->object_data);
  }
}

}

/*! @endclass
 */

/*! @class MSetIterator
 */

PIKECLASS MSetIterator
{
  CVAR XAPIAN_MSETITERATOR_OBJECT_DATA   *object_data;

  PIKEFUN object get_document()
  {
    MSetIterator  *mseti;
    Document doc;
    Document *doc2;
    struct object * o;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    doc = mseti->get_document();    
    doc2 = new Document(doc);

    o = fast_clone_object(Document_program);
    OBJ2_DOCUMENT(o)->object_data->document = doc2;

    push_object(o);
  }

  PIKEFUN int get_docid()
  {
    MSetIterator  *mseti;
    docid i;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    i = (*(*mseti));
    push_int((INT_TYPE)i);
  }

  PIKEFUN int get_percent()
  {
    MSetIterator  *mseti;
    docid i;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    i = mseti->get_percent();
    push_int((INT_TYPE)i);
  }
  
  PIKEFUN float get_weight()
  {
    MSetIterator  *mseti;
    weight i;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    i = mseti->get_weight();
    push_float((FLOAT_TYPE)i);
  }
  
  PIKEFUN int get_collapse_count()
  {
    MSetIterator  *mseti;
    docid i;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    i = mseti->get_collapse_count();
    push_int((INT_TYPE)i);
  }
  
  PIKEFUN object next()
  {
    MSetIterator  *mseti;
    mseti = THIS->object_data->mseti;
    MSetIterator *mseti2;

    struct object * o;

    mseti2 = new MSetIterator((*mseti)++);

    o = fast_clone_object(MSetIterator_program);

    OBJ2_MSETITERATOR(o)->object_data->mseti = mseti2;

    push_object(o);    
  }

  PIKEFUN object prev()
  {
    MSetIterator  *mseti;
    mseti = THIS->object_data->mseti;
    MSetIterator *mseti2;

    struct object * o;

    mseti2 = new MSetIterator((*mseti)--);

    o = fast_clone_object(MSetIterator_program);

    OBJ2_MSETITERATOR(o)->object_data->mseti = mseti2;

    push_object(o);    
  }


  PIKEFUN int `==(mixed arg)
  {
    struct object * o;
    MSetIterator  *mseti;
    MSetIterator  *msetb;

    if(arg->type!= T_OBJECT) RETURN(0);
    o = arg->u.object;
    mseti = (MSetIterator*)THIS->object_data->mseti;
    msetb = OBJ2_MSETITERATOR(o)->object_data->mseti;
    if(*mseti == *msetb) RETURN(1);
    else RETURN(0);
  }

INIT
{
    XAPIAN_MSETITERATOR_OBJECT_DATA * dta = 
	(XAPIAN_MSETITERATOR_OBJECT_DATA*)malloc(sizeof(XAPIAN_MSETITERATOR_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->mseti = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    MSetIterator  *mseti;
    mseti = THIS->object_data->mseti;
    if(mseti) delete mseti;
    free(THIS->object_data);
  }
}

}

/*! @endclass
 */


/*! @class MSet 
 */

PIKECLASS MSet
{
CVAR XAPIAN_MSET_OBJECT_DATA *object_data;

INIT
{
    XAPIAN_MSET_OBJECT_DATA * dta = 
	(XAPIAN_MSET_OBJECT_DATA*)malloc(sizeof(XAPIAN_MSET_OBJECT_DATA));
printf("allocated mset data.\n");
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->mset = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    MSet  *mset;
    mset = THIS->object_data->mset;
    if(mset) delete mset;
    free(THIS->object_data);
  }
}


/*! @decl void create()
 *!   Creates a new Public.Xapian.MSet object
 *!
 */
PIKEFUN void create()
{
  try
  {
    MSet * mset = new MSet();

    pop_n_elems(args);

    THIS->object_data->mset = mset;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN object begin()
{
  MSet  *mset;
  mset = THIS->object_data->mset;

  MSetIterator mseti;
  MSetIterator *mseti2;
  struct object * o;

  mseti = mset->begin();

  mseti2 = new MSetIterator(mseti);

  o = fast_clone_object(MSetIterator_program);

  OBJ2_MSETITERATOR(o)->object_data->mseti = mseti2;

  push_object(o);    
}

PIKEFUN object end()
{
  MSet  *mset;
  mset = THIS->object_data->mset;

  MSetIterator mseti;
  MSetIterator *mseti2;
  struct object * o;

  mseti = mset->end();

  mseti2 = new MSetIterator(mseti);

  o = fast_clone_object(MSetIterator_program);

  OBJ2_MSETITERATOR(o)->object_data->mseti = mseti2;

  push_object(o);    
}

PIKEFUN object back()
{
  MSet  *mset;
  mset = THIS->object_data->mset;

  MSetIterator mseti;
  MSetIterator *mseti2;
  struct object * o;

  mseti = mset->back();

  mseti2 = new MSetIterator(mseti);

  o = fast_clone_object(MSetIterator_program);

  OBJ2_MSETITERATOR(o)->object_data->mseti = mseti2;

  push_object(o);    
}

PIKEFUN void fetch()
{
  MSet  *mset;
  mset = THIS->object_data->mset;

  mset->fetch();
}

PIKEFUN int size()
{
  MSet  *mset;
  mset = THIS->object_data->mset;
  doccount i;

  i = mset->size();

  push_int(i);
}

PIKEFUN int get_matches_estimated()
{
  MSet  *mset;
  mset = THIS->object_data->mset;
  doccount i;

  i = mset->get_matches_estimated();

  push_int(i);
}

PIKEFUN int get_matches_upper_bound()
{
  MSet  *mset;
  mset = THIS->object_data->mset;
  doccount i;

  i = mset->get_matches_upper_bound();

  push_int(i);
}

PIKEFUN int get_firstitem()
{
  MSet  *mset;
  mset = THIS->object_data->mset;
  doccount i;

  i = mset->get_firstitem();

  push_int(i);
}

PIKEFUN int get_matches_lower_bound()
{
  MSet  *mset;
  mset = THIS->object_data->mset;
  doccount i;

  i = mset->get_matches_lower_bound();

  push_int(i);
}

PIKEFUN string get_description()
{
  MSet  *mset;
  mset = THIS->object_data->mset;

  string str = mset->get_description();

  push_text(str.c_str());
}

}

/*! @endclass
 */


/*! @class QueryParser
 */

PIKECLASS QueryParser
{
CVAR XAPIAN_QUERYPARSER_OBJECT_DATA   *object_data;

PIKEFUN void create()
{
  QueryParser * parser = new QueryParser();

  THIS->object_data->parser = parser;
}

PIKEFUN void set_stemmer(object stemmer)
{
  QueryParser * parser;
  Stem * s;

  parser = THIS->object_data->parser;
  s = OBJ2_STEM(stemmer)->object_data->stem; 
  parser->set_stemmer((const Stem)*s);

  pop_n_elems(args);
}

PIKEFUN void set_stopper(object stopper)
{
  QueryParser * parser;
  Stopper * s;

  parser = THIS->object_data->parser;
  s = OBJ2_STOPPER(stopper)->object_data->stopper; 
  parser->set_stopper((const Stopper*)s);

  pop_n_elems(args);
}

PIKEFUN void set_default_op(int op)
{
  QueryParser * parser;

  parser = THIS->object_data->parser;

  parser->set_default_op((Query::op)op);
  pop_n_elems(args);
}

PIKEFUN object parse_query(string query, int flags)
{
  Query q;
  Query * q1;
  QueryParser *parser;
  struct object *o;
  parser = THIS->object_data->parser;

  string str((const char *)query->str, (size_t)query->len);

  q = parser->parse_query(str, flags);

  q1 = new Query(q);  

  o = fast_clone_object(Query_program);
  if(!o) Pike_error("unable to clone the query program.\n");
  if(!q1) Pike_error("unable to parse the query.\n");
  OBJ2_QUERY(o)->object_data->query = q1;
  pop_n_elems(args);
  push_object(o);
}

PIKEFUN void add_prefix(string field, string prefix)
{
  QueryParser *parser;
  parser = THIS->object_data->parser;
  
  string f((const char *)field->str, (size_t)field->len);
  string p((const char *)prefix->str, (size_t)prefix->len);

  parser->add_prefix(f, p);
  pop_n_elems(args);
}

PIKEFUN void add_boolean_prefix(string field, string prefix)
{
  QueryParser *parser;
  parser = THIS->object_data->parser;
  
  string f((const char *)field->str, (size_t)field->len);
  string p((const char *)prefix->str, (size_t)prefix->len);

  parser->add_boolean_prefix(f, p);
  pop_n_elems(args);
}

PIKEFUN string get_description()
{
  QueryParser *parser;
  parser = THIS->object_data->parser;

  string str = parser->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_QUERYPARSER_OBJECT_DATA * dta = 
	(XAPIAN_QUERYPARSER_OBJECT_DATA*)malloc(sizeof(XAPIAN_QUERYPARSER_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->parser = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    QueryParser  *parser;
    parser = THIS->object_data->parser;
    if(parser) delete parser;
    free(THIS->object_data);
  }
}

}

/*! @endclass
 */


/*! @class Database
 */

PIKECLASS Database
{
CVAR XAPIAN_DATABASE_OBJECT_DATA   *object_data;

PIKEFUN void create(string path)
{
  string str((const char *)path->str, (size_t)path->len);
  Database * db = new Database(str);
  THIS->object_data->database = db;

  pop_n_elems(args);  
}

PIKEFUN void create()
{
  Database * db = new Database();

  THIS->object_data->database = db;
}

PIKEFUN void reopen()
{
  Database * db = THIS->object_data->database;

  db->reopen();
}

PIKEFUN void keep_alive()
{
  Database * db = THIS->object_data->database;

  db->keep_alive();
}


PIKEFUN int get_doclength(int did)
{
  Database  *db;
  db = THIS->object_data->database;

  doclength i = db->get_doclength((docid)did);
  pop_n_elems(args);
  push_int((INT_TYPE)i);
}

PIKEFUN int get_doccount()
{
  Database  *db;
  db = THIS->object_data->database;

  doccount i = db->get_doccount();
  push_int(i);
}

PIKEFUN int get_avlength()
{
  Database  *db;
  db = THIS->object_data->database;

  doclength i = db->get_avlength();
  push_int((INT_TYPE)i);
}

PIKEFUN int get_lastdocid()
{
  Database  *db;
  db = THIS->object_data->database;

  docid i = db->get_lastdocid();
  push_int((INT_TYPE)i);
}


PIKEFUN int has_positions()
{
  Database  *db;
  db = THIS->object_data->database;

  bool i = db->has_positions();

  push_int(i?1:0);
}

PIKEFUN object get_document(int id)
{
  Database  *db;
  Document doc;
  struct object * obj;
  struct Document_struct * od;

  db = (Database*)THIS->object_data->database;

  try
  {
    doc = db->get_document((docid)id);
  }

  catch(DocNotFoundError &e)
  {
    pop_n_elems(args);
    Pike_error("DocumentNotFoundError\n");
  }

  pop_n_elems(args);

  obj = fast_clone_object(Document_program);

  od = OBJ2_DOCUMENT(obj);

  od->object_data->document = new Document(doc);
    
  push_object(obj);

}

PIKEFUN string get_description()
{
  Database  *db;
  db = THIS->object_data->database;

  string str = db->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_DATABASE_OBJECT_DATA * dta = 
	(XAPIAN_DATABASE_OBJECT_DATA*)malloc(sizeof(XAPIAN_DATABASE_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->database = NULL;
    THIS->object_data = dta;
}

PIKEFUN void destroy()
{
    Database  *db;
    db = THIS->object_data->database;

    if(db) 
    {
      printf("deleting db\n");
      delete db;
    }
}

EXIT 
{
  if(THIS->object_data)
  {   
    Database  *db;
    db = THIS->object_data->database;
    free(THIS->object_data);
  }
}

}

/*! @class WriteableDatabase
 */

PIKECLASS WriteableDatabase
{
INHERIT Database;

/*! @decl void create(string appname)
 *!   Creates a new Public.Xapian.WriteableDatabase object
 *!
 */
PIKEFUN void create(string path, int mode)
{
  try
  {
    const string str((const char *)path->str, (size_t)path->len);

    WritableDatabase* database = new WritableDatabase(str, mode);

    pop_n_elems(args);

    THIS->object_data->database = database;
  }

  catch(DatabaseLockError &e)
  {
    Pike_error("DatabaseLockError\n");
  }
  catch(DatabaseOpeningError &e) 
  {
    Pike_error("DatabaseOpeningError\n");
  }
  catch(InvalidArgumentError &e) 
  {
    Pike_error("InvalidArgumentError\n");
  }
}

PIKEFUN void flush()
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  try
  {
    db->flush();
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseLockError &e)
  {
    Pike_error("DatabaseLockError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }
}

PIKEFUN int add_document(object document)
{
  WritableDatabase  *db;
  Document * doc;
  docid id;

  struct Document_struct * od;

  db = (WritableDatabase*)THIS->object_data->database;
  od = OBJ2_DOCUMENT(document);

  if(!od) Pike_error("Not a Document!\n");

  doc = od->object_data->document;

  try
  {
    id = db->add_document(*doc);
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }

  pop_n_elems(args);
  push_int(id);  
}


PIKEFUN void replace_document(int did, object document)
{
  WritableDatabase  *db;
  Document * doc;
  docid id;

  struct Document_struct * od;

  db = (WritableDatabase*)THIS->object_data->database;
  od = OBJ2_DOCUMENT(document);

  if(!od) Pike_error("Not a Document!\n");

  doc = od->object_data->document;

  try
  {
    db->replace_document((unsigned int)did, *doc);
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }

  pop_n_elems(args);
}

PIKEFUN void replace_document(string term, object document)
{
  WritableDatabase  *db;
  Document * doc;
  docid id;
  string str;
  struct Document_struct * od;

  db = (WritableDatabase*)THIS->object_data->database;
  od = OBJ2_DOCUMENT(document);

  if(!od) Pike_error("Not a Document!\n");


  doc = od->object_data->document;

  try
  {
    const string str((const char *)term->str, (size_t)term->len);
    db->replace_document(str, *doc);
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }

  pop_n_elems(args);
}

PIKEFUN void delete_document(string unique_term)
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;
  const string str((const char *)unique_term->str, (size_t)unique_term->len);
  pop_n_elems(args);

  try
  {
    db->delete_document(str);
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }

}

PIKEFUN void delete_document(int did)
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  try
  {
    db->delete_document((docid)did);
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    pop_n_elems(args);
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    pop_n_elems(args);
    Pike_error("DatabaseError\n");
  }

}


PIKEFUN void begin_transaction(int flushed)
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  try
  {
    db->begin_transaction((bool)flushed);
  }
  catch(Xapian::InvalidOperationError &e)
  {
    pop_n_elems(args);
    Pike_error("InvalidOperationError\n");
  }
  catch(Xapian::UnimplementedError &e)
  {
    pop_n_elems(args);
    Pike_error("UnimplementedError\n");
  }

}

PIKEFUN void commit_transaction()
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  try
  {
    db->commit_transaction();
  }
  catch(Xapian::InvalidOperationError &e)
  {
    Pike_error("InvalidOperationError\n");
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }
  catch(Xapian::UnimplementedError &e)
  {
    Pike_error("UnimplementedError\n");
  }

}

PIKEFUN void cancel_transaction()
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  try
  {
    db->cancel_transaction();
  }
  catch(Xapian::InvalidOperationError &e)
  {
    Pike_error("InvalidOperationError\n");
  }
  catch(Xapian::DatabaseCorruptError &e)
  {
    Pike_error("DatabaseCorruptError\n");
  }
  catch(Xapian::DatabaseError &e)
  {
    Pike_error("DatabaseError\n");
  }
  catch(Xapian::UnimplementedError &e)
  {
    Pike_error("UnimplementedError\n");
  }

}

PIKEFUN string get_description()
{
  WritableDatabase  *db;
  db = (WritableDatabase*)THIS->object_data->database;

  string str = db->get_description();

  push_text(str.c_str());
}

}

/*! @endclass
 */


/*! @class Enquire
 */

PIKECLASS Enquire
{

CVAR XAPIAN_ENQUIRE_OBJECT_DATA   *object_data;


/*! @decl void create()
 *!   Creates a new Public.Xapian.Query object
 *!
 */
PIKEFUN void create(object database)
{
  try
  {
    Database * db;
    db = OBJ2_DATABASE(database)->object_data->database;

    Enquire * enquire = new Enquire(*db);

    pop_n_elems(args);

    THIS->object_data->enquire = enquire;
  }

  catch(...) 
  {
    Pike_error("an error occurred!\n");
  }
}

PIKEFUN void set_query(object query, int termcount)
{
  Query * q;
  Enquire  *enquire;
  enquire = THIS->object_data->enquire;

  q = OBJ2_QUERY(query)->object_data->query;

  enquire->set_query(*q, (Xapian::termcount)termcount);
  pop_n_elems(args);  
}

PIKEFUN object get_query()
{
  Enquire  *enquire;
  Query q;
  Query * q2;
  struct object* r;
  enquire = THIS->object_data->enquire;

  q = enquire->get_query();  

  q2 = new Query(q);  

  r = fast_clone_object(Query_program);

  OBJ2_QUERY(r)->object_data->query = q2;

  push_object(r);
}

PIKEFUN object get_mset(int first, int maxitems, int checkatleast)
{
  Enquire  *enquire;
  enquire = THIS->object_data->enquire;
  MSet mset;
  MSet * mset1;
  struct object * o;

  try
  {
    mset = enquire->get_mset((doccount)first, (doccount)maxitems, 
           (doccount)checkatleast);

  }
  catch(InvalidArgumentError &e)
  {
    pop_n_elems(args);
    Pike_error("InvalidArgumentError\n");
  }  

  pop_n_elems(args);

  o = fast_clone_object(MSet_program);
  mset1 = new MSet(mset);
  OBJ2_MSET(o)->object_data->mset = mset1;

  push_object(o);
}

PIKEFUN string get_description()
{
  Enquire  *enquire;
  enquire = THIS->object_data->enquire;

  string str = enquire->get_description();

  push_text(str.c_str());
}

INIT
{
    XAPIAN_ENQUIRE_OBJECT_DATA * dta = 
	(XAPIAN_ENQUIRE_OBJECT_DATA*)malloc(sizeof(XAPIAN_ENQUIRE_OBJECT_DATA));
    if (!dta)
        Pike_error("init_sample: Out of memory!\n");

    dta->enquire = NULL;
    THIS->object_data = dta;
}

EXIT 
{
  if(THIS->object_data)
  {
    Enquire  *enquire;
    enquire = THIS->object_data->enquire;
    // if(enquire) delete enquire;
    free(THIS->object_data);
  }
}

}

/*! @endclass
 */



INIT
{
}
EXIT
{
}
EXTRA
{
add_integer_constant("DB_CREATE_OR_OPEN", DB_CREATE_OR_OPEN, 0);
add_integer_constant("DB_CREATE", DB_CREATE, 0);
add_integer_constant("DB_CREATE_OR_OVERWRITE", DB_CREATE_OR_OVERWRITE, 0);
add_integer_constant("DB_OPEN", DB_OPEN, 0);
}

/*! @endclass
 */


/*! @endmodule
 */

/*! @endmodule
 */