Registration.h

Go to the documentation of this file.

/*
 * Registration.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#ifndef REGISTRATION_H_
#define REGISTRATION_H_

#include "storage/BundleStorage.h"
#include "storage/BundleResult.h"
#include <ibrdtn/data/BundleID.h>
#include <ibrdtn/data/BundleSet.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:
                        static const std::string TAG;

                        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::NoBundleFoundException);

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

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

                        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;

                        void setFilterFragments(bool val);

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

                        void attach();

                        void detach();

                        static void processIncomingBundle(const dtn::data::EID &source, dtn::data::Bundle &bundle);

                protected:
                        void underflow();

                private:
                        class RegistrationQueue : public dtn::storage::BundleResult {
                        public:
                                RegistrationQueue();

                                virtual ~RegistrationQueue();

                                virtual void put(const dtn::data::MetaBundle &bundle) throw ();

                                dtn::data::MetaBundle pop() throw (const ibrcommon::QueueUnblockedException);

                                void expire(const dtn::data::Timestamp &timestamp) throw ();

                                void abort() throw ();

                                void reset() throw ();

                                bool has(const dtn::data::BundleID &bundle) const throw ();

                        private:
                                // protect variables against concurrent altering
                                ibrcommon::Mutex _lock;

                                // all bundles have to remain in this set to avoid duplicate delivery
                                dtn::data::BundleSet _recv_bundles;

                                // queue where the currently queued bundles are stored
                                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;
                        RegistrationQueue _queue;

                        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;

                        bool _filter_fragments;
                };
        }
}

#endif /* REGISTRATION_H_ */