BerkeleyDBXML-0.1: Database/Berkeley/dbxml_helper.cpp

#include "dbxml_helper.h"

#include "XmlManager.hpp"
#include "XmlException.hpp"

#include <string.h>

using namespace DbXml;
using namespace std;


static int asInt(XmlException& exc)
{
    int dbE = exc.getDbErrno();
    if (dbE < 0)
        dbE = -dbE;
    return (exc.getExceptionCode() + 1) * 100000 + dbE;
}

int _xmlManager(DbEnv* dbenv, u_int32_t flags, DbXml::XmlManager** mgr)
{
    try {
        *mgr = new XmlManager(dbenv, flags);
        return 0;
    }
    catch (XmlException& exc) {
        *mgr = NULL;
        return asInt(exc);
    }
}

int _xmlManager_openContainer(DbXml::XmlManager* mgr, const char* name, u_int32_t flags,
    int cType, int mode, DbXml::XmlContainer** container)
{
    try {
        DbXml::XmlContainer c = mgr->openContainer(name, flags,
            cType == 0 ? XmlContainer::NodeContainer : XmlContainer::WholedocContainer,
            mode);
        *container = new DbXml::XmlContainer(c);
        return 0;
    }
    catch (XmlException& exc) {
        *container = NULL;
        return asInt(exc);
    }
}

void _xmlContainer_delete(DbXml::XmlContainer* cont)
{
    delete cont;
}

int _xmlManager_createTransaction(DbXml::XmlManager* mgr, u_int32_t flags, DbXml::XmlTransaction** trans)
{
    try {
        XmlTransaction t = mgr->createTransaction(flags);
        *trans = new XmlTransaction(t);
        return 0;
    }
    catch (XmlException& exc) {
        *trans = NULL;
        return asInt(exc);
    }
}

void _xmlTransaction_delete(DbXml::XmlTransaction* trans)
{
    delete trans;
}

int _xmlTransaction_commit(DbXml::XmlTransaction* trans)
{
    try {
        trans->commit();
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlTransaction_abort(DbXml::XmlTransaction* trans)
{
    try {
        trans->abort();
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlContainer_getDocument(DbXml::XmlContainer* cont, DbXml::XmlTransaction* trans,
    const char* key, u_int32_t flags, DbXml::XmlDocument** doc)
{
    try {
        XmlDocument d;
        if (trans != NULL)
            d = cont->getDocument(*trans, key, flags);
        else
            d = cont->getDocument(key, flags);
        *doc = new XmlDocument(d);
        return 0;
    }
    catch (XmlException& exc) {
        *doc = NULL;
        return asInt(exc);
    }
}

char* _xmlContainer_getName(DbXml::XmlContainer* cont)
{
    string s = cont->getName();
    char* str = new char[s.length()+1];
    strcpy(str, s.c_str());
    return str;
}

void _xmlDocument_delete(DbXml::XmlDocument* doc)
{
    delete doc;
}

int _xmlDocument_getContent(DbXml::XmlDocument* doc, char** str)
{
    string s;
    try {
        doc->getContent(s);
    }
    catch (XmlException& exc) {
        *str = NULL;
        return asInt(exc);
    }
    *str = new char[s.length()+1];
    strcpy(*str, s.c_str());
    return 0;
}

int _xmlManager_createQueryContext(DbXml::XmlManager* mgr, int rt, int ev, DbXml::XmlQueryContext** ctx)
{
    try {
        XmlQueryContext c = mgr->createQueryContext(
            XmlQueryContext::LiveValues,
            ev == 0 ? XmlQueryContext::Eager : XmlQueryContext::Lazy);
        *ctx = new XmlQueryContext(c);
        return 0;
    }
    catch (XmlException& exc) {
        *ctx = NULL;
        return asInt(exc);
    }
}

void _xmlQueryContext_delete(DbXml::XmlQueryContext* ctx)
{
    delete ctx;
}

void _xmlResults_delete(DbXml::XmlResults* res)
{
    delete res;
}

int _xmlResults_hasNext(DbXml::XmlResults* res, int* answer)
{
    try {
        *answer = res->hasNext();
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlResults_nextDocument(DbXml::XmlResults* res, DbXml::XmlDocument** doc)
{
    *doc = new XmlDocument;
    try {
        if (!res->next(**doc)) {
            delete *doc;
            *doc = NULL;
        }
        return 0;
    }
    catch (XmlException& exc) {
        delete *doc;
        *doc = NULL;
        return asInt(exc);
    }
}

int _xmlResults_nextValue(DbXml::XmlResults* res, DbXml::XmlValue** val)
{
    *val = new XmlValue;
    try {
        if (!res->next(**val)) {
            delete *val;
            *val = NULL;
        }
        return 0;
    }
    catch (XmlException& exc) {
        delete *val;
        *val = NULL;
        return asInt(exc);
    }
}

int _xmlManager_query(DbXml::XmlManager* mgr, DbXml::XmlTransaction* trans,
    const char* query, DbXml::XmlQueryContext* ctx, u_int32_t flags, DbXml::XmlResults** res)
{
    try {
        XmlResults r;
        if (trans != NULL)
            r = mgr->query(*trans, query, *ctx, flags);
        else
            r = mgr->query(query, *ctx, flags);
        *res = new XmlResults(r);
        return 0;
    }
    catch (XmlException& exc) {
        *res = NULL;
        return asInt(exc);
    }
}

void _xmlQueryExpression_delete(DbXml::XmlQueryExpression* exp)
{
    delete exp;
}

int _xmlManager_prepare(DbXml::XmlManager* mgr, DbXml::XmlTransaction* trans,
    const char* query, DbXml::XmlQueryContext* ctx, DbXml::XmlQueryExpression** exp)
{
    try {
        XmlQueryExpression e;
        if (trans != NULL)
            e = mgr->prepare(*trans, query, *ctx);
        else
            e = mgr->prepare(query, *ctx);
        *exp = new XmlQueryExpression(e);
        return 0;
    }
    catch (XmlException& exc) {
        *exp = NULL;
        return asInt(exc);
    }
}

int _xmlQueryContext_setDefaultCollection(DbXml::XmlQueryContext* ctx, const char* coll)
{
    try {
        ctx->setDefaultCollection(coll);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlQueryContext_setVariableValue(DbXml::XmlQueryContext* ctx, const char* name, DbXml::XmlValue* value)
{
    try {
        ctx->setVariableValue(name, *value);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

void _xmlValue_delete(DbXml::XmlValue* val)
{
    delete val;
}

DbXml::XmlValue* _xmlNone()
{
    return new XmlValue;
}

DbXml::XmlValue* _xmlString(const char* text)
{
    return new XmlValue(text);
}

DbXml::XmlValue* _xmlBool(int value)
{
    return new XmlValue((bool)value);
}

DbXml::XmlValue* _xmlDouble(double value)
{
    return new XmlValue(value);
}

int _xmlValue_asString(DbXml::XmlValue* value, char** str)
{
    string s;
    try {
        s = value->asString();
    }
    catch (XmlException& exc) {
        *str = NULL;
        return asInt(exc);
    }
    *str = new char[s.length()+1];
    strcpy(*str, s.c_str());
    return 0;
}

int _xmlQueryExpression_execute(DbXml::XmlQueryExpression* exp, DbXml::XmlTransaction* trans,
    DbXml::XmlValue* contextItem, DbXml::XmlQueryContext* qctx, u_int32_t flags, DbXml::XmlResults** res)
{
    try {
        XmlResults r;
        if (trans != NULL && contextItem != NULL)
            r = exp->execute(*trans, *contextItem, *qctx, flags);
        else
        if (trans != NULL && contextItem == NULL)
            r = exp->execute(*trans, *qctx, flags);
        else
        if (trans == NULL && contextItem != NULL)
            r = exp->execute(*contextItem, *qctx, flags);
        else
            r = exp->execute(*qctx, flags);
        *res = new XmlResults(r);
        return 0;
    }
    catch (XmlException& exc) {
        *res = NULL;
        return asInt(exc);
    }
}

int _xmlManager_createDocument(DbXml::XmlManager* mgr, DbXml::XmlDocument** doc)
{
    try {
        XmlDocument d = mgr->createDocument();
        *doc = new XmlDocument(d);
        return 0;
    }
    catch (XmlException& exc) {
        *doc = NULL;
        return asInt(exc);
    }
}

int _xmlDocument_getName(DbXml::XmlDocument* doc, char** name)
{
    string s;
    try {
        s = doc->getName();
    }
    catch (XmlException& exc) {
        *name = NULL;
        return asInt(exc);
    }
    *name = new char[s.length()+1];
    strcpy(*name, s.c_str());
    return 0;
}

int _xmlDocument_setName(DbXml::XmlDocument* doc, const char* name)
{
    try {
        doc->setName(name);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

void _xmlUpdateContext_delete(DbXml::XmlUpdateContext* ctx)
{
    delete ctx;
}

int _xmlManager_createUpdateContext(DbXml::XmlManager* mgr, DbXml::XmlUpdateContext** ctx)
{
    try {
        XmlUpdateContext c = mgr->createUpdateContext();
        *ctx = new XmlUpdateContext(c);
        return 0;
    }
    catch (XmlException& exc) {
        *ctx = NULL;
        return asInt(exc);
    }
}

int _xmlDocument_setContent(DbXml::XmlDocument* doc, const char* text)
{
    try {
        doc->setContent(text);
        return 0;
    }
    catch (XmlException& exc) {
        *doc = NULL;
        return asInt(exc);
    }
}

int _xmlContainer_updateDocument(DbXml::XmlContainer* cont, DbXml::XmlTransaction* trans,
    DbXml::XmlDocument* doc, DbXml::XmlUpdateContext* uctx)
{
    try {
        if (trans != NULL)
            cont->updateDocument(*trans, *doc, *uctx);
        else
            cont->updateDocument(*doc, *uctx);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlContainer_putDocument(DbXml::XmlContainer* cont, DbXml::XmlTransaction* trans,
    DbXml::XmlDocument* doc, DbXml::XmlUpdateContext* uctx, u_int32_t flags)
{
    try {
        if (trans != NULL)
            cont->putDocument(*trans, *doc, *uctx, flags);
        else
            cont->putDocument(*doc, *uctx, flags);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}

int _xmlContainer_deleteDocument(DbXml::XmlContainer* cont, DbXml::XmlTransaction* trans,
    DbXml::XmlDocument* doc, DbXml::XmlUpdateContext* uctx)
{
    try {
        if (trans != NULL)
            cont->deleteDocument(*trans, *doc, *uctx);
        else
            cont->deleteDocument(*doc, *uctx);
        return 0;
    }
    catch (XmlException& exc) {
        return asInt(exc);
    }
}