// $Id$
//
-// Copyright (C) 2006
+// Copyright (C) 2006
// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
// Stefan Bund <stefan.bund@fokus.fraunhofer.de>
#define HH_ParseInt_ 1
// Custom includes
+#include <iostream>
#include "ParserBase.hh"
#include <boost/cstdint.hpp>
#include <boost/static_assert.hpp>
template <class Iterator=nil, class IPacket=nil>
struct Parse_Int8
- : public impl::ParseIntOps<Parse_Int8<Iterator,IPacket>,boost::int8_t>,
+ : public impl::ParseIntOps<Parse_Int8<Iterator,IPacket>,boost::int8_t>,
public ParserBase<Iterator,IPacket>
- {
+ {
template <class I=nil, class P=nil>
struct rebind { typedef Parse_Int8<I,P> parser; };
typedef Iterator byte_iterator;
void value(value_type v) { this->i()[0] = v; }
Parse_Int8 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_Int8<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_UInt8
- : public impl::ParseIntOps<Parse_UInt8<Iterator,IPacket>,boost::uint8_t>,
+ : public impl::ParseIntOps<Parse_UInt8<Iterator,IPacket>,boost::uint8_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
typedef Iterator byte_iterator;
static unsigned bytes() { return 1; }
-
+
Parse_UInt8() {}
explicit Parse_UInt8(Iterator const & i) : ParserBase<Iterator,IPacket>(i) {}
void value(value_type v) { this->i()[0] = v; }
Parse_UInt8 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_UInt8<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_Int16
- : public impl::ParseIntOps<Parse_Int16<Iterator,IPacket>,boost::int16_t>,
+ : public impl::ParseIntOps<Parse_Int16<Iterator,IPacket>,boost::int16_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
void value(value_type v) { impl::write_uint16(this->i(),v); }
Parse_Int16 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_Int16<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_UInt16
- : public impl::ParseIntOps<Parse_UInt16<Iterator,IPacket>,boost::uint16_t>,
+ : public impl::ParseIntOps<Parse_UInt16<Iterator,IPacket>,boost::uint16_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
void value(value_type v) { impl::write_uint16(this->i(),v); }
Parse_UInt16 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_UInt16<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_Int24
- : public impl::ParseIntOps<Parse_Int24<Iterator,IPacket>,boost::int32_t>,
+ : public impl::ParseIntOps<Parse_Int24<Iterator,IPacket>,boost::int32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
typedef boost::int32_t value_type;
- value_type value() const {
+ value_type value() const {
value_type v (impl::parse_uint24(this->i())); return v&0x800000 ? v|0xff000000 : v; }
void value(value_type v) { impl::write_uint24(this->i(),v); }
Parse_Int24 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_Int24<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_UInt24
- : public impl::ParseIntOps<Parse_UInt24<Iterator,IPacket>,boost::uint32_t>,
+ : public impl::ParseIntOps<Parse_UInt24<Iterator,IPacket>,boost::uint32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
void value(value_type v) { impl::write_uint24(this->i(),v); }
Parse_UInt24 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_UInt24<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_Int32
- : public impl::ParseIntOps<Parse_Int32<Iterator,IPacket>,boost::int32_t>,
+ : public impl::ParseIntOps<Parse_Int32<Iterator,IPacket>,boost::int32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
void value(value_type v) { impl::write_uint32(this->i(),v); }
Parse_Int32 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_Int32<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <class Iterator=nil, class IPacket=nil>
struct Parse_UInt32
- : public impl::ParseIntOps<Parse_UInt32<Iterator,IPacket>,boost::uint32_t>,
+ : public impl::ParseIntOps<Parse_UInt32<Iterator,IPacket>,boost::uint32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
void value(value_type v) { impl::write_uint32(this->i(),v); }
Parse_UInt32 const & operator= (value_type other) { value(other); return *this; }
};
+ template <class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_UInt32<Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <unsigned start, unsigned end, class Iterator=nil, class IPacket=nil>
struct Parse_IntField
- : public impl::ParseIntOps<Parse_IntField<start,end,Iterator,IPacket>,boost::int32_t>,
+ : public impl::ParseIntOps<Parse_IntField<start,end,Iterator,IPacket>,boost::int32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
typedef boost::int32_t value_type;
- value_type value() const {
+ value_type value() const {
value_type v (impl::parse_bitfield<Iterator,start,end>::parse(this->i()));
return v&boost::high_bit_mask_t<end-start-1>::high_bit ?
v | ~boost::low_bits_mask_t<end-start>::sig_bits : v;
BOOST_STATIC_ASSERT( start<end );
BOOST_STATIC_ASSERT( end-start<=32 );
};
+ template <unsigned start, unsigned end, class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_IntField<start,end,Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <unsigned start, unsigned end, class Iterator=nil, class IPacket=nil>
struct Parse_UIntField
- : public impl::ParseIntOps<Parse_UIntField<start,end,Iterator,IPacket>,boost::uint32_t>,
+ : public impl::ParseIntOps<Parse_UIntField<start,end,Iterator,IPacket>,boost::uint32_t>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
BOOST_STATIC_ASSERT( start<end );
BOOST_STATIC_ASSERT( end-start<=32 );
};
+ template <unsigned start, unsigned end, class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_UIntField<start,end,Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
template <unsigned bit, class Iterator=nil, class IPacket=nil>
struct Parse_Flag
- : public impl::ParseIntOps<Parse_Flag<bit,Iterator,IPacket>,bool>,
+ : public impl::ParseIntOps<Parse_Flag<bit,Iterator,IPacket>,bool>,
public ParserBase<Iterator,IPacket>
{
template <class I=nil, class P=nil>
typedef bool value_type;
value_type value() const { return this->i()[bit/8] & (1<<(7-(bit%8))); }
- void value(value_type v) {
+ void value(value_type v) {
if (v) this->i()[0] |= 1<<(7-(bit%8));
else this->i()[0] &= ~(1<<(7-(bit%8)));
}
Parse_Flag const & operator= (value_type other) { value(other); return *this; }
};
+ template <unsigned bit, class Iterator, class IPacket>
+ std::ostream & operator<<(std::ostream & os, Parse_Flag<bit,Iterator,IPacket> const & i)
+ { os << i.value(); return os; }
}
\f
// Local Variables:
// mode: c++
+// fill-column: 100
// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
// End: