PacketParser.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_PacketParser_
#define HH_SENF_Packets_PacketParser_ 1

// Custom includes
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/optional.hpp>
#include "PacketTypes.hh"
#include "PacketData.hh"
#include "ParseHelpers.hh"
#include "SafeIterator.hh"

//#include "PacketParser.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    class Packet;

    class PacketParserBase
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef detail::packet::iterator data_iterator; 
        typedef detail::packet::size_type size_type; 
        typedef detail::packet::difference_type difference_type; 
        typedef detail::packet::byte byte; 
        typedef PacketData * state_type; 
        typedef PacketParserBase parser_base_type; 

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

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

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

        data_iterator i() const;        

        data_iterator i(size_type offset) const; 

        state_type state() const;       

        PacketData & data() const;      

        void init() const;              

    private:
        struct ParserProtector {
            senf::safe_data_iterator safe_i_;
            mutable PacketParserBase const * parser_;

            ParserProtector(PacketParserBase const * parser);
            ParserProtector(ParserProtector const & other_);
            ~ParserProtector();
        };
    protected:
        ParserProtector protect() const;

        PacketParserBase(data_iterator i, state_type s); 

        PacketParserBase(data_iterator i, state_type s, size_type size);

        bool check(size_type size) const; 

        void validate(size_type size) const; 

        template <class Parser> Parser parse(data_iterator i) const; 

        template <class Parser, class Arg> Parser parse(Arg const & arg, data_iterator i) const;

        template <class Parser> Parser parse(size_type n) const; 

        template <class Parser, class Arg> Parser parse(Arg const & arg, size_type n) const;

        void defaultInit() const;       

        Packet packet() const;          

        void resize(size_type oldSize, size_type newSize); 

    private:
        data_iterator end() const;

        data_iterator i_;
        PacketData * data_;

        template <class Parser> friend class SafePacketParserWrapper;
        friend struct ParserProtector;
    };

    template <class Parser>
    PacketParserBase::size_type bytes(Parser const & p);

    namespace detail { template <class Parser> struct ParserInitBytes; }
    namespace detail { template <class Parser> struct ParserIsFixed; }

    template <class Parser>
    struct init_bytes : public detail::ParserInitBytes<Parser>
    {};

    template <class Parser>
    struct is_fixed : public detail::ParserIsFixed<Parser>
    {};

#   ifndef DOXYGEN

    template <class Parser>
    typename boost::enable_if_c<
        boost::is_base_of<PacketParserBase, Parser>::value
            && senf::is_fixed<Parser>::value,
        Parser >::type
    operator<<(Parser const & target, Parser const & source);

    template <class Parser>
    typename boost::enable_if_c<
        boost::is_base_of<PacketParserBase, Parser>::value
            && ! senf::is_fixed<Parser>::value,
        Parser >::type
    operator<<(Parser const & target, Parser const & source);

#   else

    template <class Parser>
    Parser operator<<(Parser const & target, Parser const & source);
#   endif

#   ifndef DOXYGEN
    template <class Parser, class Value>
    typename boost::enable_if_c <
        boost::is_base_of<PacketParserBase, Parser>::value
            && ! boost::is_base_of<PacketParserBase, Value>::value,
        Parser >::type
    operator<<(Parser target, Value const & value);
#   else

    template <class Parser, class Value>
    Parser operator<<(Parser target, Value const & value);
#   endif

#   ifndef DOXYGEN
    template <class Parser, class Value>
    typename boost::enable_if_c <
        boost::is_base_of<PacketParserBase, Parser>::value
            && ! boost::is_base_of<PacketParserBase, Value>::value,
        Parser >::type
    operator<<(Parser target, boost::optional<Value> const & value);
#   else

    template <class Parser, class Value>
    Parser operator<<(Parser target, boost::optional<Value> const & value);
#   endif

    struct VoidPacketParser
        : public PacketParserBase
    {
#       include SENF_FIXED_PARSER()
        SENF_PARSER_FINALIZE( VoidPacketParser );
    };


    template <class Parser, typename ValueType>
    struct ArrayValueParserBase : public PacketParserBase
    {
        typedef ArrayValueParserBase<Parser, ValueType> Base;

        static size_type const fixed_bytes = ValueType::static_size;
        typedef ValueType value_type;

        ArrayValueParserBase(data_iterator i, state_type s);

        value_type value() const { return value_type::from_data(i()); }
        void value(value_type const & v) { std::copy(v.begin(), v.end(), i()); }

        operator value_type () const;
        byte & operator[](size_type index);
        byte const & operator[](size_type index) const;
        Parser const & operator= (value_type const & other);

        bool operator==(Parser const & other) const;
    };

    template <class Parser, typename ValueType>
    bool operator==(ArrayValueParserBase<Parser, ValueType> const & parser, ValueType const & value);

    template <class Parser, typename ValueType>
    bool operator!=(ArrayValueParserBase<Parser, ValueType> const & parser, ValueType const & value);

    template <class Parser, typename ValueType>
    bool operator==(ValueType const & value, ArrayValueParserBase<Parser, ValueType> const & parser);

    template <class Parser, typename ValueType>
    bool operator!=(ValueType const & value, ArrayValueParserBase<Parser, ValueType> const & parser);

}

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