Search:

SENF Extensible Network Framework

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

VectorParser.hh

Go to the documentation of this file.

// $Id: VectorParser.hh 1756 2011-01-06 10:10:07Z tho $
//
// Copyright (C) 2006
// 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_VectorParser_
#define HH_SENF_Packets_VectorParser_ 1

// Custom includes
#include <boost/type_traits.hpp>
#include "PacketParser.hh"
#include "ArrayParser.hh" // for ArrayParser_iterator
#include "AuxParser.hh" // for the AuxPolicies

//#include "VectorParser.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    template <class ElementParser, class AuxPolicy> class VectorParser_Container;

    template <class ElementParser, class AuxPolicy>
    struct VectorParser
        : public PacketParserBase,
          private AuxPolicy
    {
        VectorParser(data_iterator i, state_type s);
        VectorParser(AuxPolicy policy, data_iterator i, state_type s);

        size_type bytes() const;
        void init() const;

        static const size_type init_bytes = AuxPolicy::aux_bytes;

        //-////////////////////////////////////////////////////////////////////////
        // Container interface

        typedef ElementParser value_type;
        typedef detail::ArrayParser_iterator<value_type> iterator;
        typedef iterator const_iterator;
        typedef VectorParser_Container<ElementParser,AuxPolicy> container;

        size_type size() const;
        bool empty() const;

        iterator begin() const;
        iterator end() const;

        value_type operator[](difference_type i) const;
        value_type front() const;
        value_type back() const;

        // Mutators

        // The mutators provided here are those which don't take an iterator argument.
        // If you need to pass an iterator it is much simpler and cleaner to use the
        // 'container' wrapper

        template <class Value> void push_back        (Value const & value, size_type n=1) const;
        value_type                  push_back_space  (size_type n=1) const;
        template <class Value> void push_front       (Value const & value, size_type n=1) const;
        value_type                  push_front_space (size_type n=1) const;
        void                        resize           (size_type n) const;
        template <class Value> void resize           (size_type n, Value value) const;

     private:

        friend class VectorParser_Container<ElementParser,AuxPolicy>;
    };

    template <class ElementParser, class AuxPolicy>
    class VectorParser_Container
        : private AuxPolicy::WrapperPolicy
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef VectorParser<ElementParser,AuxPolicy> parser_type;
        typedef PacketParserBase::data_iterator data_iterator;
        typedef PacketParserBase::size_type size_type;
        typedef PacketParserBase::difference_type difference_type;
        typedef ElementParser value_type;
        typedef detail::ArrayParser_iterator<value_type> iterator;
        typedef iterator const_iterator;
        typedef PacketParserBase::state_type state_type;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        // no default constructor
        // default copy
        // default destructor
        // conversion constructors

        VectorParser_Container(parser_type const & vector);

        //\}
        //-////////////////////////////////////////////////////////////////////////

        //\{

        size_type size() const;
        bool empty() const;

        iterator begin() const;
        iterator end() const;

        value_type operator[](difference_type i) const;
        value_type front() const;
        value_type back() const;

        //\}
        //\{

        iterator shift(iterator pos, size_type n=1);
        template <class Value>
        void insert(iterator pos, Value const & t);
        template <class Value>
        void insert(iterator pos, size_type n, Value const & t);
#       ifndef DOXYGEN
        template <class ForwardIterator>
        void insert(iterator pos, ForwardIterator f, ForwardIterator l,
                    typename boost::disable_if< boost::is_convertible<ForwardIterator,size_type> >::type * = 0);
#       else
        template <class ForwardIterator>
        void insert(iterator pos, ForwardIterator f, ForwardIterator l);
#       endif

        void erase(iterator pos, size_type n=1);
        void erase(iterator f, iterator l);
        void clear();

        template <class Value> void push_back        (Value const & value, size_type n=1);
        value_type                  push_back_space  (size_type n=1);
        template <class Value> void push_front       (Value const & value, size_type n=1);
        value_type                  push_front_space (size_type n=1);
        void                        resize           (size_type n);
        template <class Value> void resize           (size_type n, Value value);

        //\}

        //\{

        parser_type parser() const;
        data_iterator i() const;
        state_type state() const;
        PacketData & data() const;

        size_type bytes() const;
        void init() const;

        //\}

    protected:

    private:
        void setSize(size_type value);

        state_type state_;
        size_type i_;
    };

#   define SENF_PARSER_VECTOR(name, size, elt_type) \
        SENF_PARSER_VECTOR_I(public, name, size, elt_type)

#   define SENF_PARSER_PRIVATE_VECTOR(name, size, elt_type) \
        SENF_PARSER_VECTOR_I(protected, name, size, elt_type)
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#endif
#if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_VectorParser_i_)
#define HH_SENF_Packets_VectorParser_i_
//#include "VectorParser.cci"
#include "VectorParser.ct"
#include "VectorParser.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