Packets/ParseInt.ih

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 #ifndef IH_ParseInt_
  24 #define IH_ParseInt_ 1
  25
  26 // Custom includes
  27
  28 ///////////////////////////////ih.p////////////////////////////////////////
  29
  30 namespace satcom {
  31 namespace pkf {
  32 namespace impl {
  33
  34     ///////////////////////////////////////////////////////////////////////////
  35     // Integer operators
  36
  37     template <class Derived, class Value>
  38     class ParseIntOps
  39     {
  40     public:
  41         typedef Value value_type;
  42
  43         operator Value () const { return derived().value(); }
  44
  45 #       define unary(op) \
  46             Value operator op () const { return op derived().value(); }
  47 #       define mutator(op) \
  48             template <class Other> Derived const & operator op ## =  (Other other) \
  49                 { derived().value( derived().value() op other ); return derived(); }
  50
  51         unary(~)
  52         unary(!)
  53         unary(-)
  54
  55         mutator(+)
  56         mutator(-)
  57         mutator(*)
  58         mutator(/)
  59         mutator(%)
  60         mutator(<<)
  61         mutator(>>)
  62         mutator(&)
  63         mutator(|)
  64         mutator(^)
  65
  66 #       undef unary
  67 #       undef mutator
  68
  69         Derived const & operator ++ ()
  70             { derived().value( derived.value()+1 ); return derived(); }
  71         Derived const & operator -- ()
  72             { derived().value( derived.value()-1 ); return derived(); }
  73
  74     private:
  75         Derived & derived() { return *static_cast<Derived *>(this); }
  76         Derived const & derived() const { return *static_cast<Derived const *>(this); };
  77     };
  78
  79     ///////////////////////////////////////////////////////////////////////////
  80     // Network byte order integer extraction
  81
  82     template <class Iterator>
  83     boost::uint16_t parse_uint16(Iterator const & i)
  84     {
  85         return i[1] | i[0]<<8;
  86     }
  87
  88     template <class Iterator>
  89     void write_uint16(Iterator const & i, boost::uint16_t v)
  90     {
  91         i[0] = ( v >>  8 ) & 0xff;
  92         i[1] = ( v       ) & 0xff;
  93     }
  94
  95     template <class Iterator>
  96     boost::uint32_t parse_uint24(Iterator const & i)
  97     {
  98         return i[2] | i[1]<<8 | i[0]<<16;
  99     }
 100
 101     template <class Iterator>
 102     void write_uint24(Iterator const & i, boost::uint32_t v)
 103     {
 104         i[0] = ( v >> 16 ) & 0xff;
 105         i[1] = ( v >>  8 ) & 0xff;
 106         i[2] = ( v       ) & 0xff;
 107     }
 108
 109     template <class Iterator>
 110     boost::uint32_t parse_uint32(Iterator const & i)
 111     {
 112         return i[3] | i[2]<<8 | i[1]<<16 | i[0]<<24;
 113     }
 114
 115     template <class Iterator>
 116     void write_uint32(Iterator const & i, boost::uint32_t v)
 117     {
 118         i[0] = ( v >> 24 ) & 0xff;
 119         i[1] = ( v >> 16 ) & 0xff;
 120         i[2] = ( v >>  8 ) & 0xff;
 121         i[3] = ( v       ) & 0xff;
 122     }
 123
 124     ///////////////////////////////////////////////////////////////////////////
 125     // bitfield extraction
 126
 127     template <class Iterator, unsigned offset, unsigned endb, unsigned start, unsigned end>
 128     struct parse_bitfield_i
 129     {
 130         static boost::uint32_t parse(Iterator const & i) {
 131             return ( ( ( parse_uint32(i+offset+1)>>(40-end) ) // Beware of sign extension !!
 132                        & boost::low_bits_mask_t<32-(40-end)>::sig_bits )
 133                      | (i[offset]<<(32-(40-end))) )
 134                 & boost::low_bits_mask_t<end-start>::sig_bits;
 135         }
 136
 137         static void write(Iterator const & i, boost::uint32_t v) {
 138             write_uint32(i+offset+1,
 139                          (parse_uint32(i+offset+1) & ~(boost::low_bits_mask_t<end-8>::sig_bits<<(40-end)))
 140                          | ((v & boost::low_bits_mask_t<end-8>::sig_bits) << (40-end)));
 141             i[offset] = (i[offset] & ~(boost::low_bits_mask_t<8-start>::sig_bits))
 142                 | ((v>>(end-8)) & boost::low_bits_mask_t<8-start>::sig_bits);
 143         }
 144     };
 145
 146     template <class Iterator, unsigned offset, unsigned start, unsigned end>
 147     struct parse_bitfield_i<Iterator, offset, 3, start, end>
 148     {
 149         static boost::uint32_t parse(Iterator const & i) {
 150             return ( parse_uint32(i+offset)>>(32-end) )
 151                 & boost::low_bits_mask_t<end-start>::sig_bits;
 152         }
 153
 154         static void write(Iterator const & i, boost::uint32_t v) {
 155             write_uint32(i+offset,
 156                          (parse_uint32(i+offset) & ~(boost::low_bits_mask_t<end-start>::sig_bits<<(32-end)))
 157                          | ((v & boost::low_bits_mask_t<end-start>::sig_bits) << (32-end)));
 158         }
 159     };
 160
 161     template <class Iterator, unsigned offset, unsigned start, unsigned end>
 162     struct parse_bitfield_i<Iterator, offset, 2, start, end>
 163     {
 164         static boost::uint32_t parse(Iterator const & i) {
 165             return ( parse_uint24(i+offset)>>(24-end) )
 166                 & boost::low_bits_mask_t<end-start>::sig_bits;
 167         }
 168
 169         static void write(Iterator const & i, boost::uint32_t v) {
 170             write_uint24(i+offset,
 171                          (parse_uint24(i+offset) & ~(boost::low_bits_mask_t<end-start>::sig_bits<<(24-end)))
 172                          | ((v & boost::low_bits_mask_t<end-start>::sig_bits) << (24-end)));
 173         }
 174     };
 175
 176     template <class Iterator, unsigned offset, unsigned start, unsigned end>
 177     struct parse_bitfield_i<Iterator, offset, 1, start, end>
 178     {
 179         static boost::uint32_t parse(Iterator const & i) {
 180             return ( parse_uint16(i+offset)>>(16-end) )
 181                 & boost::low_bits_mask_t<end-start>::sig_bits;
 182         }
 183
 184         static void write(Iterator const & i, boost::uint32_t v) {
 185             write_uint16(i+offset,
 186                          (parse_uint16(i+offset) & ~(boost::low_bits_mask_t<end-start>::sig_bits<<(16-end)))
 187                          | ((v & boost::low_bits_mask_t<end-start>::sig_bits) << (16-end)));
 188         }
 189     };
 190
 191     template <class Iterator, unsigned offset, unsigned start, unsigned end>
 192     struct parse_bitfield_i<Iterator, offset, 0, start, end>
 193     {
 194         static boost::uint32_t parse(Iterator const & i) {
 195             return ( i[offset]>>(8-end) )
 196                 & boost::low_bits_mask_t<end-start>::sig_bits;
 197         }
 198
 199         static void write(Iterator const & i, boost::uint32_t v) {
 200             i[offset] = (i[offset] & ~(boost::low_bits_mask_t<end-start>::sig_bits<<(8-end)))
 201                 | ((v & boost::low_bits_mask_t<end-start>::sig_bits) << (8-end));
 202         }
 203     };
 204
 205     template <class Iterator, unsigned start, unsigned end>
 206     struct parse_bitfield
 207         : public parse_bitfield_i<Iterator,start/8,(end-1)/8-start/8,start%8,end-8*(start/8)>
 208     {};
 209
 210 }}}
 211
 212 ///////////////////////////////ih.e////////////////////////////////////////
 213 #endif
 214
 215 \f
 216 // Local Variables:
 217 // mode: c++
 218 // c-file-style: "satcom"
 219 // End: