daemon/src/storage/MemoryBundleStorage.h

Go to the documentation of this file.

/*
 * MemoryBundleStorage.h
 *
 *  Created on: 22.11.2010
 *      Author: morgenro
 */

#ifndef MEMORYBUNDLESTORAGE_H_
#define MEMORYBUNDLESTORAGE_H_

#include "Component.h"
#include "core/BundleCore.h"
#include "storage/BundleStorage.h"
#include "core/Node.h"
#include "core/EventReceiver.h"

#include <ibrdtn/data/Bundle.h>
#include <ibrdtn/data/BundleList.h>

namespace dtn
{
        namespace storage
        {
                class MemoryBundleStorage : public BundleStorage, public dtn::core::EventReceiver, public dtn::daemon::IntegratedComponent, private dtn::data::BundleList
                {
                public:
                        MemoryBundleStorage(size_t maxsize = 0);
                        virtual ~MemoryBundleStorage();

                        virtual void store(const dtn::data::Bundle &bundle);

                        virtual dtn::data::Bundle get(const dtn::data::BundleID &id);

                        virtual const std::list<dtn::data::MetaBundle> get(BundleFilterCallback &cb);

                        virtual const std::set<dtn::data::EID> getDistinctDestinations();

                        void remove(const dtn::data::BundleID &id);

                        dtn::data::MetaBundle remove(const ibrcommon::BloomFilter &filter);

                        void clear();

                        bool empty();

                        unsigned int count();

                        size_t size() const;

                        void releaseCustody(const dtn::data::EID &custodian, const dtn::data::BundleID &id);

                        void raiseEvent(const dtn::core::Event *evt);

                        virtual const std::string getName() const;

                protected:
                        virtual void componentUp();
                        virtual void componentDown();

                        virtual void eventBundleExpired(const ExpiringBundle &b);

                private:
                        ibrcommon::Mutex _bundleslock;
                        std::set<dtn::data::Bundle> _bundles;

                        struct CMP_BUNDLE_PRIORITY
                        {
                                bool operator() (const dtn::data::MetaBundle& lhs, const dtn::data::MetaBundle& rhs) const
                                {
                                        if (lhs.getPriority() == rhs.getPriority())
                                                return rhs > lhs;

                                        return (lhs.getPriority() > rhs.getPriority());
                                }
                        };

                        std::set<dtn::data::MetaBundle, CMP_BUNDLE_PRIORITY> _priority_index;
                        std::map<dtn::data::BundleID, ssize_t> _bundle_lengths;

                        size_t _maxsize;
                        size_t _currentsize;
                };
        }
}

#endif /* MEMORYBUNDLESTORAGE_H_ */