GenericTLV.ct

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


/** \file
    \brief GenericTLV non-inline template implementation  */

//#include "GenericTLV.ih"

// Custom includes
#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 {
        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())
        Base::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");
}

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())
        i->second->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())
        i->second->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 i->second->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 i->second->bytes(parser);
    else
        throw TLVParserNotRegisteredException();
}

template <class BaseParser, class Keytype>
prefix_ typename senf::GenericTLVParserRegistry<BaseParser,Keytype>::const_iterator
senf::GenericTLVParserRegistry<BaseParser,Keytype>::begin()
    const
{
    return map_.begin();
}

template <class BaseParser, class Keytype>
prefix_ typename senf::GenericTLVParserRegistry<BaseParser,Keytype>::const_iterator
senf::GenericTLVParserRegistry<BaseParser,Keytype>::end()
    const
{
    return map_.end();
}

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