X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Packets%2FIntParser.hh;h=8c55605ad3fc283cf8d539ac4d9e42f61bdeb4ab;hb=bd9f9d3fd6fbcff0112a7bf48ab9284da9576b11;hp=fe3de037975e88c7504e225628b54b2732377431;hpb=e59da064ee0ae6cc18c7e1173eedb920d5023021;p=senf.git

diff --git a/Packets/IntParser.hh b/Packets/IntParser.hh
index fe3de03..8c55605 100644
--- a/Packets/IntParser.hh
+++ b/Packets/IntParser.hh
@@ -23,8 +23,8 @@
 /** \file
     \brief IntParser public header */
 
-#ifndef HH_IntParser_
-#define HH_IntParser_ 1
+#ifndef HH_SENF_Packets_IntParser_
+#define HH_SENF_Packets_IntParser_ 1
 
 // Custom includes
 #include <iostream>
@@ -148,6 +148,34 @@ namespace senf {
     inline std::ostream & operator<<(std::ostream & os, Int16Parser const & i)
     { os << i.value(); return os; }
 
+    /** \brief Parse 16bit signed byte aligned integer LSB
+        \see parseint
+        \ingroup parseint
+     */
+    struct Int16LSBParser
+        : public detail::packet::IntParserOps<Int16LSBParser,boost::int16_t>,
+          public PacketParserBase
+    {
+        Int16LSBParser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::int16_t value_type;
+        static size_type const fixed_bytes = 2;
+        static value_type const min_value = -32768;
+        static value_type const max_value = 32767;
+
+
+        value_type value() const { return detail::packet::parse_uint16LSB(i()); }
+        void value(value_type v) { detail::packet::write_uint16LSB(i(),v); }
+        Int16LSBParser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related Int16Parser
+     */
+    inline std::ostream & operator<<(std::ostream & os, Int16LSBParser const & i)
+    { os << i.value(); return os; }
+
     /** \brief Parse 16bit unsigned byte aligned integer
         \see parseint
         \ingroup parseint
@@ -175,6 +203,33 @@ namespace senf {
     inline std::ostream & operator<<(std::ostream & os, UInt16Parser const & i)
     { os << i.value(); return os; }
 
+    /** \brief Parse 16bit unsigned byte aligned integer LSB
+        \see parseint
+        \ingroup parseint
+     */
+    struct UInt16LSBParser
+        : public detail::packet::IntParserOps<UInt16LSBParser,boost::uint16_t>,
+          public PacketParserBase
+    {
+        UInt16LSBParser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::uint16_t value_type;
+        static size_type const fixed_bytes = 2;
+        static value_type const min_value = 0u;
+        static value_type const max_value = 65535u;
+
+        value_type value() const { return detail::packet::parse_uint16LSB(i()); }
+        void value(value_type v) { detail::packet::write_uint16LSB(i(),v); }
+        UInt16LSBParser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related UInt16LSBParser
+     */
+    inline std::ostream & operator<<(std::ostream & os, UInt16LSBParser const & i)
+    { os << i.value(); return os; }
+
     /** \brief Parse 24bit signed byte aligned integer
         \see parseint
         \ingroup parseint
@@ -284,8 +339,110 @@ namespace senf {
     inline std::ostream & operator<<(std::ostream & os, UInt32Parser const & i)
     { os << i.value(); return os; }
 
+    struct UInt32LSBParser
+        : public detail::packet::IntParserOps<UInt32LSBParser,boost::uint32_t>,
+          public PacketParserBase
+    {
+        UInt32LSBParser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::uint32_t value_type;
+        static size_type const fixed_bytes = 4;
+        static value_type const min_value = 0u;
+        static value_type const max_value = 4294967295u;
+
+        value_type value() const { return detail::packet::parse_uint32LSB(i()); }
+        void value(value_type v) { detail::packet::write_uint32LSB(i(),v); }
+        UInt32LSBParser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related UInt32LSBParser
+     */
+    inline std::ostream & operator<<(std::ostream & os, UInt32LSBParser const & i)
+    { os << i.value(); return os; }
+
+
+
+
+    /** \brief Parse 64bit signed byte aligned integer
+        \see parseint
+        \ingroup parseint
+     */
+    struct Int64Parser
+        : public detail::packet::IntParserOps<Int64Parser,boost::int64_t>,
+          public PacketParserBase
+    {
+        Int64Parser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::int64_t value_type;
+        static size_type const fixed_bytes = 8;
+
+        value_type value() const { return detail::packet::parse_uint64(i()); }
+        void value(value_type v) { detail::packet::write_uint64(i(),v); }
+        Int64Parser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related Int64Parser
+    */
+    inline std::ostream & operator<<(std::ostream & os, Int64Parser const & i)
+    { os << i.value(); return os; }
+
+
+    /** \brief Parse 64bit unsigned byte aligned integer
+        \see parseint
+        \ingroup parseint
+     */
+    struct UInt64Parser
+        : public detail::packet::IntParserOps<UInt64Parser,boost::uint64_t>,
+          public PacketParserBase
+    {
+        UInt64Parser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::uint64_t value_type;
+        static size_type const fixed_bytes = 8;
+
+        value_type value() const { return detail::packet::parse_uint64(i()); }
+        void value(value_type v) { detail::packet::write_uint64(i(),v); }
+        UInt64Parser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related UInt64Parser
+     */
+    inline std::ostream & operator<<(std::ostream & os, UInt64Parser const & i)
+    { os << i.value(); return os; }
+
+    /** \brief Parse 64bit unsigned byte aligned integer LSB
+        \see parseint
+        \ingroup parseint
+     */
+    struct UInt64LSBParser
+        : public detail::packet::IntParserOps<UInt64LSBParser,boost::uint64_t>,
+          public PacketParserBase
+    {
+        UInt64LSBParser(data_iterator i, state_type s) : PacketParserBase(i,s,fixed_bytes) {}
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        typedef boost::uint64_t value_type;
+        static size_type const fixed_bytes = 8;
+
+        value_type value() const { return detail::packet::parse_uint64LSB(i()); }
+        void value(value_type v) { detail::packet::write_uint64LSB(i(),v); }
+        UInt64LSBParser const & operator= (value_type other) { value(other); return *this; }
+    };
+    /** \brief Write parsed value to stream
+        \related UInt64LSBParser
+     */
+    inline std::ostream & operator<<(std::ostream & os, UInt64LSBParser const & i)
+    { os << i.value(); return os; }
+
     /** \brief Parse signed bitfield with up to 32bit's
-        
+
         This parser will parse a bitfield beginning at the bit \a Start and ending \e before \a
         End. Bits are numbered <em>most significant bit first</em> as this is the customary
         numbering used when defining packet data structures. \a Start and \a End can be \e
@@ -303,7 +460,7 @@ namespace senf {
             compile-time constants, the compiler will create optimized bit-masks to directly access
             the value. The parser is also optimized to access the minimum number of data bytes
             necessary.
-        
+
         \ingroup parseint
      */
     template <unsigned Start, unsigned End>
@@ -343,7 +500,7 @@ namespace senf {
     { os << i.value(); return os; }
 
     /** \brief Parse unsigned bitfield with up to 32bit's
-        
+
         This parser will parse a bitfield beginning at the bit \a Start and ending \e before \a
         End. Bits are numbered <em>most significant bit first</em> as this is the customary
         numbering used when defining packet data structures. \a Start and \a End can be \e
@@ -361,7 +518,7 @@ namespace senf {
             compile-time constants, the compiler will create optimized bit-masks to directly access
             the value. The parser is also optimized to access the minimum number of data bytes
             necessary.
-        
+
         \ingroup parseint
      */
     template <unsigned Start, unsigned End>
@@ -442,14 +599,14 @@ namespace senf {
 
 ///////////////////////////////hh.e////////////////////////////////////////
 #endif
-#if !defined(HH_Packets__decls_) && !defined(HH_IntParser_i_)
-#define HH_IntParser_i_
+#if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_IntParser_i_)
+#define HH_SENF_Packets_IntParser_i_
 //#include "IntParser.cci"
 //#include "IntParser.ct"
 //#include "IntParser.cti"
 #endif
 
-
+
 // Local Variables:
 // mode: c++
 // fill-column: 100