// $Id$
//
// Copyright (C) 2007
// Fraunhofer Institute for Open Communication Systems (FOKUS)
//
// The contents of this file are subject to the Fraunhofer FOKUS Public License
// Version 1.0 (the "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
// http://senf.berlios.de/license.html
//
// The Fraunhofer FOKUS Public License Version 1.0 is based on,
// but modifies the Mozilla Public License Version 1.1.
// See the full license text for the amendments.
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
// for the specific language governing rights and limitations under the License.
//
// The Original Code is Fraunhofer FOKUS code.
//
// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
// (registered association), Hansastraße 27 c, 80686 Munich, Germany.
//
// Contributor(s):
//   Stefan Bund <g0dil@berlios.de>
/** \file
     \brief ParseHelpers internal header */

# if !defined(IH_ParseHelpers_)
# define IH_ParseHelpers_ 1
#
# // Custom includes
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/if.hpp>
# include <boost/preprocessor/expand.hpp>
# include <boost/preprocessor/facilities/is_empty.hpp>
# include <boost/preprocessor/punctuation/comma.hpp>
# include "../Utils/preprocessor.hh"
# include "../Utils/mpl.hh"
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_INITIALIZE
#
# define SENF_PARSER_INITIALIZE  BOOST_PP_CAT( SENF_PARSER_INITIALIZE_ , SENF_PARSER_TYPE )
#
# define SENF_PARSER_INITIALIZE_fix()                                                             \
    private:                                                                                      \
        SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
        SENF_MPL_SLOT_DEF_ZERO(offset);                                                           \
        SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
        SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
        void init_chain(senf::mpl::rv<0>*) const {}                                               \
    public:
#
# define SENF_PARSER_INITIALIZE_var()                                                             \
    private:                                                                                      \
        SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
        SENF_MPL_SLOT_DEF_ZERO(init_bytes);                                                       \
        SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
        SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
        SENF_MPL_SLOT_DEF_ZERO(group);                                                            \
        void init_chain(senf::mpl::rv<0>*) const {}                                               \
        size_type field_offset_(senf::mpl::rv<0>*) const { return 0; }                            \
    public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_INHERIT_*
#
# define SENF_PARSER_INHERIT_var(name)                                                            \
        typedef name parser_base_type;                                                            \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(index, 1);                                                              \
        SENF_MPL_SLOT_SET(init_bytes, senf::init_bytes<name>::value);                             \
        size_type field_offset_(senf::mpl::rv<1>*) const {                                        \
            return senf::bytes( *static_cast<name const*>(this) );                                \
        }                                                                                         \
        void init_chain(senf::mpl::rv<1>*) const {                                                \
            name::init();                                                                         \
        }                                                                                         \
    public:
#
# define SENF_PARSER_INHERIT_fix(name)                                                            \
        typedef name parser_base_type;                                                            \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(offset, name::fixed_bytes);                                             \
        SENF_MPL_SLOT_SET(index, 1);                                                              \
        void init_chain(senf::mpl::rv<1>*) const {                                                \
            name::init();                                                                         \
        }                                                                                         \
    public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_FIELD*
# // SENF_PARSER_P_FIELD_*
#
# define SENF_PARSER_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, public)
# define SENF_PARSER_FIELD_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, public)
# define SENF_PARSER_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, public)
# define SENF_PARSER_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, public)
#
# define SENF_PARSER_P_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, protected)
# define SENF_PARSER_P_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, protected)
#
# define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access)                                 \
    access:                                                                                       \
        SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access)                            \
        BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                       \
    public:
#
# define SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access)                           \
        SENF_PARSER_I_BITFIELD_RESET()                                                            \
        SENF_PARSER_I_FIELD_INTRO(name, type, access)                                             \
        BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type, access)                      \
        BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                      \
        BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                       \
            name, type,                                                                           \
            BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type),                              \
            BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type),                         \
            BOOST_PP_CAT(SENF_PARSER_I_ISVAR_, ofstype) (name, type),                             \
            access )
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_FIELD_INTRO
#
# define SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
        typedef type BOOST_PP_CAT(name, _t);                                                      \
        static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1;            \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index));                                      \
    access:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_FIELD_INIT_*
#
# define SENF_PARSER_I_FIELD_INIT_rw(name, type, access)                                          \
    private:                                                                                      \
        void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
            init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
            name().init();                                                                        \
        }                                                                                         \
    access:
#
# define SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
    private:                                                                                      \
        void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
            init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
        }                                                                                         \
    access:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_FIELD_OFS_*
#
# define SENF_PARSER_I_FIELD_OFS_var(name, type, access)                                          \
    protected:                                                                                    \
        size_type BOOST_PP_CAT(name,_offset)() const {                                            \
            return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));    \
        }                                                                                         \
        static size_type const BOOST_PP_CAT(name, _init_bytes) =                                  \
            SENF_MPL_SLOT_GET(init_bytes);                                                        \
    private:
#
# define SENF_PARSER_I_FIELD_OFS_fix(name, type, access)                                          \
    protected:                                                                                    \
        static size_type const BOOST_PP_CAT(name, _offset) =                                      \
            SENF_MPL_SLOT_GET(offset);                                                            \
    private:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_ADVANCE_OFS_*
#
# define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(BOOST_PP_CAT(name, _)())
# define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes<type>::value
#
# define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes
# define SENF_PARSER_I_INITBYTES_fix(name, type) void
#
# define SENF_PARSER_I_ISVAR_fix(name, type) 0
# define SENF_PARSER_I_ISVAR_var(name, type) (senf::is_fixed<type>::value?0:1)
#
# define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize, isvar, access)                    \
        size_type BOOST_PP_CAT(name, _next_offset)() const {                                      \
            return BOOST_PP_CAT(name,_offset)() + size;                                           \
        }                                                                                         \
        static size_type const BOOST_PP_CAT(name, _next_init_bytes) =                             \
            BOOST_PP_CAT(name, _init_bytes) + isize;                                              \
    private:                                                                                      \
        size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                \
            return BOOST_PP_CAT(name, _next_offset)();                                            \
        }                                                                                         \
        SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes));                       \
    protected:                                                                                    \
        static size_type const BOOST_PP_CAT(name, _group) = SENF_MPL_SLOT_GET(group) + isvar;     \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(group, BOOST_PP_CAT(name, _group));                                     \
    access:
#
# define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, isvar, access)                    \
        static size_type const BOOST_PP_CAT(name, _next_offset) =                                 \
            BOOST_PP_CAT(name, _offset) + size;                                                   \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset));                              \
    access:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_FIELD_VAL_*
#
# define SENF_PARSER_I_FIELD_VAL_rw(name, type, access)                                           \
    protected:                                                                                    \
        BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const {                                    \
            return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
        }                                                                                         \
    access:                                                                                       \
        BOOST_PP_CAT(name, _t) name() const {                                                     \
            return BOOST_PP_CAT(name,_)();                                                        \
        }
#
# define SENF_PARSER_I_FIELD_VAL_ro(name, type, access)                                           \
    protected:                                                                                    \
        BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const {                                    \
            return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
        }                                                                                         \
    access:                                                                                       \
        BOOST_PP_CAT(name, _t)::value_type name() const {                                         \
            return BOOST_PP_CAT(name,_)();                                                        \
        }
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_CUSTOM_FIELD_*
#
# define SENF_PARSER_CUSTOM_FIELD_var(name, type, size, isize)                                    \
      SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, var)
# define SENF_PARSER_CUSTOM_FIELD_fix(name, type, size)                                           \
      SENF_PARSER_CUSTOM_FIELD_I(name, type, size, size, fix)
#
# define SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, ofstype)                             \
        SENF_PARSER_I_BITFIELD_RESET()                                                            \
        SENF_PARSER_I_FIELD_INTRO(name, type, public)                                             \
        SENF_PARSER_I_FIELD_INIT_ro(name, type, public)                                           \
        BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, public)                      \
        BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize, 1, public)    \
        BOOST_PP_CAT(name, _t) name() const
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_BITFIELD_*
# // SENF_PARSER_P_BITFIELD_*
#
# define SENF_PARSER_BITFIELD_var(name, bits, type)                                               \
      SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, public)
# define SENF_PARSER_BITFIELD_RO_var(name, bits, type)                                            \
      SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, public)
# define SENF_PARSER_BITFIELD_fix(name, bits, type)                                               \
      SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, public)
# define SENF_PARSER_BITFIELD_RO_fix(name, bits, type)                                            \
      SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, public)
#
# define SENF_PARSER_P_BITFIELD_var(name, bits, type)                                             \
      SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, protected)
# define SENF_PARSER_P_BITFIELD_fix(name, bits, type)                                             \
      SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, protected)
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_BITFIELD_I
#
# define SENF_PARSER_BITFIELD_TYPE_signed(start, bits)   senf::IntFieldParser<start, start+bits>
# define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::UIntFieldParser<start, start+bits>
# define SENF_PARSER_BITFIELD_TYPE_bool(start, bits)     senf::FlagParser<start>
#
# define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access)                        \
    access:                                                                                       \
        static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit);                 \
    private:                                                                                      \
        SENF_MPL_SLOT_SET(bit, BOOST_PP_CAT(name, _bit) + bits);                                  \
        typedef BOOST_PP_CAT(SENF_PARSER_BITFIELD_TYPE_, type)( BOOST_PP_CAT(name, _bit), bits )  \
             BOOST_PP_CAT(name,_bit_t );                                                          \
    access:                                                                                       \
        SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \
    public:
#
# define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype, access)                       \
         SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
         SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
         BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type, access)                  \
         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                      \
             name, type,                                                                          \
             BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes,            \
             0,                                                                                   \
             access)                                                                              \
    private:                                                                                      \
         SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes);                   \
    access:                                                                                       \
         BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                      \
    public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_BITFIELD_OFS_*
#
# define SENF_PARSER_I_BITFIELD_OFS_var(name, type, access)                                       \
        size_type BOOST_PP_CAT(name,_offset)() const {                                            \
            return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0))     \
                - SENF_MPL_SLOT_GET(bitfield_size);                                               \
        }                                                                                         \
        static size_type const BOOST_PP_CAT(name, _init_bytes) =                                  \
            SENF_MPL_SLOT_GET(init_bytes) - SENF_MPL_SLOT_GET(bitfield_size);
#
# define SENF_PARSER_I_BITFIELD_OFS_fix(name, type, access)                                       \
        static size_type const BOOST_PP_CAT(name, _offset) =                                      \
            SENF_MPL_SLOT_GET(offset) - SENF_MPL_SLOT_GET(bitfield_size);
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_I_BITFIELD_RESET
#
# define SENF_PARSER_I_BITFIELD_RESET()                                                           \
        SENF_MPL_SLOT_SET(bit, 0);                                                                \
        SENF_MPL_SLOT_SET(bitfield_size, 0);
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_SKIP_*
#
# define SENF_PARSER_SKIP_var(bytes, ibytes)                                                      \
      SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var)
#
# define SENF_PARSER_SKIP_fix(bytes)                                                              \
      SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix)
#
# define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype)                                         \
    private:                                                                                      \
          SENF_PARSER_I_BITFIELD_RESET()                                                          \
          SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
          SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
          BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
          BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, bytes, ibytes, 1,        \
                                                             private)                             \
    public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_SKIP_BITS_*
#
# define SENF_PARSER_SKIP_BITS_var(bits) SENF_PARSER_I_SKIP_BITS(bits, var)
# define SENF_PARSER_SKIP_BITS_fix(bits) SENF_PARSER_I_SKIP_BITS(bits, fix)
#
# define SENF_PARSER_I_SKIP_BITS(bits, ofstype)                                                   \
      private:                                                                                    \
          SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits);                                  \
      public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_GOTO_*
#
# define SENF_PARSER_GOTO_var(name)                                                               \
      SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
                          BOOST_PP_CAT(name, _offset)(),                                          \
                          BOOST_PP_CAT(name, _init_bytes),                                        \
                          var )
#
# define SENF_PARSER_GOTO_fix(name)                                                               \
      SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
                          BOOST_PP_CAT(name, _offset),                                            \
                          BOOST_PP_CAT(name, _offset),                                            \
                          fix )
#
# define SENF_PARSER_GOTO_OFFSET_var(offset, isize)                                               \
      SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var )
#
# define SENF_PARSER_GOTO_OFFSET_fix(offset)                                                      \
      SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix )
#
# define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype)                                      \
      private:                                                                                    \
          SENF_PARSER_I_BITFIELD_RESET()                                                          \
          SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
          SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
          BOOST_PP_CAT( SENF_PARSER_I_GOTO_SET_OFS_, ofstype ) (name, offset, initsize)           \
      public:
#
# define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize)                                     \
          size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {              \
              return offs;                                                                        \
          }                                                                                       \
          SENF_MPL_SLOT_SET(init_bytes, initsize);
#
# define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize)                                     \
          SENF_MPL_SLOT_SET(offset, offs);
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_LABEL_*
#
# define SENF_PARSER_LABEL_var(name) SENF_PARSER_I_LABEL( name, var, public )
# define SENF_PARSER_LABEL_fix(name) SENF_PARSER_I_LABEL( name, fix, public )
#
# define SENF_PARSER_I_LABEL(name, ofstype, access)                                               \
      access:                                                                                     \
          SENF_PARSER_I_BITFIELD_RESET()                                                          \
          SENF_PARSER_I_FIELD_INTRO(name, void, access)                                           \
          SENF_PARSER_I_FIELD_INIT_ro(name, void, access)                                         \
          BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
          BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, 0, 0, 0, access)         \
      public:
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_OFFSET_*
#
# define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
# define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)()
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_FIXED_OFFSET_*
#
# define SENF_PARSER_FIXED_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
# define SENF_PARSER_FIXED_OFFSET_var(name) BOOST_PP_CAT(name, _init_bytes)
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_CURRENT_FIXED_OFFSET_*
#
# define SENF_PARSER_CURRENT_FIXED_OFFSET_fix() SENF_MPL_SLOT_GET(offset)
# define SENF_PARSER_CURRENT_FIXED_OFFSET_var() SENF_MPL_SLOT_GET(init_bytes)
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_FINALIZE_*
#
# define SENF_PARSER_FINALIZE_var(name)                                                           \
    SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
    size_type bytes() const {                                                                     \
        return field_offset_(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));           \
    }                                                                                             \
    static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes)
#
# define SENF_PARSER_FINALIZE_fix(name)                                                           \
    SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
    static size_type const fixed_bytes = SENF_MPL_SLOT_GET(offset);
#
# define SENF_PARSER_FINALIZE_GENERIC(name)                                                       \
         void defaultInit() const {                                                               \
             init_chain(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));                \
         }                                                                                        \
         name(data_iterator i, state_type s) : parser_base_type(i,s) {}                           \
    private:                                                                                      \
         template <class T> void init(T) const { defaultInit(); }                                 \
    public:                                                                                       \
         void init() const { init(0); }
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_REQUIRE_VAR
#
# define SENF_PARSER_REQUIRE_VAR(description) \
      BOOST_PP_CAT(SENF_PARSER_REQUIRE_VAR_, SENF_PARSER_TYPE)(description)
#
# define SENF_PARSER_REQUIRE_VAR_var(description)
#
# define SENF_PARSER_REQUIRE_VAR_fix(description)                                                 \
      typedef BOOST_PP_CAT( PARSER_ERROR__,                                                       \
                            BOOST_PP_CAT(description, _not_allowed_in_fixed_parser) )             \
          BOOST_PP_CAT(errsym_, __LINE__);
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_COLLECTION_I
#
# ifndef DOXYGEN
#
  namespace senf { namespace detail { namespace auxtag {
      struct none {}; } } }
  namespace senf { namespace detail { namespace auxtag {
      struct bytes {}; } } }
  namespace senf { namespace detail { namespace auxtag {
      template <class Transform, class Tag>
      struct transform {}; } } }
  namespace senf { namespace detail { namespace auxtag {
      struct packetSize {}; } } }
#
# endif
#
# // Each tag is implemented by defining the following macros. If the Tag is <name>(<args>):
# //   SENF_PARSER_COLLECTION_TAG_GOBBLE__<name>(<args>)
# //       gobble the tag, that is expand to nothing
# //   SENF_PARSER_COLLECTION_TAG__<name>(<args>)
# //       return an intermediate tag. This tag will be used with the next macro to get the aux tag
# //       this indirection is needed since the tag may include templates with more than one
# //       argument which cannot be passed through macros ... Ugh ...
# //   SENF_PARSER_COLLECTION_TAG_EXPAND__<tag>(<tag args>)
# //       expand to the real tag type
# //   SENF_PARSER_COLLECTION_TAG_GETAUX__<name>(<args>)
# //       return the real aux field. More specifically, this is the aux argument to the aux expand
# //       macro
# //   SENF_PARSER_COLLECTION_TAG_AUXTYPE__<name>(<args>)
# //       return an identifier selecting the aux type macro to use. If the expansion of this macro
# //       is <auxtag>, the macro will be called SENF_PARSER_COLLECTION_TAG_AUXDEF__<auxtag>
# //   SENF_PARSER_COLLECTION_TAG_AUXDEF__<auxtag>(<name>,<auxarg>)
# //       this command must declare the typedef <fieldname>_aux_type to the base aux policy
#
# define SENF_PARSER_COLLECTION_TAG_GOBBLE__bytes(x)
# define SENF_PARSER_COLLECTION_TAG__bytes(x) bytes()
# define SENF_PARSER_COLLECTION_TAG_EXPAND__bytes() senf::detail::auxtag::bytes
# define SENF_PARSER_COLLECTION_TAG_GETAUX__bytes(x) x
# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__bytes(x) auxField
#
# define SENF_PARSER_COLLECTION_TAG_GOBBLE__transform(x,y)
# define SENF_PARSER_COLLECTION_TAG__transform(x,y) \
      transform(x, SENF_PARSER_COLLECTION_TAG_RECURS1(y))
# define SENF_PARSER_COLLECTION_TAG_EXPAND__transform(x,y)                                        \
      senf::detail::auxtag::transform<                                                            \
          x,                                                                                      \
          SENF_CAT_RECURS1(SENF_PARSER_COLLECTION_TAG_EXPAND__, y)>
# define SENF_PARSER_COLLECTION_TAG_GETAUX__transform(x,y) \
      SENF_PARSER_COLLECTION_TAG_GETAUX_RECURS1(y)
# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__transform(x,y) \
      SENF_PARSER_COLLECTION_TAG_AUXTYPE_RECURS1(y)
#
# define SENF_PARSER_COLLECTION_TAG_GOBBLE__packetSize()
# define SENF_PARSER_COLLECTION_TAG__packetSize() packetSize()
# define SENF_PARSER_COLLECTION_TAG_EXPAND__packetSize() senf::detail::auxtag::bytes
# define SENF_PARSER_COLLECTION_TAG_GETAUX__packetSize() _
# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__packetSize() packetSize
#
# define SENF_PARSER_COLLECTION_TAG_EXPAND__none() senf::detail::auxtag::none
#
# define SENF_PARSER_COLLECTION_TAG_RECURS1(aux)                                                  \
      BOOST_PP_IF(                                                                                \
          SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                                \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG__, aux),                                        \
          none() )
#
# define SENF_PARSER_COLLECTION_TAG_GETAUX_RECURS1(aux)                                           \
      BOOST_PP_IF(                                                                                \
          SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                                \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux),                                 \
          aux)
#
# define SENF_PARSER_COLLECTION_TAG_AUXTYPE_RECURS1(aux)                                          \
      BOOST_PP_IF(                                                                                \
          SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                                \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_AUXTYPE__, aux),                                \
          auxField)
#
# define SENF_PARSER_COLLECTION_HAS_KEYWORD(x)                                                    \
      BOOST_PP_IS_EMPTY( SENF_CAT_RECURS1(SENF_PARSER_COLLECTION_TAG_GOBBLE__, x) )
#
# define SENF_PARSER_COLLECTION_GETAUX(aux)                                                       \
      BOOST_PP_IF( SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                       \
                   SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux),                    \
                   aux )

# define SENF_PARSER_COLLECTION_I(access, name, aux, traits)                                      \
      BOOST_PP_EXPAND(                                                                            \
          SENF_PARSER_COLLECTION_II                                                               \
              BOOST_PP_IF(                                                                        \
                  SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                        \
                  ( access,                                                                       \
                    name,                                                                         \
                    SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_AUXTYPE__, aux),                  \
                    SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux),                   \
                    SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG__, aux),                          \
                    traits ),                                                                     \
                  ( access,                                                                       \
                    name,                                                                         \
                    auxField,                                                                     \
                    aux,                                                                          \
                    none(),                                                                       \
                    traits ) ))
#
# define SENF_PARSER_COLLECTION_II(access, name, auxtype, aux, tag, traits)                       \
      private:                                                                                    \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_AUXDEF__, auxtype)(name, aux)                   \
          typedef traits::parser<                                                                 \
              BOOST_PP_CAT(name,_aux_policy),                                                     \
              BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_EXPAND__, tag)                              \
              >::type BOOST_PP_CAT(name, _collection_t);                                          \
      access:                                                                                     \
          SENF_PARSER_FIELD_SETUP_I( name,                                                        \
                                     BOOST_PP_CAT(name, _collection_t),                           \
                                     SENF_PARSER_TYPE,                                            \
                                     rw,                                                          \
                                     access )                                                     \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_VAL__, auxtype)(name, aux, access)              \
      public:
#
# define SENF_PARSER_COLLECTION_TAG_AUXDEF__auxField(name, aux)                                   \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUXTYPE_, SENF_PARSER_TYPE)(name, aux)              \
          typedef BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUX_I_, SENF_PARSER_TYPE)(name, aux)        \
              BOOST_PP_CAT(name,_aux_policy);
#
# define SENF_PARSER_COLLECTION_AUXTYPE_var(name, aux)                                            \
      static bool const BOOST_PP_CAT(name, _aux_fixed) =                                          \
          (SENF_MPL_SLOT_GET(group) - BOOST_PP_CAT(aux, _group) == 0);
#
# define SENF_PARSER_COLLECTION_AUXTYPE_fix(name, aux)
#
# ifndef DOXYGEN
#
  namespace senf { namespace detail {
      template <class Parser> struct DynamicAuxParserPolicy;
      template <class Parser, unsigned offset> struct FixedAuxParserPolicy;
      template <class Parser, unsigned fixedOffset, bool fixedDelta>
      struct ParserAuxPolicySelect
      { typedef senf::detail::DynamicAuxParserPolicy<Parser> type; };
      template <class Parser, unsigned fixedOffset>
      struct ParserAuxPolicySelect<Parser, fixedOffset, true>
      { typedef senf::detail::FixedAuxParserPolicy<Parser, fixedOffset> type; };
  }};
#
# endif
#
# define SENF_PARSER_COLLECTION_AUX_I_var(name, aux)                                              \
      senf::detail::ParserAuxPolicySelect< BOOST_PP_CAT(aux, _t),                                 \
                                           SENF_PARSER_CURRENT_FIXED_OFFSET()                     \
                                               - SENF_PARSER_FIXED_OFFSET(aux),                   \
                                           BOOST_PP_CAT(name, _aux_fixed) >::type
#
# define SENF_PARSER_COLLECTION_AUX_I_fix(name, aux)                                              \
      senf::detail::FixedAuxParserPolicy< BOOST_PP_CAT(aux, _t),                                  \
                                          SENF_PARSER_CURRENT_FIXED_OFFSET()                      \
                                              - SENF_PARSER_FIXED_OFFSET(aux) >
#
# define SENF_PARSER_COLLECTION_TAG_AUXDEF__packetSize(name, aux)                                 \
          typedef senf::detail::PacketSizeAuxParserPolicy BOOST_PP_CAT(name, _aux_policy);
#
# define SENF_PARSER_COLLECTION_TAG_VAL__auxField(name, aux, access)                              \
          BOOST_PP_CAT(SENF_PARSER_COLLECTION_VAL_, SENF_PARSER_TYPE)(name, aux, access)
#
# define SENF_PARSER_COLLECTION_VAL_var(name,aux,access)                                          \
      private:                                                                                    \
          template <class T> T BOOST_PP_CAT(name, _dispatch)(boost::true_type) const              \
          { return parse<T>( SENF_PARSER_OFFSET(name) ); }                                        \
          template <class T> T BOOST_PP_CAT(name, _dispatch)(boost::false_type) const             \
          { return parse<T>( BOOST_PP_CAT(aux,_)(), SENF_PARSER_OFFSET(name) ); }                 \
          BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const                                    \
          { return BOOST_PP_CAT(name, _dispatch) <BOOST_PP_CAT(name, _t)>(                        \
                  boost::integral_constant<bool, BOOST_PP_CAT(name, _aux_fixed)>()); }            \
      access:                                                                                     \
          BOOST_PP_CAT(name, _t) name() const                                                     \
          { return BOOST_PP_CAT(name, _)(); }
#
# define SENF_PARSER_COLLECTION_VAL_fix(name,aux,access)                                          \
      private:                                                                                    \
          BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const                                    \
          { return parse<BOOST_PP_CAT(name, _t)>( SENF_PARSER_OFFSET(name) ); }                   \
      access:                                                                                     \
          BOOST_PP_CAT(name, _t) name() const                                                     \
          { return BOOST_PP_CAT(name, _)(); }
#
# define SENF_PARSER_COLLECTION_TAG_VAL__packetSize(name, aux, access)                            \
      private:                                                                                    \
          BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const                                    \
          { return parse<BOOST_PP_CAT(name, _t)>( SENF_PARSER_OFFSET(name) ); }                   \
      access:                                                                                     \
          BOOST_PP_CAT(name, _t) name() const                                                     \
          { return BOOST_PP_CAT(name, _)(); }
#
# //-///////////////////////////////////////////////////////////////////////////////////////////////
# 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"
# // End: