VectorParser.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Packets_VectorParser_
#define HH_SENF_Packets_VectorParser_ 1

// Custom includes
#include <boost/type_traits/is_convertible.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_type;

        container_type container() const;

        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 InputIterator>
        void assign(InputIterator first, InputIterator last);

        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: