NativeSession.h

Go to the documentation of this file.

/*
 * NativeSession.h
 *
 * Copyright (C) 2013 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 NATIVESESSION_H_
#define NATIVESESSION_H_

#include "api/NativeSerializerCallback.h"
#include "api/Registration.h"
#include "core/EventReceiver.h"
#include <ibrdtn/data/Bundle.h>
#include <ibrdtn/data/StatusReportBlock.h>
#include <ibrdtn/data/CustodySignalBlock.h>
#include <ibrcommon/thread/Thread.h>
#include <ibrcommon/thread/Queue.h>
#include <ibrcommon/thread/RWMutex.h>
#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/Exceptions.h>

namespace dtn
{
        namespace api
        {
                class NativeSessionException : public ibrcommon::Exception
                {
                public:
                        NativeSessionException(string what = "An error happened.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class BundleNotFoundException : public ibrcommon::Exception
                {
                public:
                        BundleNotFoundException(string what = "Bundle not found.") throw() : ibrcommon::Exception(what)
                        {
                        };
                };

                class NativeSessionCallback {
                public:
                        virtual ~NativeSessionCallback() = 0;

                        virtual void notifyBundle(const dtn::data::BundleID &id) throw () = 0;

                        virtual void notifyStatusReport(const dtn::data::EID &source, const dtn::data::StatusReportBlock &report) throw () = 0;

                        virtual void notifyCustodySignal(const dtn::data::EID &source, const dtn::data::CustodySignalBlock &custody) throw () = 0;
                };

                class NativeSession {
                        static const std::string TAG;

                public:
                        enum RegisterIndex {
                                REG1 = 0,
                                REG2 = 1
                        };

                        NativeSession(NativeSessionCallback *session_cb, NativeSerializerCallback *serializer_cb);

                        NativeSession(NativeSessionCallback *session_cb, NativeSerializerCallback *serializer_cb, const std::string &handle);

                        virtual ~NativeSession();

                        void destroy() throw ();

                        const dtn::data::EID& getNodeEID() const throw ();

                        void setEndpoint(const std::string &suffix) throw (NativeSessionException);

                        void resetEndpoint() throw ();

                        void addEndpoint(const std::string &suffix) throw (NativeSessionException);

                        void removeEndpoint(const std::string &suffix) throw (NativeSessionException);

                        void addRegistration(const dtn::data::EID &eid) throw (NativeSessionException);

                        void removeRegistration(const dtn::data::EID &eid) throw (NativeSessionException);

                        void clearRegistration() throw ();

                        std::vector<std::string> getSubscriptions() throw ();

                        void next(RegisterIndex ri) throw (BundleNotFoundException);

                        void load(RegisterIndex ri, const dtn::data::BundleID &id) throw (BundleNotFoundException);

                        void get(RegisterIndex ri) throw ();

                        void getInfo(RegisterIndex ri) throw ();

                        void free(RegisterIndex ri) throw (BundleNotFoundException);

                        void clear(RegisterIndex ri) throw ();

                        void delivered(const dtn::data::BundleID &id) const throw (BundleNotFoundException);

                        dtn::data::BundleID send(RegisterIndex ri) throw ();

                        void put(RegisterIndex ri, const dtn::data::Bundle &b) throw ();

                        void put(RegisterIndex ri, const dtn::data::PrimaryBlock &b) throw ();

                        void write(RegisterIndex ri, const char *buf, const size_t len, const size_t offset = std::string::npos) throw ();

                        void read(RegisterIndex ri, char *buf, size_t &len, const size_t offset = 0) throw ();

                        void receive() throw (NativeSessionException);

                        const std::string& getHandle() const;

                private:
                        // local registration
                        dtn::api::Registration _registration;

                        class BundleReceiver : public dtn::core::EventReceiver
                        {
                        public:
                                BundleReceiver(NativeSession &session);
                                virtual ~BundleReceiver();

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

                        private:
                                NativeSession &_session;
                        } _receiver;

                        void fireNotificationBundle(const dtn::data::BundleID &id) throw ();

                        void fireNotificationAdministrativeRecord(const dtn::data::MetaBundle &bundle);

                        void fireNotificationStatusReport(const dtn::data::EID &source, const dtn::data::StatusReportBlock &report) throw ();

                        void fireNotificationCustodySignal(const dtn::data::EID &source, const dtn::data::CustodySignalBlock &custody) throw ();

                        // callback
                        ibrcommon::RWMutex _cb_mutex;
                        NativeSessionCallback *_session_cb;
                        NativeSerializerCallback *_serializer_cb;

                        // default endpoint
                        dtn::data::EID _endpoint;

                        // local bundle register
                        dtn::data::Bundle _bundle[2];

                        // local bundle queue
                        ibrcommon::Queue<dtn::data::BundleID> _bundle_queue;
                };
        } /* namespace net */
} /* namespace dtn */
#endif /* NATIVESESSION_H_ */