Search:

SENF Extensible Network Framework

• Home
• Download
• Wiki
• BerliOS
• ChangeLog
• Browse SVN
• Bug Tracker

PacketImpl.hh

Go to the documentation of this file.

// $Id: PacketImpl.hh 1742 2010-11-04 14:51:56Z g0dil $
//
// Copyright (C) 2007
// Fraunhofer (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HH_SENF_Packets_PacketImpl_
#define HH_SENF_Packets_PacketImpl_ 1

// Custom includes
#include <memory>
#include <vector>
#include <boost/utility.hpp>
#include <boost/static_assert.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <senf/Utils/pool_alloc_mixin.hh>
#include <senf/Utils/singleton.hh>

//#include "PacketImpl.mpp"
#include "PacketImpl.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    struct ComplexAnnotation {};

    void dumpPacketAnnotationRegistry(std::ostream & os);

namespace detail {

    class PacketImpl
        : boost::noncopyable,
          public pool_alloc_mixin<PacketImpl>
    {
    public:
        typedef senf::detail::packet::byte byte;
        typedef senf::detail::packet::raw_container raw_container;
        typedef senf::detail::packet::size_type size_type;
        typedef senf::detail::packet::difference_type difference_type;
        typedef senf::detail::packet::interpreter_list interpreter_list;
        typedef senf::detail::packet::iterator iterator;
        typedef senf::detail::packet::const_iterator const_iterator;
        typedef senf::detail::packet::refcount_t refcount_t;

        // structors

        PacketImpl();
        PacketImpl(size_type size, byte initValue);
        template <class InputIterator>
        PacketImpl(InputIterator b, InputIterator e);
        ~PacketImpl();

        // rerference/memory management

        void add_ref();
        void release();
        refcount_t refcount() const;

        // Interpreter chain

        PacketInterpreterBase * first();
        PacketInterpreterBase * last();

        PacketInterpreterBase * next(PacketInterpreterBase * p);
        PacketInterpreterBase * prev(PacketInterpreterBase * p);

        void appendInterpreter    (PacketInterpreterBase * p);
        void prependInterpreter   (PacketInterpreterBase * p);
        void prependInterpreter   (PacketInterpreterBase * p, PacketInterpreterBase * before);
        void truncateInterpreters (PacketInterpreterBase * p);
        void truncateInterpretersBackwards (PacketInterpreterBase * p);

        // Data container

        iterator begin();
        iterator end();
        size_type size();

        void insert(PacketData * self, iterator pos, byte v);
        void insert(PacketData * self, iterator pos, size_type n, byte v);
        template <class ForwardIterator>
        void insert(PacketData * self, iterator pos, ForwardIterator f, ForwardIterator l);

        void erase(PacketData * self, iterator pos);
        void erase(PacketData * self, iterator first, iterator last);
        void clear(PacketData * self);

        void reserve(size_type n);
        size_type capacity() const;

        // Annotations
        template <class Annotation>
        Annotation & annotation();

        void clearAnnotations();
        void assignAnnotations(PacketImpl const & other);
        void dumpAnnotations(std::ostream & os);

        struct Guard {
            Guard(PacketImpl * impl);
            ~Guard();
            PacketImpl * p;
        };

    private:
        void eraseInterpreters(interpreter_list::iterator b, interpreter_list::iterator e);
        void updateIterators(PacketData * self, difference_type pos, difference_type n);

        void * annotation(AnnotationRegistry::key_type key); // may return 0 !
        void * complexAnnotation(AnnotationRegistry::key_type key); // may return 0 !
        template <class Annotation>
        void * complexAnnotation();

        refcount_t refcount_;
        raw_container data_;
        interpreter_list interpreters_;

        union SimpleAnnotationSlot
        {
            unsigned char _ [SENF_PACKET_ANNOTATION_SLOTSIZE];
        };

        typedef boost::ptr_vector< boost::nullable<AnnotationRegistry::EntryBase> >
            ComplexAnnotations;
        ComplexAnnotations complexAnnotations_;

        SimpleAnnotationSlot simpleAnnotations_[SENF_PACKET_ANNOTATION_SLOTS];
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#endif
#if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_PacketImpl_i_)
#define HH_SENF_Packets_PacketImpl_i_
#include "PacketImpl.cci"
#include "PacketImpl.ct"
#include "PacketImpl.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End:

---

Contact: senf-dev@lists.berlios.de | © 2006-2010 Fraunhofer Institute for Open Communication Systems, Network Research