Block.h

Go to the documentation of this file.

/*
 * Block.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 BLOCK_H_
#define BLOCK_H_

#include "ibrdtn/data/EID.h"
#include "ibrdtn/data/Exceptions.h"
#include "ibrdtn/data/Number.h"
#include "ibrdtn/data/Dictionary.h"
#include "ibrdtn/data/Serializer.h"
#include <ibrcommon/Exceptions.h>
#include <list>

namespace dtn
{
        namespace data
        {
                class BundleBuilder;

                class Block
                {
                        friend class BundleBuilder;

                public:
                        enum ProcFlags
                        {
                                REPLICATE_IN_EVERY_FRAGMENT = 1,                        // 0 - Block must be replicated in every fragment.
                                TRANSMIT_STATUSREPORT_IF_NOT_PROCESSED = 1 << 0x01, // 1 - Transmit status report if block can't be processed.
                                DELETE_BUNDLE_IF_NOT_PROCESSED = 1 << 0x02,             // 2 - Delete bundle if block can't be processed.
                                LAST_BLOCK = 1 << 0x03,                                                         // 3 - Last block.
                                DISCARD_IF_NOT_PROCESSED = 1 << 0x04,                           // 4 - Discard block if it can't be processed.
                                FORWARDED_WITHOUT_PROCESSED = 1 << 0x05,                        // 5 - Block was forwarded without being processed.
                                BLOCK_CONTAINS_EIDS = 1 << 0x06                                         // 6 - Block contains an EID-reference field.
                        };

                        typedef std::list<dtn::data::EID> eid_list;

                        virtual ~Block();

                        Block& operator=(const Block &block);

                        bool operator==(const block_t &id) const;

                        virtual void addEID(const dtn::data::EID &eid);
                        virtual void clearEIDs();
                        virtual const eid_list& getEIDList() const;

                        const block_t& getType() const { return _blocktype; }

                        void set(ProcFlags flag, const bool &value);
                        bool get(ProcFlags flag) const;
                        const Bitset<ProcFlags>& getProcessingFlags() const;

                        virtual std::ostream &serialize(std::ostream &stream, Length &length) const = 0;

                        virtual std::istream &deserialize(std::istream &stream, const Length &length) = 0;

                        virtual Length getLength() const = 0;

                        virtual Length getLength_strict() const;

                        virtual std::ostream &serialize_strict(std::ostream &stream, Length &length) const;

                protected:
                        Block(block_t blocktype);

                        // block type of this block
                        block_t _blocktype;

                        // the list of EID references embedded in this block
                        eid_list _eids;

                private:
                        // block processing flags
                        Bitset<ProcFlags> _procflags;
                };
        }
}

#endif /* BLOCK_H_ */