ail/memory.cpp

   1 #include <ail/memory.hpp>
   2 #include <ail/string.hpp>
   3
   4 #include <boost/foreach.hpp>
   5
   6 namespace ail
   7 {
   8         std::size_t const bits_per_byte = 8;
   9
  10         bit_reader::bit_reader(std::string const & data, bool high_to_low_order):
  11                 offset(0),
  12                 big_endian(true)
  13         {
  14                 std::size_t
  15                                 initial_value,
  16                                 limit,
  17                                 direction;
  18
  19                 if(high_to_low_order)
  20                 {
  21                         initial_value = bits_per_byte - 1;
  22                         limit = -1;
  23                         direction = -1;
  24                 }
  25                 else
  26                 {
  27                         initial_value = 0;
  28                         limit = bits_per_byte;
  29                         direction = 1;
  30                 }
  31
  32                 BOOST_FOREACH(char i, data)
  33                 {
  34                         for(std::size_t bit = initial_value; bit != limit; bit += direction)
  35                                 bit_stream.push_back(static_cast<char>((i >> bit) & 1));
  36                 }
  37         }
  38
  39         ulong bit_reader::read(std::size_t bit_count)
  40         {
  41                 std::size_t new_offset = offset + bit_count;
  42                 if(new_offset > bit_stream.size())
  43                         throw exception("Reading bit stream data out of bounds");
  44                 std::string binary_string = bit_stream.substr(offset, bit_count);
  45                 ulong output = binary_string_to_number(binary_string);
  46                 offset = new_offset;
  47                 return output;
  48         }
  49
  50         ulong bit_reader::read_bytes(std::size_t byte_count)
  51         {
  52                 return read(bits_per_byte * byte_count);
  53         }
  54
  55         bool bit_reader::read_bool()
  56         {
  57                 return read(1) == 1;
  58         }
  59
  60         std::size_t bit_reader::get_offset() const
  61         {
  62                 return offset;
  63         }
  64
  65         void bit_reader::set_offset(std::size_t new_offset)
  66         {
  67                 if(new_offset > bit_stream.size())
  68                         throw exception("New bit stream offset is out of bounds");
  69                 offset = new_offset;
  70         }
  71
  72         std::string bit_reader::string(std::size_t length, std::size_t character_size)
  73         {
  74                 std::string output;
  75                 for(std::size_t i = 0; i < length; i++)
  76                         output.push_back(static_cast<char>(read(character_size)));
  77                 return output;
  78         }
  79
  80         ulong read_big_endian(char const * input, std::size_t size, std::size_t offset)
  81         {
  82                 unsigned char const * unsigned_input = reinterpret_cast<unsigned char const *>(input + offset);
  83                 ulong output = 0;
  84                 if(size)
  85                 {
  86                         for(unsigned char const * i = unsigned_input, * end = unsigned_input + size; i < end; ++i)
  87                         {
  88                                 output <<= bits_per_byte;
  89                                 output |= *i;
  90                         }
  91                 }
  92                 return output;
  93         }
  94
  95         ulong read_little_endian(char const * input, std::size_t size, std::size_t offset)
  96         {
  97                 unsigned char const * unsigned_input = reinterpret_cast<unsigned char const *>(input + offset);
  98                 ulong output = 0;
  99                 if(size)
 100                 {
 101                         for(unsigned char const * i = unsigned_input + size - 1, * end = unsigned_input; i >= end; --i)
 102                         {
 103                                 output <<= bits_per_byte;
 104                                 output |= static_cast<ulong>(*i);
 105                         }
 106                 }
 107                 return output;
 108         }
 109
 110         ulong read_big_endian_bits(char const * data, std::size_t bit_count, std::size_t offset)
 111         {
 112                 ulong output = 0;
 113                 for(std::size_t i = 0; i < bit_count; i++)
 114                 {
 115                         output <<= 1;
 116                         output |= get_bit(data, offset + i);
 117                 }
 118                 return output;
 119         }
 120
 121         ulong read_little_endian_bits(char const * data, std::size_t bit_count, std::size_t offset)
 122         {
 123                 ulong output = 0;
 124                 for(std::size_t i = 0; i < bit_count; i++)
 125                         output |= get_bit(data, offset + i) << i;
 126                 return output;
 127         }
 128
 129         void write_big_endian(ulong input, char * output, std::size_t size)
 130         {
 131                 if(size)
 132                 {
 133                         for(char * i = output + size - 1; i >= output; --i)
 134                         {
 135                                 *i = (char)input;
 136                                 input >>= bits_per_byte;
 137                         }
 138                 }
 139         }
 140
 141         void write_little_endian(ulong input, char * output, std::size_t size)
 142         {
 143                 if(size)
 144                 {
 145                         for(char * i = output, * end = output + size; i < end; ++i)
 146                         {
 147                                 *i = (char)input;
 148                                 input >>= bits_per_byte;
 149                         }
 150                 }
 151         }
 152
 153         std::string big_endian_string(ulong input, std::size_t size)
 154         {
 155                 char * buffer = new char[size];
 156                 write_big_endian(input, buffer, size);
 157                 std::string output = std::string(buffer, size);
 158                 delete buffer;
 159                 return output;
 160         }
 161
 162         std::string little_endian_string(ulong input, std::size_t size)
 163         {
 164                 char * buffer = new char[size];
 165                 write_little_endian(input, buffer, size);
 166                 std::string output = std::string(buffer, size);
 167                 delete buffer;
 168                 return output;
 169         }
 170
 171         ulong get_bit(char const * data, std::size_t offset)
 172         {
 173                 std::size_t byte = offset / bits_per_byte;
 174                 std::size_t bit = offset % bits_per_byte;
 175                 return (data[byte] >> bit) & 1;
 176         }
 177 }