Git-Url: 
http://git.frugalware.org/gitweb/gitweb.cgi?p=pacman-g2.git;a=commitdiff;h=7fd8eef8ae9f1036c5584c5b7c625aca269c9915

commit 7fd8eef8ae9f1036c5584c5b7c625aca269c9915
Author: Michel Hermier <[email protected]>
Date:   Sat Apr 26 12:56:21 2014 +0200

libpacman: Objectize struct __pmdb_t.

diff --git a/lib/libpacman/cache.cpp b/lib/libpacman/cache.cpp
index 0281797..e1fa455 100644
--- a/lib/libpacman/cache.cpp
+++ b/lib/libpacman/cache.cpp
@@ -70,8 +70,8 @@ int _pacman_db_load_pkgcache(pmdb_t *db)
_pacman_log(PM_LOG_DEBUG, _("loading package cache (infolevel=%#x) for 
repository '%s'"),
inforeq, db->treename);

-       _pacman_db_rewind(db);
-       while((info = _pacman_db_readpkg(db, inforeq)) != NULL) {
+       db->rewind();
+       while((info = db->readpkg(inforeq)) != NULL) {
info->origin = PKG_FROM_CACHE;
info->data = db;
/* add to the collective */
@@ -197,7 +197,7 @@ int _pacman_db_load_grpcache(pmdb_t *db)
pmpkg_t *pkg = lp->data;

if(!(pkg->infolevel & INFRQ_DESC)) {
-                       _pacman_db_read(pkg->data, pkg, INFRQ_DESC);
+                       ((__pmdb_t *)pkg->data)->read(pkg, INFRQ_DESC);
}

for(i = pkg->groups; i; i = i->next) {
diff --git a/lib/libpacman/conflict.cpp b/lib/libpacman/conflict.cpp
index 55f9816..3c5a42c 100644
--- a/lib/libpacman/conflict.cpp
+++ b/lib/libpacman/conflict.cpp
@@ -319,7 +319,7 @@ pmlist_t *_pacman_db_find_conflicts(pmtrans_t *trans, char 
*root, pmlist_t **ski
}
if(dbpkg && !(dbpkg->infolevel & INFRQ_FILES)) {
_pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), dbpkg->name);
-                                               _pacman_db_read(db_local, 
dbpkg, INFRQ_FILES);
+                                               db_local->read(dbpkg, 
INFRQ_FILES);
}
if(dbpkg && _pacman_list_is_strin(j->data, dbpkg->files)) {
ok = 1;
@@ -335,7 +335,7 @@ pmlist_t *_pacman_db_find_conflicts(pmtrans_t *trans, char 
*root, pmlist_t **ski
dbpkg2 = _pacman_db_get_pkgfromcache(db_local, p2->name);
if(dbpkg2 && !(dbpkg2->infolevel & INFRQ_FILES)) {
_pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), dbpkg2->name);
-                                                                       
_pacman_db_read(db_local, dbpkg2, INFRQ_FILES);
+                                                                       
db_local->read(dbpkg2, INFRQ_FILES);
}
/* If it used to exist in there, but doesn't anymore */
if(dbpkg2 && !_pacman_list_is_strin(filestr, p2->files) && 
_pacman_list_is_strin(filestr, dbpkg2->files)) {
diff --git a/lib/libpacman/db.cpp b/lib/libpacman/db.cpp
index 97d7ee4..60776ca 100644
--- a/lib/libpacman/db.cpp
+++ b/lib/libpacman/db.cpp
@@ -67,35 +67,21 @@ FILE *_pacman_db_fopen_lastupdate(const pmdb_t *db, const 
char *mode)
return fopen(path, mode);
}

-pmdb_t *_pacman_db_new(pmhandle_t *handle, const char *treename)
+__pmdb_t::__pmdb_t(pmhandle_t *handle, const char *treename)
{
-       pmdb_t *db = f_zalloc(sizeof(pmdb_t));
+       path = 
f_zalloc(strlen(handle->root)+strlen(handle->dbpath)+strlen(treename)+2);
+//     if(path == NULL) {
+//             return(NULL);
+//     }
+       sprintf(path, "%s%s/%s", handle->root, handle->dbpath, treename);

-       if(db == NULL) {
-               return(NULL);
-       }
-
-       db->path = 
f_zalloc(strlen(handle->root)+strlen(handle->dbpath)+strlen(treename)+2);
-       if(db->path == NULL) {
-               FREE(db);
-               return(NULL);
-       }
-       sprintf(db->path, "%s%s/%s", handle->root, handle->dbpath, treename);
-
-       STRNCPY(db->treename, treename, PATH_MAX);
-
-       return(db);
+       STRNCPY(this->treename, treename, PATH_MAX);
}

-void _pacman_db_free(void *data)
+__pmdb_t::~__pmdb_t()
{
-       pmdb_t *db = data;
-
-       FREELISTSERVERS(db->servers);
-       free(db->path);
-       free(db);
-
-       return;
+       FREELISTSERVERS(servers);
+       free(path);
}

int _pacman_db_cmp(const void *db1, const void *db2)
@@ -103,7 +89,7 @@ int _pacman_db_cmp(const void *db1, const void *db2)
return(strcmp(((pmdb_t *)db1)->treename, ((pmdb_t *)db2)->treename));
}

-pmlist_t *_pacman_db_search(pmdb_t *db, pmlist_t *needles)
+pmlist_t *__pmdb_t::search(pmlist_t *needles)
{
pmlist_t *i, *j, *ret = NULL;

@@ -118,7 +104,7 @@ pmlist_t *_pacman_db_search(pmdb_t *db, pmlist_t *needles)
_pacman_log(PM_LOG_DEBUG, "searching for target '%s'\n", targ);
if(f_strmatcher_init(&strmatcher, targ, F_STRMATCHER_ALL_IGNORE_CASE) == 0 &&
_pacman_packagestrmatcher_init(&packagestrmatcher, &strmatcher, 
PM_PACKAGE_FLAG_NAME | PM_PACKAGE_FLAG_DESCRIPTION | PM_PACKAGE_FLAG_PROVIDES) 
== 0) {
-                       for(j = _pacman_db_get_pkgcache(db); j; j = j->next) {
+                       for(j = _pacman_db_get_pkgcache(this); j; j = j->next) {
pmpkg_t *pkg = j->data;

if(f_match(pkg, &packagestrmatcher)) {
@@ -133,39 +119,33 @@ pmlist_t *_pacman_db_search(pmdb_t *db, pmlist_t *needles)
return(ret);
}

-pmlist_t *_pacman_db_test(pmdb_t *db)
+pmlist_t *__pmdb_t::test()
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, NULL));
-
-       return db->ops->test(db);
+       return ops->test(this);
}

-int _pacman_db_open(pmdb_t *db, int flags)
+int __pmdb_t::open(int flags)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
ASSERT(flags == 0, RET_ERR(PM_ERR_DB_OPEN, -1)); /* No flags are supported for 
now */

-       return db->ops->open(db, flags, &db->cache_timestamp);
+       return ops->open(this, flags, &cache_timestamp);
}

-int _pacman_db_close(pmdb_t *db)
+int __pmdb_t::close()
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
-
-       return db->ops->close(db);
+       return ops->close(this);
}

-int _pacman_db_gettimestamp(pmdb_t *db, time_t *timestamp)
+int __pmdb_t::gettimestamp(time_t *timestamp)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
ASSERT(timestamp != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));

-       if(db->ops->gettimestamp) {
-               return db->ops->gettimestamp(db, timestamp);
+       if(ops->gettimestamp) {
+               return ops->gettimestamp(this, timestamp);
} else {
char buffer[PM_FMT_MDTM_MAX];

-               if(_pacman_db_getlastupdate(db, buffer) == 0 &&
+               if(_pacman_db_getlastupdate(this, buffer) == 0 &&
_pacman_ftp_strpmdtm(buffer, timestamp) != NULL) {
return 0;
}
@@ -175,73 +155,62 @@ int _pacman_db_gettimestamp(pmdb_t *db, time_t *timestamp)

/* A NULL timestamp means now per f_localtime definition.
*/
-int _pacman_db_settimestamp(pmdb_t *db, const time_t *timestamp)
+int __pmdb_t::settimestamp(const time_t *timestamp)
{
char buffer[PM_FMT_MDTM_MAX];

-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
-
_pacman_ftp_strfmdtm(buffer, sizeof(buffer), timestamp);
-       return _pacman_db_setlastupdate(db, buffer);
+       return _pacman_db_setlastupdate(this, buffer);
}

-int _pacman_db_rewind(pmdb_t *db)
+int __pmdb_t::rewind()
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
-
-       return db->ops->rewind(db);
+       return ops->rewind(this);
}

-pmpkg_t *_pacman_db_readpkg(pmdb_t *db, unsigned int inforeq)
+pmpkg_t *__pmdb_t::readpkg(unsigned int inforeq)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, NULL));
-
-       return db->ops->readpkg(db, inforeq);
+       return ops->readpkg(this, inforeq);
}

-pmpkg_t *_pacman_db_scan(pmdb_t *db, const char *target, unsigned int inforeq)
+pmpkg_t *__pmdb_t::scan(const char *target, unsigned int inforeq)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, NULL));
-
-       return db->ops->scan(db, target, inforeq);
+       return ops->scan(this, target, inforeq);
}

-int _pacman_db_read(pmdb_t *db, pmpkg_t *info, unsigned int inforeq)
+int __pmdb_t::read(pmpkg_t *info, unsigned int inforeq)
{
int ret;

-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
ASSERT(info != NULL, RET_ERR(PM_ERR_PKG_INVALID, -1));
if(_pacman_strempty(info->name) || _pacman_strempty(info->version)) {
_pacman_log(PM_LOG_ERROR, _("invalid package entry provided to 
_pacman_db_read"));
return(-1);
}

-       if((ret = db->ops->read(db, info, inforeq)) == 0) {
+       if((ret = ops->read(this, info, inforeq)) == 0) {
info->infolevel |= inforeq;
}
return ret;
}

-int _pacman_db_write(pmdb_t *db, pmpkg_t *info, unsigned int inforeq)
+int __pmdb_t::write(pmpkg_t *info, unsigned int inforeq)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
ASSERT(info != NULL, RET_ERR(PM_ERR_PKG_INVALID, -1));

-       if(db->ops->write != NULL) {
-               return db->ops->write(db, info, inforeq);
+       if(ops->write != NULL) {
+               return ops->write(this, info, inforeq);
} else {
RET_ERR(PM_ERR_WRONG_ARGS, -1); // Not supported
}
}

-int _pacman_db_remove(pmdb_t *db, pmpkg_t *info)
+int __pmdb_t::remove(pmpkg_t *info)
{
-       ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
ASSERT(info != NULL, RET_ERR(PM_ERR_PKG_INVALID, -1));

-       if(db->ops->remove != NULL) {
-               return db->ops->remove(db, info);
+       if(ops->remove != NULL) {
+               return ops->remove(this, info);
} else {
RET_ERR(PM_ERR_WRONG_ARGS, -1); // Not supported
}
@@ -324,7 +293,7 @@ pmdb_t *_pacman_db_register(const char *treename, 
pacman_cb_db_register callback

_pacman_log(PM_LOG_FLOW1, _("registering database '%s'"), treename);

-       db = _pacman_db_new(handle, treename);
+       db = new __pmdb_t(handle, treename);
if(db == NULL) {
RET_ERR(PM_ERR_DB_CREATE, NULL);
}
@@ -335,8 +304,8 @@ pmdb_t *_pacman_db_register(const char *treename, 
pacman_cb_db_register callback
}

_pacman_log(PM_LOG_DEBUG, _("opening database '%s'"), db->treename);
-       if(_pacman_db_open(db, 0) == -1) {
-               _pacman_db_free(db);
+       if(db->open(0) == -1) {
+               delete db;
RET_ERR(PM_ERR_DB_OPEN, NULL);
}

diff --git a/lib/libpacman/db.h b/lib/libpacman/db.h
index 9cdb9d6..fb79a09 100644
--- a/lib/libpacman/db.h
+++ b/lib/libpacman/db.h
@@ -58,6 +58,29 @@ struct __pmdb_ops_t {

/* Database */
struct __pmdb_t {
+       __pmdb_t(pmhandle_t *handle, const char *treename);
+       ~__pmdb_t();
+
+       /* Prototypes for backends functions */
+       pmlist_t *test(); /* FIXME: constify */
+
+       int open(int flags);
+       int close();
+
+       int gettimestamp(time_t *timestamp);
+       int settimestamp(const time_t *timestamp);
+
+       int rewind();
+       pmpkg_t *readpkg(unsigned int inforeq);
+       pmpkg_t *scan(const char *target, unsigned int inforeq);
+
+       int read(pmpkg_t *info, unsigned int inforeq);
+       int write(pmpkg_t *info, unsigned int inforeq);
+       int remove(pmpkg_t *info);
+
+       // Cache operations
+       pmlist_t *search(pmlist_t *needles);
+
const pmdb_ops_t *ops;
char *path;
char treename[PATH_MAX];
@@ -68,23 +91,8 @@ struct __pmdb_t {
pmlist_t *servers;
};

-pmdb_t *_pacman_db_new(pmhandle_t *handle, const char *treename);
-void _pacman_db_free(void *data);
int _pacman_db_cmp(const void *db1, const void *db2);
-pmlist_t *_pacman_db_search(pmdb_t *db, pmlist_t *needles);
-
-/* Prototypes for backends functions */
-pmlist_t *_pacman_db_test(pmdb_t *db);
-int _pacman_db_open(pmdb_t *db, int flags);
-int _pacman_db_close(pmdb_t *db);
-int _pacman_db_gettimestamp(pmdb_t *db, time_t *timestamp);
-int _pacman_db_settimestamp(pmdb_t *db, const time_t *timestamp);
-int _pacman_db_rewind(pmdb_t *db);
-pmpkg_t *_pacman_db_readpkg(pmdb_t *db, unsigned int inforeq);
-pmpkg_t *_pacman_db_scan(pmdb_t *db, const char *target, unsigned int inforeq);
-int _pacman_db_read(pmdb_t *db, pmpkg_t *info, unsigned int inforeq);
-int _pacman_db_write(pmdb_t *db, pmpkg_t *info, unsigned int inforeq);
-int _pacman_db_remove(pmdb_t *db, pmpkg_t *info);
+
pmdb_t *_pacman_db_register(const char *treename, pacman_cb_db_register 
callback);

namespace libpacman
diff --git a/lib/libpacman/db/localdb.cpp b/lib/libpacman/db/localdb.cpp
index d860280..d1510c5 100644
--- a/lib/libpacman/db/localdb.cpp
+++ b/lib/libpacman/db/localdb.cpp
@@ -160,7 +160,7 @@ pmpkg_t *_pacman_localdb_pkg_new(pmdb_t *db, const struct 
dirent *dirent, unsign
dname = dirent->d_name;
if((pkg = _pacman_pkg_new_from_filename(dname, 0)) == NULL ||
_pacman_localpkg_init(pkg, db) != 0 ||
-               _pacman_db_read(db, pkg, inforeq) == -1) {
+               db->read(pkg, inforeq) == -1) {
_pacman_log(PM_LOG_ERROR, _("invalid name for dabatase entry '%s'"), dname);
FREEPKG(pkg);
}
@@ -218,7 +218,7 @@ int _pacman_localdb_open(pmdb_t *db, int flags, time_t 
*timestamp)
}
db->handle = opendir(db->path);
ASSERT(db->handle != NULL, RET_ERR(PM_ERR_DB_OPEN, -1));
-       _pacman_db_gettimestamp(db, timestamp);
+       db->gettimestamp(timestamp);
return 0;
}

@@ -278,7 +278,7 @@ pmpkg_t *_pacman_localdb_scan(pmdb_t *db, const char 
*target, unsigned int infor
ASSERT(!_pacman_strempty(target), RET_ERR(PM_ERR_WRONG_ARGS, NULL));

// Search from start
-       _pacman_db_rewind(db);
+       db->rewind();

/* search for a specific package (by name only) */
while((ent = readdir(db->handle)) != NULL) {
diff --git a/lib/libpacman/db/syncdb.cpp b/lib/libpacman/db/syncdb.cpp
index 72aaa39..61de0cd 100644
--- a/lib/libpacman/db/syncdb.cpp
+++ b/lib/libpacman/db/syncdb.cpp
@@ -143,7 +143,7 @@ pmpkg_t *_pacman_syncdb_pkg_new(pmdb_t *db, const struct 
archive_entry *entry, u
dname = archive_entry_pathname((struct archive_entry *)entry);
if((pkg = _pacman_pkg_new_from_filename(dname, 0)) == NULL ||
_pacman_syncpkg_init(pkg, db) != 0 ||
-               _pacman_db_read(db, pkg, inforeq) == -1) {
+               db->read(pkg, inforeq) == -1) {
_pacman_log(PM_LOG_ERROR, _("invalid name for dabatase entry '%s'"), dname);
FREEPKG(pkg);
}
@@ -166,7 +166,7 @@ int _pacman_syncdb_update(pmdb_t *db, int force)
int ret, updated=0;

if(!force) {
-               _pacman_db_gettimestamp(db, &timestamp);
+               db->gettimestamp(&timestamp);
if(timestamp == PM_TIME_INVALID) {
_pacman_log(PM_LOG_DEBUG, _("failed to get timestamp for %s (no big deal)\n"), 
db->treename);
}
@@ -201,7 +201,7 @@ int _pacman_syncdb_update(pmdb_t *db, int force)
_pacman_db_free_pkgcache(db);

if(updated) {
-                       _pacman_db_settimestamp(db, &newmtime);
+                       db->settimestamp(&newmtime);
}
}
return 0;
@@ -224,7 +224,7 @@ int _pacman_syncdb_open(pmdb_t *db, int flags, time_t 
*timestamp)
RET_ERR(PM_ERR_DB_OPEN, 0);
}
if(timestamp != NULL) {
-               _pacman_db_gettimestamp(db, timestamp);
+               db->gettimestamp(timestamp);
}
return 0;
}
@@ -254,7 +254,7 @@ pmpkg_t *_pacman_syncdb_readpkg(pmdb_t *db, unsigned int 
inforeq)
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, NULL));

if(!db->handle) {
-               _pacman_db_rewind(db);
+               db->rewind();
}
if(!db->handle) {
return NULL;
@@ -284,7 +284,7 @@ pmpkg_t *_pacman_syncdb_scan(pmdb_t *db, const char 
*target, unsigned int infore
ASSERT(!_pacman_strempty(target), RET_ERR(PM_ERR_WRONG_ARGS, NULL));

// Search from start
-       _pacman_db_rewind(db);
+       db->rewind();

/* search for a specific package (by name only) */
while (archive_read_next_header(db->handle, &entry) == ARCHIVE_OK) {
diff --git a/lib/libpacman/deps.cpp b/lib/libpacman/deps.cpp
index 1f1fc5b..8734abd 100644
--- a/lib/libpacman/deps.cpp
+++ b/lib/libpacman/deps.cpp
@@ -551,7 +551,7 @@ pmlist_t *_pacman_removedeps(pmdb_t *db, pmlist_t *targs)
}
/* add it to the target list */
_pacman_log(PM_LOG_DEBUG, _("loading ALL info for '%s'"), pkg->name);
-                               _pacman_db_read(db, pkg, INFRQ_ALL);
+                               db->read(pkg, INFRQ_ALL);
newtargs = _pacman_list_add(newtargs, pkg);
_pacman_log(PM_LOG_FLOW2, _("adding '%s' to the targets"), pkg->name);
newtargs = _pacman_removedeps(db, newtargs);
@@ -763,7 +763,7 @@ int pacman_output_generate(pmlist_t *targets, pmlist_t 
*dblist) {
pmdb_t *db = j->data;
do {
foundMatch = 0;
-            pkg = _pacman_db_readpkg(db, inforeq);
+            pkg = db->readpkg(inforeq);
while(pkg != NULL) {
char *pname = (char *)pacman_pkg_getinfo(pkg, PM_PKG_NAME);
targets = _pacman_list_remove(targets, (void*) pname, str_cmp, (void **)&match);
@@ -786,9 +786,9 @@ int pacman_output_generate(pmlist_t *targets, pmlist_t 
*dblist) {
}
FREE(match);
}
-                pkg = _pacman_db_readpkg(db, inforeq);
+                pkg = db->readpkg(inforeq);
}
-            _pacman_db_rewind(db);
+            db->rewind();
} while(foundMatch);
}
FREELISTPTR(found);
diff --git a/lib/libpacman/package.cpp b/lib/libpacman/package.cpp
index 160601b..ad1011f 100644
--- a/lib/libpacman/package.cpp
+++ b/lib/libpacman/package.cpp
@@ -431,7 +431,7 @@ void *__pacman_pkg_getinfo(pmpkg_t *pkg, unsigned char parm)
case PM_PKG_FORCE:
if(!(pkg->infolevel & INFRQ_DESC)) {
_pacman_log(PM_LOG_DEBUG, _("loading DESC info for '%s'"), pkg->name);
-                                       _pacman_db_read(pkg->data, pkg, 
INFRQ_DESC);
+                                       ((__pmdb_t *)pkg->data)->read(pkg, 
INFRQ_DESC);
}
break;
/* Depends entry */
@@ -441,7 +441,7 @@ void *__pacman_pkg_getinfo(pmpkg_t *pkg, unsigned char parm)
case PM_PKG_PROVIDES:
if(!(pkg->infolevel & INFRQ_DEPENDS)) {
_pacman_log(PM_LOG_DEBUG, "loading DEPENDS info for '%s'", pkg->name);
-                                       _pacman_db_read(pkg->data, pkg, 
INFRQ_DEPENDS);
+                                       ((__pmdb_t *)pkg->data)->read(pkg, 
INFRQ_DEPENDS);
}
break;
/* Files entry */
@@ -449,14 +449,14 @@ void *__pacman_pkg_getinfo(pmpkg_t *pkg, unsigned char 
parm)
case PM_PKG_BACKUP:
if(pkg->data == handle->db_local && !(pkg->infolevel & INFRQ_FILES)) {
_pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), pkg->name);
-                                       _pacman_db_read(pkg->data, pkg, 
INFRQ_FILES);
+                                       ((__pmdb_t *)pkg->data)->read(pkg, 
INFRQ_FILES);
}
break;
/* Scriptlet */
case PM_PKG_SCRIPLET:
if(pkg->data == handle->db_local && !(pkg->infolevel & INFRQ_SCRIPLET)) {
_pacman_log(PM_LOG_DEBUG, _("loading SCRIPLET info for '%s'"), pkg->name);
-                                       _pacman_db_read(pkg->data, pkg, 
INFRQ_SCRIPLET);
+                                       ((__pmdb_t *)pkg->data)->read(pkg, 
INFRQ_SCRIPLET);
}
break;
}
diff --git a/lib/libpacman/pacman.cpp b/lib/libpacman/pacman.cpp
index 48bf949..d4ba7ec 100644
--- a/lib/libpacman/pacman.cpp
+++ b/lib/libpacman/pacman.cpp
@@ -227,9 +227,9 @@ int pacman_db_unregister(pmdb_t *db)
_pacman_db_free_pkgcache(db);

_pacman_log(PM_LOG_DEBUG, _("closing database '%s'"), db->treename);
-       _pacman_db_close(db);
+       db->close();

-       _pacman_db_free(db);
+       delete db;

return(0);
}
@@ -737,7 +737,7 @@ pmlist_t *pacman_db_test(pmdb_t *db)
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));

-       return(_pacman_db_test(db));
+       return db->test();
}

/** Searches a database
@@ -754,7 +754,7 @@ pmlist_t *pacman_db_search(pmdb_t *db)
ASSERT(handle->needles->data != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));

-       ret = _pacman_db_search(db, handle->needles);
+       ret = db->search(handle->needles);
FREELIST(handle->needles);
return(ret);
}
@@ -912,7 +912,7 @@ int pacman_trans_release()

handle->trans = 0;

-       _pacman_db_settimestamp(handle->db_local, NULL);
+       handle->db_local->settimestamp(NULL);

if(_pacman_handle_unlock(handle) != 0) {
return -1;
diff --git a/lib/libpacman/sync.cpp b/lib/libpacman/sync.cpp
index 03de629..c707d57 100644
--- a/lib/libpacman/sync.cpp
+++ b/lib/libpacman/sync.cpp
@@ -218,7 +218,7 @@ static int check_olddelay(void)

for(i = handle->dbs_sync; i; i= i->next) {
pmdb_t *db = i->data;
-               if(_pacman_db_gettimestamp(db, &tm) == -1) {
+               if(db->gettimestamp(&tm) == -1) {
continue;
}
if(difftime(time(NULL), tm) > handle->olddelay) {
@@ -734,7 +734,7 @@ int _pacman_sync_commit(pmtrans_t *trans, pmlist_t **data)
m->data = strdup(pkg_new->name);
}
}
-                                                       
if(_pacman_db_write(db_local, depender, INFRQ_DEPENDS) == -1) {
+                                                       
if(db_local->write(depender, INFRQ_DEPENDS) == -1) {
_pacman_log(PM_LOG_ERROR, _("could not update requiredby for database entry 
%s-%s"),
pkg_new->name, pkg_new->version);
}
@@ -743,7 +743,7 @@ int _pacman_sync_commit(pmtrans_t *trans, pmlist_t **data)
}
}
}
-                               if(_pacman_db_write(db_local, pkg_new, 
INFRQ_DEPENDS) == -1) {
+                               if(db_local->write(pkg_new, INFRQ_DEPENDS) == 
-1) {
_pacman_log(PM_LOG_ERROR, _("could not update new database entry %s-%s"),
pkg_new->name, pkg_new->version);
}
diff --git a/lib/libpacman/trans.cpp b/lib/libpacman/trans.cpp
index 28cc0f2..fdf3ae2 100644
--- a/lib/libpacman/trans.cpp
+++ b/lib/libpacman/trans.cpp
@@ -62,7 +62,7 @@ static int check_oldcache(void)
pmdb_t *db = handle->db_local;
time_t timestamp;

-       if(_pacman_db_gettimestamp(db, &timestamp) == -1) {
+       if(db->gettimestamp(&timestamp) == -1) {
return(-1);
}
if(difftime(timestamp, db->cache_timestamp) != 0) {
@@ -332,7 +332,7 @@ int _pacman_remove_addtarget(pmtrans_t *trans, const char 
*name)
RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
}

-       if((pkg_local = _pacman_db_scan(db_local, name, INFRQ_ALL)) == NULL) {
+       if((pkg_local = db_local->scan(name, INFRQ_ALL)) == NULL) {
_pacman_log(PM_LOG_ERROR, _("could not find %s in database"), name);
RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
}
@@ -568,7 +568,7 @@ int _pacman_remove_prepare(pmtrans_t *trans, pmlist_t 
**data)
pmlist_t *i;
for(i = lp; i; i = i->next) {
pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
-                                               pmpkg_t *pkg_local = 
_pacman_db_scan(db_local, miss->depend.name, INFRQ_ALL);
+                                               pmpkg_t *pkg_local = 
db_local->scan(miss->depend.name, INFRQ_ALL);
if(pkg_local) {
_pacman_log(PM_LOG_FLOW2, _("pulling %s in the targets list"), pkg_local->name);
trans->packages = _pacman_list_add(trans->packages, pkg_local);
@@ -1088,7 +1088,7 @@ int _pacman_add_commit(pmtrans_t *trans, pmlist_t **data)
if(oldpkg) {
if(!(pkg_local->infolevel & INFRQ_FILES)) {
_pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), pkg_local->name);
-                                               _pacman_db_read(db_local, 
pkg_local, INFRQ_FILES);
+                                               db_local->read(pkg_local, 
INFRQ_FILES);
}
oldpkg->backup = _pacman_list_strdup(pkg_local->backup);
strncpy(oldpkg->name, pkg_local->name, PKG_NAME_LEN);
@@ -1179,7 +1179,7 @@ int _pacman_add_commit(pmtrans_t *trans, pmlist_t **data)

_pacman_log(PM_LOG_FLOW1, _("updating database"));
_pacman_log(PM_LOG_FLOW2, _("adding database entry '%s'"), pkg_new->name);
-               if(_pacman_db_write(db_local, pkg_new, INFRQ_ALL)) {
+               if(db_local->write(pkg_new, INFRQ_ALL)) {
_pacman_log(PM_LOG_ERROR, _("error updating database for %s-%s!"),
pkg_new->name, pkg_new->version);
RET_ERR(PM_ERR_DB_WRITE, -1);
@@ -1218,7 +1218,7 @@ int _pacman_add_commit(pmtrans_t *trans, pmlist_t **data)
}
_pacman_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s'"), 
pkg_new->name, depinfo->name);
depinfo->requiredby = _pacman_stringlist_append(_pacman_pkg_getinfo(depinfo, 
PM_PKG_REQUIREDBY), pkg_new->name);
-                       if(_pacman_db_write(db_local, depinfo, INFRQ_DEPENDS)) {
+                       if(db_local->write(depinfo, INFRQ_DEPENDS)) {
_pacman_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry 
%s-%s"),
depinfo->name, depinfo->version);
}
@@ -1310,7 +1310,7 @@ int _pacman_remove_commit(pmtrans_t *trans, pmlist_t 
**data)
/* remove the package from the database */
_pacman_log(PM_LOG_FLOW1, _("updating database"));
_pacman_log(PM_LOG_FLOW2, _("removing database entry '%s'"), pkg_local->name);
-               if(_pacman_db_remove(db_local, pkg_local) == -1) {
+               if(db_local->remove(pkg_local) == -1) {
_pacman_log(PM_LOG_ERROR, _("could not remove database entry %s-%s"), 
pkg_local->name, pkg_local->version);
}
if(_pacman_db_remove_pkgfromcache(db_local, pkg_local) == -1) {
@@ -1355,7 +1355,7 @@ int _pacman_remove_commit(pmtrans_t *trans, pmlist_t 
**data)
depinfo->requiredby = _pacman_list_remove(_pacman_pkg_getinfo(depinfo, 
PM_PKG_REQUIREDBY), pkg_local->name, str_cmp, (void **)&data);
FREE(data);
_pacman_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), 
depinfo->name);
-                       if(_pacman_db_write(db_local, depinfo, INFRQ_DEPENDS)) {
+                       if(db_local->write(depinfo, INFRQ_DEPENDS)) {
_pacman_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry 
%s-%s"),
depinfo->name, depinfo->version);
}
_______________________________________________
Frugalware-git mailing list
[email protected]
http://frugalware.org/mailman/listinfo/frugalware-git

Reply via email to