winamp/Src/Wasabi/api/service/svcs/svc_db.h

#ifndef _SVC_DB_H
#define _SVC_DB_H

#include <bfc/dispatch.h>
#include <api/service/services.h>

typedef enum {
  DBSVC_DATATYPE_UNKNOWN = 0,
  DBSVC_DATATYPE_INT     = 1,
  DBSVC_DATATYPE_STRING  = 2,
  DBSVC_DATATYPE_BINARY  = 3,
  DBSVC_DATATYPE_GUID    = 4,
  DBSVC_DATATYPE_FLOAT   = 5,
} dbSvcDatatypeEnum;

typedef struct {
  void *data;
  dbSvcDatatypeEnum datatype;
  int datalen;
} dbSvcDatachunk;

typedef struct {
  const char *name;
  dbSvcDatatypeEnum datatype;
  int id;
  int indexed;
  int uniques_indexed;
} dbSvcColInfo;

class dbSvcScanner;

class NOVTABLE dbSvcScanner : public Dispatchable {

  public:

    void first();
    void last();
    void block_next(); // blocking call for baclkward compat
    void block_previous(); // blocking call for baclkward compat
    int next(); // if non blocking, returns 0 for "HOLD ON!" and 1 for "GOT A ROW!"
    int previous(); // if non blocking, returns 0 for "HOLD ON!" and 1 for "GOT A ROW!"
    void push();
    void pop();
    int eof();
    int bof();

    int getNumRows();
    void moveToRow(int row);
    int getCurRow();

    int locateByName(const char *col, int from_row, dbSvcDatachunk *data);
    int locateById(int id, int from_row, dbSvcDatachunk *data);

    int getNumCols();
    dbSvcColInfo *enumCol(int n);
    dbSvcColInfo *getColById(int n);
    dbSvcColInfo *getColByName(const char *col);

    dbSvcDatachunk *getFieldByName(const char *col);
    dbSvcDatachunk *getFieldById(int id);

    void setIndexByName(const char *col);
    void setIndexById(int id);

    dbSvcScanner *newUniqueScannerByName(const char *col);
    dbSvcScanner *newUniqueScannerById(int colid);
    void deleteUniqueScanner(dbSvcScanner *);

    int query(const char *query);
    const char *getLastQuery();
    void cancelQuery();
    int hasIndexChanged();
    void clearDirtyBit();

    void joinScanner(dbSvcScanner *scanner, const char *field);
    void unjoinScanner(dbSvcScanner *scanner);

    void setBlocking(int b); // blocking is the default behavior

    enum {
      CBFIRST             = 100,
      CBLAST              = 110,
      CBNEXT              = 120, // retired
      CBPREVIOUS          = 130, // retired
      CBNEXT2             = 121,
      CBPREVIOUS2         = 131,
      CBPUSH              = 140,
      CBPOP               = 150,
      CBEOF               = 160,
      CBBOF               = 170,
      GETNUMROWS          = 180,
      MOVETOROW           = 190,
      GETCURROW           = 200,
      LOCATEBYNAME        = 210,
      LOCATEBYID          = 220,
      GETNUMCOLS          = 230,
      ENUMCOL             = 240,
      GETCOLBYID          = 250,
      GETCOLBYNAME        = 260,
      GETFIELDBYNAME      = 270,
      GETFIELDBYID        = 280,
      SETINDEXBYNAME      = 290,
      SETINDEXBYID        = 300,
      QUERY               = 310,
      CANCELQUERY         = 320,
      INDEXCHANGED        = 330,
      CLEARDIRTYBIT       = 340,
      UNIQUEBYNAME        = 350,
      UNIQUEBYID          = 360,
      DELETEUNIQUE        = 370,
      GETLASTQUERY        = 380,
      JOINSCANNER         = 390,
      UNJOINSCANNER       = 400,
      SETBLOCKING         = 410,
    };
};


inline void dbSvcScanner::first() {
  _voidcall(CBFIRST);
}

inline void dbSvcScanner::last() {
  _voidcall(CBLAST);
}

inline void dbSvcScanner::block_next() {
  _voidcall(CBNEXT);
}

inline int dbSvcScanner::next() {
  return _call(CBNEXT2, 0);
}

inline void dbSvcScanner::block_previous() {
  _voidcall(CBPREVIOUS);
}

inline int dbSvcScanner::previous() {
  return _call(CBPREVIOUS2, 0);
}

inline void dbSvcScanner::push() {
  _voidcall(CBPUSH);
}

inline void dbSvcScanner::pop() {
  _voidcall(CBPOP);
}

inline int dbSvcScanner::eof() {
  return _call(CBEOF, 0);
}

inline int dbSvcScanner::bof() {
  return _call(CBBOF, 0);
}

inline int dbSvcScanner::getNumRows() {
  return _call(GETNUMROWS, 0);
}

inline void dbSvcScanner::moveToRow(int row) {
  _voidcall(MOVETOROW, row);
}

inline int dbSvcScanner::getCurRow() {
  return _call(GETCURROW, 0);
}

inline int dbSvcScanner::locateByName(const char *col, int from_row, dbSvcDatachunk *data) {
  return _call(LOCATEBYNAME, 0, col, from_row, data);
}

inline int dbSvcScanner::locateById(int colid, int from_row, dbSvcDatachunk *data) {
  return _call(LOCATEBYNAME, 0, colid, from_row, data);
}

inline int dbSvcScanner::getNumCols() {
  return _call(GETNUMCOLS, 0);
}

inline dbSvcColInfo *dbSvcScanner::enumCol(int n) {
  return _call(ENUMCOL, ((dbSvcColInfo *)NULL), n);
}

inline dbSvcColInfo *dbSvcScanner::getColByName(const char *col) {
  return _call(GETCOLBYNAME, ((dbSvcColInfo *)NULL), col);
}

inline dbSvcColInfo *dbSvcScanner::getColById(int colid) {
  return _call(GETCOLBYID, ((dbSvcColInfo *)NULL), colid);
}

inline dbSvcDatachunk *dbSvcScanner::getFieldByName(const char *col) {
  return _call(GETFIELDBYNAME, ((dbSvcDatachunk *)NULL), col);
}

inline dbSvcDatachunk *dbSvcScanner::getFieldById(int colid) {
  return _call(GETFIELDBYNAME, ((dbSvcDatachunk *)NULL), colid);
}

inline void dbSvcScanner::setIndexByName(const char *col) {
  _voidcall(SETINDEXBYNAME, col);
}

inline void dbSvcScanner::setIndexById(int colid) {
  _voidcall(SETINDEXBYID, colid);
}

inline dbSvcScanner *dbSvcScanner::newUniqueScannerByName(const char *col) {
  return _call(UNIQUEBYNAME, (dbSvcScanner *)NULL, col);
}

inline dbSvcScanner *dbSvcScanner::newUniqueScannerById(int colid) {
  return _call(UNIQUEBYID, (dbSvcScanner *)NULL, colid);
}

inline void dbSvcScanner::deleteUniqueScanner(dbSvcScanner *s) {
  _voidcall(DELETEUNIQUE, s);
}

inline int dbSvcScanner::query(const char *q) {
  return _call(QUERY, 0, q);
}

inline void dbSvcScanner::cancelQuery() {
  _voidcall(CANCELQUERY);
}

inline int dbSvcScanner::hasIndexChanged() {
  return _call(INDEXCHANGED, 0);
}

inline void dbSvcScanner::clearDirtyBit() {
  _voidcall(CLEARDIRTYBIT);
}

inline const char *dbSvcScanner::getLastQuery() {
  return _call(GETLASTQUERY, (const char *)NULL);
}

inline void dbSvcScanner::joinScanner(dbSvcScanner *scanner, const char *field) {
  _voidcall(JOINSCANNER, scanner, field);
}

inline void dbSvcScanner::unjoinScanner(dbSvcScanner *scanner) {
  _voidcall(UNJOINSCANNER, scanner);
}

inline void dbSvcScanner::setBlocking(int b) {
  _voidcall(SETBLOCKING, b);
}

class NOVTABLE dbSvcScannerI : public dbSvcScanner {
public:
  virtual void first()=0;
  virtual void last()=0;
  virtual void block_next()=0;
  virtual void block_previous()=0;
  virtual int next()=0;
  virtual int previous()=0;
  virtual void push()=0;
  virtual void pop()=0;
  virtual int eof()=0;
  virtual int bof()=0;
  virtual int getNumRows()=0;
  virtual void moveToRow(int row)=0;
  virtual int getCurRow()=0;
  virtual int locateByName(const char *col, int from_row, dbSvcDatachunk *data)=0;
  virtual int locateById(int id, int from_row, dbSvcDatachunk *data)=0;
  virtual int getNumCols()=0;
  virtual dbSvcColInfo *enumCol(int n)=0;
  virtual dbSvcColInfo *getColById(int n)=0;
  virtual dbSvcColInfo *getColByName(const char *col)=0;
  virtual dbSvcDatachunk *getFieldByName(const char *col)=0;
  virtual dbSvcDatachunk *getFieldById(int id)=0;
  virtual void setIndexByName(const char *col)=0;
  virtual void setIndexById(int id)=0;
  virtual dbSvcScanner *newUniqueScannerByName(const char *col)=0;
  virtual dbSvcScanner *newUniqueScannerById(int colid)=0;
  virtual void deleteUniqueScanner(dbSvcScanner *)=0;
  virtual int query(const char *query)=0;
  virtual void cancelQuery()=0;
  virtual int hasIndexChanged()=0;
  virtual void clearDirtyBit()=0;
  virtual const char *getLastQuery()=0;
  virtual void joinScanner(dbSvcScanner *scanner, const char *field)=0;
  virtual void unjoinScanner(dbSvcScanner *scanner)=0;
  virtual void setBlocking(int block)=0;

protected:
  RECVS_DISPATCH;
};

class NOVTABLE dbSvcTable : public Dispatchable {
public:
  dbSvcScanner *getScanner();
  dbSvcScanner *newScanner();
  void deleteScanner(dbSvcScanner *scanner);
  void _new();
  void insert();
  void cancel();
  void edit();
  void post();
  void _delete();
  int editing();
  void setFieldByName(const char *col, dbSvcDatachunk *data);
  void setFieldById(int colid, dbSvcDatachunk *data);
  void deleteFieldByName(const char *col);
  void deleteFieldById(int colid);
  void addColumn(const char *colname, int colid, int datatype, int uniques_indexed);
  void addIndexByName(const char *col);
  void addIndexById(int colid);
  void dropIndexByName(const char *col);
  void dropIndexById(int colid);
  void sync();

  enum {
    GETSCANNER        = 100,
    NEWSCANNER        = 110,
    DELETESCANNER     = 111,
    CBNEW             = 120,
    CBINSERT          = 130,
    CBCANCEL          = 140,
    CBEDIT            = 150,
    CBPOST            = 160,
    CBDELETE          = 170,
    EDITING           = 180,
    SETFIELDBYNAME    = 190,
    SETFIELDBYID      = 200,
    DELETEFIELDBYNAME = 210,
    DELETEFIELDBYID   = 220,
    ADDCOLUMN         = 230,
    ADDINDEXBYNAME    = 240,
    ADDINDEXBYID      = 250,
    SYNC              = 260,
    DROPINDEXBYNAME   = 270,
    DROPINDEXBYID     = 280,
  };
};

inline dbSvcScanner *dbSvcTable::getScanner() {
  return _call(GETSCANNER, static_cast<dbSvcScanner *>(NULL));
}

inline dbSvcScanner *dbSvcTable::newScanner() {
  return _call(NEWSCANNER, static_cast<dbSvcScanner *>(NULL));
}

inline void dbSvcTable::deleteScanner(dbSvcScanner *scanner) {
  _voidcall(DELETESCANNER, scanner);
}

inline void dbSvcTable::_new() {
  _voidcall(CBNEW);
}

inline void dbSvcTable::insert() {
  _voidcall(CBINSERT);
}

inline void dbSvcTable::cancel() {
  _voidcall(CBCANCEL);
}

inline void dbSvcTable::edit() {
  _voidcall(CBEDIT);
}

inline void dbSvcTable::post() {
  _voidcall(CBPOST);
}

inline void dbSvcTable::_delete() {
  _voidcall(CBDELETE);
}

inline int dbSvcTable::editing() {
  return _call(EDITING, 0);
}

inline void dbSvcTable::setFieldByName(const char *col, dbSvcDatachunk *data) {
  _voidcall(SETFIELDBYNAME, col, data);
}

inline void dbSvcTable::setFieldById(int colid, dbSvcDatachunk *data) {
  _voidcall(SETFIELDBYID, colid, data);
}

inline void dbSvcTable::deleteFieldByName(const char *col) {
  _voidcall(DELETEFIELDBYNAME, col);
}

inline void dbSvcTable::deleteFieldById(int colid) {
  _voidcall(DELETEFIELDBYID, colid);
}

inline void dbSvcTable::addColumn(const char *colname, int colid, int datatype, int index_uniques) {
  _voidcall(ADDCOLUMN, colname, colid, datatype, index_uniques);
}

inline void dbSvcTable::addIndexByName(const char *col) {
  _voidcall(ADDINDEXBYNAME, col);
}

inline void dbSvcTable::addIndexById(int colid) {
  _voidcall(ADDINDEXBYID, colid);
}

inline void dbSvcTable::dropIndexByName(const char *col) {
  _voidcall(DROPINDEXBYNAME, col);
}

inline void dbSvcTable::dropIndexById(int colid) {
  _voidcall(DROPINDEXBYID, colid);
}

inline void dbSvcTable::sync() {
  _voidcall(SYNC);
}

class NOVTABLE dbSvcTableI : public dbSvcTable {
public:
  virtual dbSvcScanner *getScanner()=0;
  virtual dbSvcScanner *newScanner()=0;
  virtual void deleteScanner(dbSvcScanner *scanner)=0;
  virtual void _new()=0;
  virtual void insert()=0;
  virtual void cancel()=0;
  virtual void edit()=0;
  virtual void post()=0;
  virtual void _delete()=0;
  virtual int editing()=0;
  virtual void setFieldByName(const char *col, dbSvcDatachunk *data)=0;
  virtual void setFieldById(int colid, dbSvcDatachunk *data)=0;
  virtual void deleteFieldByName(const char *col)=0;
  virtual void deleteFieldById(int colid)=0;
  virtual void addColumn(const char *colname, int colid, int datatype, int index_uniques)=0;
  virtual void addIndexByName(const char *col)=0;
  virtual void addIndexById(int colid)=0;
  virtual void dropIndexByName(const char *col)=0;
  virtual void dropIndexById(int colid)=0;
  virtual void sync()=0;

protected:
  RECVS_DISPATCH;
};

class NOVTABLE svc_db : public Dispatchable {
protected:
  svc_db() {}
  ~svc_db() {}
public:
  static FOURCC getServiceType() { return WaSvc::DB; }

  int testQueryFormat(int queryformat);

  dbSvcTable *openTable(const char *tablefilename, int create_if_not_exist, int cache_in_memory);
  void closeTable(dbSvcTable *table);

  enum {
    TESTQUERYFORMAT = 10,
    OPENTABLE       = 20,
    CLOSETABLE      = 30,
  };
};

inline int svc_db::testQueryFormat(int queryformat) {
  return _call(TESTQUERYFORMAT, 0, queryformat);
}

inline dbSvcTable *svc_db::openTable(const char *tablename, int create_if_not_exist, int cache_in_memory) {
  return _call(OPENTABLE, static_cast<dbSvcTable *>(NULL), tablename, create_if_not_exist, cache_in_memory);
}

inline void svc_db::closeTable(dbSvcTable *table) {
  _voidcall(CLOSETABLE, table);
}

// derive from this one
class NOVTABLE svc_dbI : public svc_db{
public:
  virtual int testQueryFormat(int queryformat)=0;
  virtual dbSvcTable *openTable(const char *filename, int create_if_not_exist, int cache_in_memory)=0;
  virtual void closeTable(dbSvcTable *table)=0;

protected:
  RECVS_DISPATCH;
};

#include <api/service/svc_enum.h>

enum {
  DBQFORMAT_MINIQUERY =1,
  DBQFORMAT_SQL       =2,
};

class DatabaseEnum : public SvcEnumT<svc_db> {
public:
  DatabaseEnum(int queryformat=DBQFORMAT_MINIQUERY) :
    query_format(queryformat) {}
protected:
  virtual int testService(svc_db *svc) {
    return svc->testQueryFormat(query_format);
  }

private:
  int query_format;
};

#endif