include/core/SQLiteBundleStorage.h

Go to the documentation of this file.

/*
 * SQLiteBundleStorage.h
 *
 *  Created on: 13.10.2008
 *      Author: morgenro
 */

#ifndef SQLITEBUNDLESTORAGE_H_
#define SQLITEBUNDLESTORAGE_H_

#include "config.h"

#ifdef HAVE_LIBSQLITE3

#include "core/AbstractBundleStorage.h"
#include "core/CustodyManager.h"
#include "data/Bundle.h"
#include "utils/Service.h"
#include <list>
#include <vector>
#include <sqlite3.h>
#include "data/Exceptions.h"
#include "utils/MutexLock.h"
#include "utils/Mutex.h"
#include <map>

using namespace dtn::data;
using namespace dtn::utils;

namespace dtn
{
        namespace exceptions
        {
                class SQLitePrepareException : public Exception
                {
                        public:
                                SQLitePrepareException() : Exception("error while prepare the sql statement")
                                {
                                };

                                SQLitePrepareException(string what) : Exception(what)
                                {
                                };
                };

                class DuplicateException : public Exception
                {
                        public:
                                DuplicateException() : Exception("this item already exists!")
                                {
                                };

                                DuplicateException(string what) : Exception(what)
                                {
                                };
                };
        }

        namespace core
        {
                class SQLiteBundleStorage : public Service, public AbstractBundleStorage
                {
                public:
                        SQLiteBundleStorage(string dbfile, bool flush = false);

                        virtual ~SQLiteBundleStorage();

                        void store(const BundleSchedule &schedule);

                        Bundle* storeFragment(const Bundle &bundle);

                        BundleSchedule getSchedule(unsigned int dtntime);

                        BundleSchedule getSchedule(string destination);

                        void clear();

                        bool isEmpty();

                        unsigned int getSize();

                        unsigned int getCount();

                protected:
                        virtual void tick();

                        void terminate();

                        void eventNodeAvailable(const Node &node);
                        void eventNodeUnavailable(const Node &node);

                private:
                        void sqlQuery(string query, int id1 = -1, int id2 = -1, int id3 = -1);
                        sqlite3_stmt* prepareStatement(string query);
                        sqlite3_int64 storeBundle(const Bundle &bundle);

                        sqlite3 *m_db;

                        Mutex m_dblock;
                        unsigned int last_gettime;

                        sqlite3_stmt *m_stmt_size;
                        sqlite3_stmt *m_stmt_getbytime;
                        sqlite3_stmt *m_stmt_getbyeid;
                        sqlite3_stmt *m_stmt_store_bundle;
                        sqlite3_stmt *m_stmt_store_schedule;

                        sqlite3_stmt *m_stmt_store_fragment;
                        sqlite3_stmt *m_stmt_check_fragment;
                        sqlite3_stmt *m_stmt_get_fragment;
                        sqlite3_stmt *m_stmt_delete_fragment;

                        sqlite3_stmt *m_stmt_outdate_fragments;
                        sqlite3_stmt *m_stmt_outdate_bundles;

                        map<string,Node> m_neighbours;
                };
        }
}

#endif

#endif /* SQLITEBUNDLESTORAGE_H_ */

---