daemon/src/api/Registration.h

Go to the documentation of this file.

/*
 * Registration.h
 *
 *  Created on: 15.06.2011
 *      Author: morgenro
 */

#ifndef REGISTRATION_H_
#define REGISTRATION_H_

#include "storage/BundleStorage.h"
#include <ibrdtn/data/BundleID.h>
#include <ibrdtn/data/BundleList.h>
#include <ibrcommon/thread/Queue.h>
#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/thread/Timer.h>
#include <string>
#include <set>

namespace dtn
{
        namespace api
        {
                class Registration
                {
                public:
                        enum NOTIFY_CALL
                        {
                                NOTIFY_BUNDLE_AVAILABLE = 0,
                                NOTIFY_NEIGHBOR_AVAILABLE = 1,
                                NOTIFY_NEIGHBOR_UNAVAILABLE = 2,
                                NOTIFY_SHUTDOWN = 3
                        };

                        class RegistrationException : public ibrcommon::Exception
                        {
                        public:
                                RegistrationException(string what = "") throw() : Exception(what)
                                {
                                }
                        };

                        class AlreadyAttachedException : public RegistrationException
                        {
                        public:
                                AlreadyAttachedException(string what = "") throw() : RegistrationException(what)
                                {
                                }
                        };

                        class NotFoundException : public RegistrationException
                        {
                        public:
                                NotFoundException(string what = "") throw() : RegistrationException(what)
                                {
                                }
                        };

                        class NotPersistentException : public RegistrationException
                        {
                        public:
                                NotPersistentException(string what = "") throw() : RegistrationException(what)
                                {
                                }
                        };

                        Registration();

                        virtual ~Registration();

                        void notify(const NOTIFY_CALL);

                        NOTIFY_CALL wait();

                        void wait_for_bundle(size_t timeout = 0);

                        void subscribe(const dtn::data::EID &endpoint);

                        void unsubscribe(const dtn::data::EID &endpoint);

                        bool hasSubscribed(const dtn::data::EID &endpoint);

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

                        bool operator==(const std::string&) const;

                        bool operator==(const Registration&) const;

                        bool operator<(const Registration&) const;

                        dtn::data::Bundle receive() throw (dtn::storage::BundleStorage::NoBundleFoundException);

                        dtn::data::MetaBundle receiveMetaBundle() throw (dtn::storage::BundleStorage::NoBundleFoundException);

                        void delivered(const dtn::data::MetaBundle &m);

                        const dtn::data::EID& getDefaultEID() const;

                        const std::string& getHandle() const;

                        void abort();

                        void reset();

                        void setPersistent(ibrcommon::Timer::time_t lifetime);

                        void unsetPersistent();

                        bool isPersistent();

                        bool isPersistent() const;

                        ibrcommon::Timer::time_t getExpireTime() const;

                        void attach();

                        void detach();

                protected:
                        void underflow();

                private:
                        ibrcommon::Queue<dtn::data::MetaBundle> _queue;
                        const std::string _handle;
                        const dtn::data::EID _default_eid;

                        ibrcommon::Mutex _endpoints_lock;
                        std::set<dtn::data::EID> _endpoints;
                        dtn::data::BundleList _received_bundles;

                        ibrcommon::Mutex _receive_lock;
                        ibrcommon::Conditional _wait_for_cond;
                        bool _no_more_bundles;

                        ibrcommon::Queue<NOTIFY_CALL> _notify_queue;

                        static const std::string alloc_handle();
                        static void free_handle(const std::string &handle);

                        static std::set<std::string> _handles;

                        bool _persistent;
                        bool _detached;
                        ibrcommon::Mutex _attach_lock;
                        ibrcommon::Timer::time_t _expiry;
                };
        }
}

#endif /* REGISTRATION_H_ */