// $Id$
//
// Copyright (C) 2009
// Fraunhofer Institute for Open Communication Systems (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Thorsten Horstmann <tho@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 GenericTLV non-inline template implementation  */

//#include "GenericTLV.ih"

// Custom includes
#include <boost/io/ios_state.hpp>
#include <senf/Utils/hexdump.hh>
#include <senf/Utils/TypeInfo.hh>
#include <senf/Utils/Format.hh>

#define prefix_
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::GenericTLVParserBase<Base>

template <class Base>
template <class Parser>
prefix_ Parser senf::GenericTLVParserBase<Base>::init()
{
    PacketParserBase::size_type oldSize (bytes() );
    PacketParserBase::size_type newParserSize ( senf::init_bytes<Parser>::value );
    this->resize(  oldSize, newParserSize);
    std::fill(this->i(), boost::next(this->i(), newParserSize), 0u);
    Parser concreteParser = Parser(this->i(), this->state() );
    concreteParser.init();
//    concreteParser.length() = newParserSize - senf::init_bytes<Base>::value;
    return concreteParser;
}

template <class Base>
prefix_  void senf::GenericTLVParserBase<Base>::dump(std::ostream & os)
    const
{
    if (Base::Registry::instance().isRegistered( *this)) {
        Base::Registry::instance().dump( *this, os);
    } else {
        boost::io::ios_all_saver ias(os);
        os << "  GenericTLVParser<" << prettyName(typeid(Base)) << ">\n"
           << "    type:   " << format::dumpint(this->type()) << "\n"
           << "    length: " << format::dumpint(this->length()) << "\n"
           << "    value:\n";
        hexdump(value().begin(), value().end(), os);
    }
}

template <class Base>
prefix_  senf::PacketInterpreterBase::range senf::GenericTLVParserBase<Base>::value()
    const
{
    PacketData::iterator begin ( boost::next(this->i(), senf::bytes( self())) );
    return PacketInterpreterBase::range(begin, boost::next( begin, this->length()) );
}

template <class Base>
template <class ForwardReadableRange>
prefix_ void senf::GenericTLVParserBase<Base>::value_(ForwardReadableRange const &range)
{
    //typename boost::range_difference<ForwardReadableRange>::type rangeSize ( boost::size(range));
    unsigned rangeSize ( boost::size(range));
    if ( rangeSize != this->length() )
        resize( bytes(), rangeSize + senf::bytes(self()) );
    std::copy( boost::begin(range), boost::end(range), boost::next(
            this->i(), senf::bytes( self())) );
    this->length_() = rangeSize;
}


//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::GenericTLVParserRegistry<BaseParser,Keytype>

template <class BaseParser, class Keytype>
template <typename Parser>
prefix_ void senf::GenericTLVParserRegistry<BaseParser,Keytype>::registerParser()
{
    Keytype key (Parser::typeId+0);
    typename Map::iterator i (map_.find( key ));
    if (i == map_.end() )
        map_.insert(key, new detail::GenericTLVParserRegistry_Entry<BaseParser, Parser>() );
}

// Wow ... this is stupid .. Boost 1.33 ptr_map API is broken ...

#if BOOST_VERSION < 103400
#define PTRMAP_GET_CONTENTS(v) (v)
#else
#define PTRMAP_GET_CONTENTS(v) (*(v).second)
#endif

template <class BaseParser, class Keytype>
prefix_ void senf::GenericTLVParserRegistry<BaseParser,Keytype>::dump(
        GenericTLVParser const & parser, std::ostream & os)
    const
{
    typename Map::const_iterator i (map_.find( parser.type()));
    if (i != map_.end())
        PTRMAP_GET_CONTENTS(*i).dump(parser, os);
}

template <class BaseParser, class Keytype>
prefix_ void senf::GenericTLVParserRegistry<BaseParser,Keytype>::dump(
        GenericTLVParser const & parser, Keytype const & key, std::ostream & os)
    const
{
    typename Map::const_iterator i (map_.find( key));
    if (i != map_.end())
        PTRMAP_GET_CONTENTS(*i).dump(parser, os);
}

template <class BaseParser, class Keytype>
prefix_ senf::PacketParserBase::size_type senf::GenericTLVParserRegistry<BaseParser,Keytype>::bytes(
        GenericTLVParser const & parser)
    const
{
    typename Map::const_iterator i (map_.find( parser.type()));
    if (i != map_.end())
        return PTRMAP_GET_CONTENTS(*i).bytes(parser);
    else
        throw TLVParserNotRegisteredException();
}

template <class BaseParser, class Keytype>
prefix_ senf::PacketParserBase::size_type senf::GenericTLVParserRegistry<BaseParser,Keytype>::bytes(
        GenericTLVParser const & parser, Keytype const & key)
    const
{
    typename Map::const_iterator i (map_.find( key));
    if (i != map_.end())
        return PTRMAP_GET_CONTENTS(*i).bytes(parser);
    else
        throw TLVParserNotRegisteredException();
}

#undef PTRMAP_GET_CONTENTS

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// 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: