// $Id$
//
// Copyright (C) 2009
// 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.
// All Rights Reserved.
//
// Contributor(s):
//   Thorsten Horstmann <tho@berlios.de>

/** \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);
    SENF_ASSERT_EXPRESSION(
            map_.insert( key, new detail::GenericTLVParserRegistry_Entry<BaseParser, Parser>()).second,
        "Duplicate TLV registration");
}

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