ListParser.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_ListParser_
#define HH_SENF_Packets_ListParser_ 1

// Custom includes
#include <boost/utility/enable_if.hpp>
#include "PacketParser.hh"

//#include "ListParser.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    namespace detail { template <class Container> class ListParser_Iterator; }

    template <class ListPolicy>
    class ListParser_Container;

    template <class ListPolicy>
    class ListParser
        : public PacketParserBase,
          private ListPolicy
    {
    public:
        typedef ListPolicy policy;

        ListParser(data_iterator i, state_type s);
        ListParser(ListPolicy policy, data_iterator i, state_type s);

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

        static const size_type init_bytes = ListPolicy::init_bytes;

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

        typedef typename ListPolicy::element_type value_type;
        typedef typename ListPolicy::container_type container_type;

        container_type container() const;

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

        value_type front() const;
        value_type back() const;

        template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
        template <class Range>
        void assign(Range const & range);

        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;

        static ListParser & get(ListPolicy & p);
        static ListParser const & get(ListPolicy const & p);

    private:
        template <class Policy> friend class ListParser_Container;
    };

    template <class ListPolicy>
    class ListParser_Container
        : private ListPolicy
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef ListPolicy policy;
        typedef typename ListPolicy::parser_type parser_type;
        typedef PacketParserBase::data_iterator data_iterator;
        typedef PacketParserBase::size_type size_type;
        typedef PacketParserBase::difference_type difference_type;
        typedef typename ListPolicy::element_type value_type;
        typedef detail::ListParser_Iterator<ListParser_Container> iterator;
        typedef iterator const_iterator;
        typedef PacketParserBase::state_type state_type;

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

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

        ListParser_Container(parser_type const & list);
        ~ListParser_Container();

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

        //\{

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

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

        value_type front() const;
        value_type back() const;

        //\}
        //\{

        // All these operations can be quite inefficient depending on the list type
        value_type 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);
        template <class ForwardIterator>
#       ifndef DOXYGEN
        void insert(iterator pos, ForwardIterator f, ForwardIterator l,
                    typename boost::disable_if< boost::is_convertible<ForwardIterator,size_type> >::type * = 0);
#       else
        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;

        //\}

    private:
        friend class detail::ListParser_Iterator<ListParser_Container>;

        state_type state_;
        size_type i_;
    };

#   define SENF_PARSER_LIST(name, size, elt_type) \
        SENF_PARSER_LIST_I(public, name, size, elt_type)

#   define SENF_PARSER_PRIVATE_LIST(name, size, elt_type) \
        SENF_PARSER_LIST_I(protected, name, size, elt_type)


    template <class ListPolicy, class OutputIterator>
    void copy(ListParser_Container<ListPolicy> container, OutputIterator result);

}

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