daemon/src/core/BundleCore.h

Go to the documentation of this file.

#ifndef BUNDLECORE_H_
#define BUNDLECORE_H_

#include "Component.h"

#include "core/EventReceiver.h"
#include "core/StatusReportGenerator.h"
#include "storage/BundleStorage.h"
#include "core/WallClock.h"
#include "routing/BaseRouter.h"

#include "net/ConnectionManager.h"
#include "net/ConvergenceLayer.h"

#include <ibrdtn/data/Serializer.h>
#include <ibrdtn/data/EID.h>
#include <ibrdtn/data/CustodySignalBlock.h>

#include <vector>
#include <set>
#include <map>

using namespace dtn::data;

namespace dtn
{
        namespace core
        {
                class BundleCore : public dtn::daemon::IntegratedComponent, public dtn::core::EventReceiver, public dtn::data::Validator
                {
                public:
                        static dtn::data::EID local;

                        static BundleCore& getInstance();

                        WallClock& getClock();

                        void setStorage(dtn::storage::BundleStorage *storage);
                        dtn::storage::BundleStorage& getStorage();

                        void setRouter(dtn::routing::BaseRouter *router);
                        dtn::routing::BaseRouter& getRouter() const;

                        void transferTo(const dtn::data::EID &destination, const dtn::data::BundleID &bundle);

                        void addConvergenceLayer(dtn::net::ConvergenceLayer *cl);

                        void addConnection(const dtn::core::Node &n);
                        void removeConnection(const dtn::core::Node &n);

                        void addRoute(const dtn::data::EID &destination, const dtn::data::EID &nexthop, size_t timeout = 0);

                        void removeRoute(const dtn::data::EID &destination, const dtn::data::EID &nexthop);

                        const std::set<dtn::core::Node> getNeighbors();

                        bool isNeighbor(const dtn::core::Node &node);

                        const dtn::core::Node getNeighbor(const dtn::data::EID &eid);

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

                        virtual void validate(const dtn::data::PrimaryBlock &obj) const throw (RejectedException);
                        virtual void validate(const dtn::data::Block &obj, const size_t length) const throw (RejectedException);
                        virtual void validate(const dtn::data::Bundle &obj) const throw (RejectedException);

                        static size_t blocksizelimit;

                        static size_t max_lifetime;

                        static size_t max_timestamp_future;

                        static bool forwarding;

                        virtual const std::string getName() const;

                        static void processBlocks(dtn::data::Bundle &b);

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

                private:
                        BundleCore();

                        virtual ~BundleCore();

                        BundleCore operator=(const BundleCore &k) { return k; };

                        WallClock _clock;

                        dtn::storage::BundleStorage *_storage;
                        dtn::routing::BaseRouter *_router;

                        // generator for statusreports
                        StatusReportGenerator _statusreportgen;

                        // manager class for connections
                        dtn::net::ConnectionManager _connectionmanager;
                };
        }
}

#endif /*BUNDLECORE_H_*/