ibrdtn/ibrdtn/api/Bundle.h

Go to the documentation of this file.

/*
 * Bundle.h
 *
 *  Created on: 24.07.2009
 *      Author: morgenro
 */

#ifndef API_BUNDLE_H_
#define API_BUNDLE_H_

#include "ibrdtn/data/EID.h"
#include "ibrdtn/data/Bundle.h"
#include <ibrcommon/data/BLOB.h>

#include <iostream>
#include <fstream>

namespace dtn
{
        namespace api
        {
                class Bundle
                {
                public:
                        enum BUNDLE_PRIORITY
                        {
                                PRIO_LOW = 0,
                                PRIO_MEDIUM = 1,
                                PRIO_HIGH = 2
                        };

                        Bundle();

                        Bundle(const dtn::data::EID &destination);

                        virtual ~Bundle();

                        void setLifetime(unsigned int lifetime);

                        unsigned int getLifetime() const;

                        void requestDeliveredReport();

                        void requestForwardedReport();

                        void requestDeletedReport();

                        void requestReceptionReport();

                        void requestCustodyTransfer();

                        void requestEncryption();

                        void requestSigned();

                        bool statusVerified();

                        void setPriority(BUNDLE_PRIORITY p);

                        BUNDLE_PRIORITY getPriority() const;

                        friend std::ostream &operator<<(std::ostream &stream, const dtn::api::Bundle &b)
                        {
                                // To send a bundle, we construct a default serializer. Such a serializer convert
                                // the bundle data to the standardized form as byte stream.
                                dtn::data::DefaultSerializer(stream) << b._b;

                                // Since this method is used to serialize bundles into an StreamConnection, we need to call
                                // a flush on the StreamConnection. This signals the stream to set the bundle end flag on
                                // the last segment of streaming.
                                stream.flush();

                                // To support concatenation of streaming calls, we return the reference to the output stream.
                                return stream;
                        }

                        friend std::istream &operator>>(std::istream &stream, dtn::api::Bundle &b)
                        {
                                // To receive a bundle, we construct a default deserializer. Such a deserializer
                                // convert a byte stream into a bundle object. If this deserialization fails
                                // an exception will be thrown.
                                dtn::data::DefaultDeserializer(stream) >> b._b;

                                // To support concatenation of streaming calls, we return the reference to the input stream.
                                return stream;
                        }

                        ibrcommon::BLOB::Reference getData() throw (dtn::MissingObjectException);

                        void setDestination(const dtn::data::EID &eid, const bool singleton = true);

                        void setReportTo(const dtn::data::EID &eid);

                        dtn::data::EID getDestination() const;

                        dtn::data::EID getSource() const;

                        dtn::data::EID getReportTo() const;

                        dtn::data::EID getCustodian() const;

                        bool operator<(const Bundle& other) const;

                        bool operator>(const Bundle& other) const;

                protected:
                        Bundle(const dtn::data::Bundle &b);

                        // base bundle object
                        dtn::data::Bundle _b;
                };
        }
}

#endif /* API_BUNDLE_H_ */