// $Id$
//
// Copyright (C) 2007
// Fraunhofer Institute for Open Communication Systems (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.

/** \file
    \brief ListBParser internal header */

#ifndef IH_ListBParser_
#define IH_ListBParser_ 1

// Custom includes

///////////////////////////////ih.p////////////////////////////////////////

namespace senf {
namespace detail {

    /** \brief Internal: ListPolicy defing the ListBParser parser
        \internal
        \see \ref ListBParser
     */
    template <class ElementParser, class BytesParser>
    struct ListBParser_Policy
    {
        // This policy needs to work around a serious problem with this type of list: When we change
        // the size of any (direct or indirect) subelement of the list, This will change will render
        // the list completely invalid and unparseable since the 'byte' field will now be invalid.
        //
        // The solution we apply is to store the *size* (i.e. the number of elements) of the list
        // when creating the container wrapper. We also maintain this value accross insert/erase
        // statements. Additionally we also safe the complete size of the data container (the vector
        // holding the bytes). Since we only allow packet changes through this container while it
        // exists, any change in the container size must be a change within this list and therefore
        // mandates an update of the 'bytes' field.
        //
        // The list container wrapper will call 'update' policy member before every access to the
        // container and also in the destructor. This gives us a chance to fix the bytes header
        // before the invalid header is seen by anyone (This is so, since we only allow access to
        // the list through the container wrapper ...). Since we know the number of list elements,
        // we can always find the correct 'bytes' value by traversing the list for that number of
        // elements.
        //
        // By caching the container size, all this can be made reasonably efficient and usable: The
        // updates are done automatically by only if needed. It would of course be more efficient to
        // just apply the size change directly to the bytes header (no need to traverse the
        // list). However, the implementation of this approach would be much more complex and even
        // more invasive and would probably suffer from the same restrictions to the user.

        struct container_policy;

        typedef PacketParserBase::data_iterator iterator;
        typedef PacketParserBase::state_type state_type;
        typedef PacketParserBase::size_type size_type;
        typedef ElementParser element_type;
        typedef ListParser< ListBParser_Policy > parser_type;
        typedef ListParser_Container< container_policy > container_type;

        static const size_type init_bytes = BytesParser::fixed_bytes;

        size_type bytes  (iterator i, state_type s) const;
        size_type size   (iterator i, state_type s) const;
        void      init   (iterator i, state_type s) const;

        /** \brief Internal: ListBParser_Policy's iterator policy
            \internal
         */
        struct iterator_policy
        {
            iterator setBegin        (iterator i, state_type s);
            iterator setEnd          (iterator i, state_type s);
            void     setFromPosition (iterator i, state_type s, iterator p);
            iterator next            (iterator i, state_type s);
            iterator raw             (iterator i, state_type s) const;
        };

        /** \brief Internal: ListBParser_Policy's container policy
            \internal
         */
        struct container_policy
        {
            typedef typename ListBParser_Policy<
                ElementParser,BytesParser>::iterator_policy iterator_policy;
            typedef typename ListBParser_Policy<
                ElementParser,BytesParser>::parser_type parser_type;
            typedef typename ListBParser_Policy<
                ElementParser,BytesParser>::element_type element_type;

            static const size_type init_bytes = ListBParser_Policy<
                ElementParser,BytesParser>::init_bytes;

            container_policy(parser_type const & list);

            size_type bytes  (iterator i, state_type s) const;
            size_type size   (iterator i, state_type s) const;
            void      erase  (iterator i, state_type s, iterator p);
            void      insert (iterator i, state_type s, iterator p);
            void      init   (iterator i, state_type s);
            void      update (iterator i, state_type s) const;

            size_type n_;
            mutable size_type container_size_;
        };
    };

}}

///////////////////////////////ih.e////////////////////////////////////////
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: