Class: Cosmos::BinaryAccessor

Inherits:

Object

Object
Cosmos::BinaryAccessor

show all

Defined in:: lib/cosmos/packets/binary_accessor.rb,
ext/cosmos/ext/structure/structure.c

Overview

Provides methods for binary reading and writing

Constant Summary collapse

PACK_8_BIT_INT = Constants for ruby packing directives

'c'

PACK_NATIVE_16_BIT_INT =

's'

PACK_LITTLE_ENDIAN_16_BIT_UINT =

'v'

PACK_BIG_ENDIAN_16_BIT_UINT =

'n'

PACK_NATIVE_32_BIT_INT =

'l'

PACK_NATIVE_32_BIT_UINT =

'L'

PACK_NATIVE_64_BIT_INT =

'q'

PACK_NATIVE_64_BIT_UINT =

'Q'

PACK_LITTLE_ENDIAN_32_BIT_UINT =

'V'

PACK_BIG_ENDIAN_32_BIT_UINT =

'N'

PACK_LITTLE_ENDIAN_32_BIT_FLOAT =

'e'

PACK_LITTLE_ENDIAN_64_BIT_FLOAT =

'E'

PACK_BIG_ENDIAN_32_BIT_FLOAT =

'g'

PACK_BIG_ENDIAN_64_BIT_FLOAT =

'G'

PACK_NULL_TERMINATED_STRING =

'Z*'

PACK_BLOCK =

'a*'

PACK_8_BIT_INT_ARRAY =

'c*'

PACK_8_BIT_UINT_ARRAY =

'C*'

PACK_NATIVE_16_BIT_INT_ARRAY =

's*'

PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY =

'n*'

PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY =

'v*'

PACK_NATIVE_32_BIT_INT_ARRAY =

'l*'

PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY =

'N*'

PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY =

'V*'

PACK_NATIVE_64_BIT_INT_ARRAY =

'q*'

PACK_NATIVE_64_BIT_UINT_ARRAY =

'Q*'

PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY =

'e*'

PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY =

'E*'

PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY =

'g*'

PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY =

'G*'

ZERO_STRING = Additional Constants

"\000"

DATA_TYPES = Valid data types

[:INT, :UINT, :FLOAT, :STRING, :BLOCK]

OVERFLOW_TYPES = Valid overflow types

[:TRUNCATE, :SATURATE, :ERROR, :ERROR_ALLOW_HEX]

HOST_ENDIANNESS = Store the host endianness so that it only has to be determined once

get_host_endianness()

ENDIANNESS = Valid endianess

[:BIG_ENDIAN, :LITTLE_ENDIAN]

Class Method Summary collapse

.adjust_packed_size(num_bytes, packed) ⇒ Object

Adjusts the packed array to be the given number of bytes.
.byte_swap_buffer(buffer, num_bytes_per_word) ⇒ String

Byte swaps every X bytes of data in a buffer into a new buffer.
.byte_swap_buffer!(buffer, num_bytes_per_word) ⇒ String

Byte swaps every X bytes of data in a buffer overwriting the buffer.
.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ Integer

Checks for overflow of an integer data type.
.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ Array[Integer]

Checks for overflow of an array of integer data types.
.read(param_bit_offset, param_bit_size, param_data_type, param_buffer, param_endianness) ⇒ Integer

Reads binary data of any data type from a buffer.
.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness) ⇒ Array

Reads an array of binary data of any data type from a buffer.
.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow) ⇒ Integer

Writes binary data of any data type to a buffer.
.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow) ⇒ Array

Writes an array of binary data of any data type to a buffer.

Class Method Details

.adjust_packed_size(num_bytes, packed) ⇒ `Object`

Adjusts the packed array to be the given number of bytes

Parameters:

num_bytes (Integer) —

The desired number of bytes
packet (Array) —

The packed data buffer

# File 'lib/cosmos/packets/binary_accessor.rb', line 833

def self.adjust_packed_size(num_bytes, packed)
  difference = num_bytes - packed.length
  if difference > 0
    packed << (ZERO_STRING * difference)
  elsif difference < 0
    packed = packed[0..(packed.length - 1 + difference)]
  end
  packed
end

.byte_swap_buffer(buffer, num_bytes_per_word) ⇒ `String`

Byte swaps every X bytes of data in a buffer into a new buffer

Parameters:

buffer (String) —

Buffer that will be copied then modified
num_bytes_per_word (Integer) —

Number of bytes per word that will be swapped

Returns:

(String) —

modified buffer

# File 'lib/cosmos/packets/binary_accessor.rb', line 864

def self.byte_swap_buffer(buffer, num_bytes_per_word)
  buffer = buffer.clone
  self.byte_swap_buffer!(buffer, num_bytes_per_word)
end

.byte_swap_buffer!(buffer, num_bytes_per_word) ⇒ `String`

Byte swaps every X bytes of data in a buffer overwriting the buffer

Parameters:

buffer (String) —

Buffer to modify
num_bytes_per_word (Integer) —

Number of bytes per word that will be swapped

Returns:

(String) —

buffer passed in as a parameter

# File 'lib/cosmos/packets/binary_accessor.rb', line 848

def self.byte_swap_buffer!(buffer, num_bytes_per_word)
  num_swaps = buffer.length / num_bytes_per_word
  index = 0
  num_swaps.times do
    range = index..(index + num_bytes_per_word - 1)
    buffer[range] = buffer[range].reverse
    index += num_bytes_per_word
  end
  buffer
end

.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ `Integer`

Checks for overflow of an integer data type

Parameters:

value (Integer) —

Value to write into the buffer
min_value (Integer) —

Minimum allowed value
max_value (Integer) —

Maximum allowed value
hex_max_value (Integer) —

Maximum allowed value if specified in hex
bit_size (Integer) —

Size of the item in bits
data_type (Symbol) —

DATA_TYPES
overflow (Symbol) —

OVERFLOW_TYPES

Returns:

(Integer) —

Potentially modified value

# File 'lib/cosmos/packets/binary_accessor.rb', line 879

def self.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
  if overflow != :TRUNCATE
    if value > max_value
      if overflow == :SATURATE
        value = max_value
      else
        if overflow == :ERROR or value > hex_max_value
          raise ArgumentError, "value of #{value} invalid for #{bit_size}-bit #{data_type}"
        end
      end
    elsif value < min_value
      if overflow == :SATURATE
        value = min_value
      else
        raise ArgumentError, "value of #{value} invalid for #{bit_size}-bit #{data_type}"
      end
    end
  end
  value
end

.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ `Array[Integer]`

Checks for overflow of an array of integer data types

Parameters:

values (Array[Integer]) —

Values to write into the buffer
min_value (Integer) —

Minimum allowed value
max_value (Integer) —

Maximum allowed value
hex_max_value (Integer) —

Maximum allowed value if specified in hex
bit_size (Integer) —

Size of the item in bits
data_type (Symbol) —

DATA_TYPES
overflow (Symbol) —

OVERFLOW_TYPES

Returns:

(Array[Integer]) —

Potentially modified values

# File 'lib/cosmos/packets/binary_accessor.rb', line 910

def self.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
  if overflow != :TRUNCATE
    values.each_with_index do |value, index|
      values[index] = check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
    end
  end
  values
end

.read(param_bit_offset, param_bit_size, param_data_type, param_buffer, param_endianness) ⇒ `Integer`

Reads binary data of any data type from a buffer

Parameters:

bit_offset (Integer) —

Bit offset to the start of the item. A negative number means to offset from the end of the buffer.
bit_size (Integer) —

Size of the item in bits
data_type (Symbol) —

DATA_TYPES
buffer (String) —

Binary string buffer to read from
endianness (Symbol) —

ENDIANNESS

Returns:

(Integer) —

value read from the buffer

# File 'ext/cosmos/ext/structure/structure.c', line 281

static VALUE binary_accessor_read(VALUE self, VALUE param_bit_offset, VALUE param_bit_size, VALUE param_data_type, VALUE param_buffer, VALUE param_endianness)
{
  /* Convert Parameters to C Data Types */
  int bit_offset = FIX2INT(param_bit_offset);
  int bit_size = FIX2INT(param_bit_size);

  /* Local Variables */
  int given_bit_offset = bit_offset;
  int given_bit_size = bit_size;
  signed char signed_char_value = 0;
  unsigned char unsigned_char_value = 0;
  signed short signed_short_value = 0;
  unsigned short unsigned_short_value = 0;
  signed int signed_int_value = 0;
  signed long signed_long_value = 0;
  unsigned int unsigned_int_value = 0;
  signed long long signed_long_long_value = 0;
  unsigned long long unsigned_long_long_value = 0;
  unsigned char* unsigned_char_array = NULL;
  int array_length = 0;
  char* string = NULL;
  int string_length = 0;
  float float_value = 0.0;
  double double_value = 0.0;
  int shift_needed = 0;
  int shift_count = 0;
  int index = 0;
  int num_bits = 0;
  int num_bytes = 0;
  int num_words = 0;
  int upper_bound = 0;
  int lower_bound = 0;
  int byte_aligned = 0;
  VALUE temp_value = Qnil;
  VALUE return_value = Qnil;

  unsigned char* buffer = NULL;
  long buffer_length = 0;

  Check_Type(param_buffer, T_STRING);
  buffer = (unsigned char*) RSTRING_PTR(param_buffer);
  buffer_length = RSTRING_LEN(param_buffer);

  /* Handle negative bit offsets */
  if (bit_offset < 0) {
    if (given_bit_size <= 0) {
      rb_raise(rb_eArgError, "negative or zero bit_sizes (%d) cannot be given with negative bit_offsets (%d)", given_bit_size, given_bit_offset);
    } else {
      bit_offset = (((int)buffer_length * 8) + bit_offset);
      if (bit_offset < 0) {
        rb_funcall(self, id_method_raise_buffer_error, 5, symbol_read, param_buffer, param_data_type, param_bit_offset, param_bit_size);
      }
    }
  }

  /* Handle negative and zero bit sizes */
  if (bit_size <= 0) {
    if ((param_data_type == symbol_STRING) || (param_data_type == symbol_BLOCK)) {
      bit_size = (((int)buffer_length * 8) - bit_offset + bit_size);
      if (bit_size == 0) {
        return rb_str_new2("");
      } else if (bit_size < 0) {
        rb_funcall(self, id_method_raise_buffer_error, 5, symbol_read, param_buffer, param_data_type, param_bit_offset, param_bit_size);
      }
    } else {
      rb_raise(rb_eArgError, "bit_size %d must be positive for data types other than :STRING and :BLOCK", given_bit_size);
    }
  }

  /* define bounds of string to access this item */
  lower_bound = (bit_offset / 8);
  upper_bound = ((bit_offset + bit_size - 1) / 8);

  /* Check for byte alignment */
  byte_aligned = ((bit_offset % 8) == 0);

  /* Sanity check buffer size */
  if (upper_bound >= buffer_length) {
    /* Check special case of little endian bit field */
    if ((param_endianness == symbol_LITTLE_ENDIAN) && ((param_data_type == symbol_INT) || (param_data_type == symbol_UINT)) && (!((byte_aligned) && ((bit_size == 8) || (bit_size == 16) || (bit_size == 32) || (bit_size == 64)))) && (lower_bound < buffer_length)) {
      /* Ok little endian bit field */
    } else {
      rb_funcall(self, id_method_raise_buffer_error, 5, symbol_read, param_buffer, param_data_type, param_bit_offset, param_bit_size);
    }
  }

  if ((param_data_type == symbol_STRING) || (param_data_type == symbol_BLOCK)) {

    /*#######################################
       *# Handle :STRING and :BLOCK data types
       *#######################################*/

    if (byte_aligned) {
      string_length = upper_bound - lower_bound + 1;
      string = malloc(string_length + 1);
      memcpy(string, buffer + lower_bound, string_length);
      string[string_length] = 0;
      if (param_data_type == symbol_STRING) {
        return_value = rb_str_new2(string);
      } else /* param_data_type == symbol_BLOCK */ {
        return_value = rb_str_new(string, string_length);
      }
      free(string);
    } else {
      rb_raise(rb_eArgError, "bit_offset %d is not byte aligned for data_type %s", given_bit_offset, RSTRING_PTR(rb_funcall(param_data_type, id_method_to_s, 0)));
    }

  } else if (param_data_type == symbol_INT) {

    /*###################################
       *# Handle :INT data type
       *###################################*/

    if ((byte_aligned) && ((bit_size == 8) || (bit_size == 16) || (bit_size == 32) || (bit_size == 64))) {
      /*###########################################################
         *# Handle byte-aligned 8, 16, 32, and 64 bit :INT
         *###########################################################*/

      if (bit_size == 8)
      {
        signed_char_value = *((signed char*) &buffer[lower_bound]);
        return_value = INT2FIX(signed_char_value);
      }
      else if (bit_size == 16)
      {
        read_aligned_16(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &signed_short_value);
        return_value = INT2FIX(signed_short_value);
      }
      else if (bit_size == 32)
      {
        read_aligned_32(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &signed_int_value);
        return_value = INT2NUM(signed_int_value);
      }
      else /* bit_size == 64 */
      {
        read_aligned_64(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &signed_long_long_value);
        return_value = LL2NUM(signed_long_long_value);
      }
    } else {
      string_length = ((bit_size - 1)/ 8) + 1;
      array_length = string_length + 4; /* Required number of bytes plus slack */
      unsigned_char_array = (unsigned char*) malloc(array_length);
      read_bitfield(lower_bound, upper_bound, bit_offset, bit_size, given_bit_offset, given_bit_size, param_endianness, buffer, (int)buffer_length, unsigned_char_array);

      num_words = ((string_length - 1) / 4) + 1;
      num_bytes = num_words * 4;
      num_bits = num_bytes * 8;
      shift_needed = num_bits - bit_size;
      shift_count = shift_needed / 8;
      shift_needed = shift_needed % 8;

      if (bit_size > 1) {
        for (index = 0; index < shift_count; index++) {
          signed_right_shift_byte_array(unsigned_char_array, num_bytes, 8);
        }

        if (shift_needed > 0) {
          signed_right_shift_byte_array(unsigned_char_array, num_bytes, shift_needed);
        }
      } else {
        for (index = 0; index < shift_count; index++) {
          unsigned_right_shift_byte_array(unsigned_char_array, num_bytes, 8);
        }

        if (shift_needed > 0) {
          unsigned_right_shift_byte_array(unsigned_char_array, num_bytes, shift_needed);
        }
      }

      if (HOST_ENDIANNESS == symbol_LITTLE_ENDIAN) {
        for (index = 0; index < num_bytes; index += 4) {
          reverse_bytes(&(unsigned_char_array[index]), 4);
        }
      }

      if (bit_size <= 31) {
        return_value = INT2FIX(*((int*) unsigned_char_array));
      } else if (bit_size == 32) {
        return_value = INT2NUM(*((int*) unsigned_char_array));
      } else {
        return_value = rb_int2big(*((int*) unsigned_char_array));
        temp_value = INT2FIX(32);
        for (index = 4; index < num_bytes; index += 4) {
          return_value = rb_big_lshift(return_value, temp_value);
          if (FIXNUM_P(return_value)) {
            signed_long_value = FIX2LONG(return_value);
            return_value = rb_int2big(signed_long_value);
          }
          return_value = rb_big_plus(return_value, rb_uint2big(*((unsigned int*) &(unsigned_char_array[index]))));
          if (FIXNUM_P(return_value)) {
            signed_long_value = FIX2LONG(return_value);
            return_value = rb_int2big(signed_long_value);
          }
        }
        return_value = rb_big_norm(return_value);
      }

      free(unsigned_char_array);
    }

  } else if (param_data_type == symbol_UINT) {

    /*###################################
       *# Handle :UINT data type
       *###################################*/

    if ((byte_aligned) && ((bit_size == 8) || (bit_size == 16) || (bit_size == 32) || (bit_size == 64))) {
      /*###########################################################
         *# Handle byte-aligned 8, 16, 32, and 64 bit :UINT
         *###########################################################*/

      if (bit_size == 8)
      {
        unsigned_char_value = buffer[lower_bound];
        return_value = INT2FIX(unsigned_char_value);
      }
      else if (bit_size == 16)
      {
        read_aligned_16(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &unsigned_short_value);
        return_value = INT2FIX(unsigned_short_value);
      }
      else if (bit_size == 32)
      {
        read_aligned_32(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &unsigned_int_value);
        return_value = UINT2NUM(unsigned_int_value);
      }
      else /* bit_size == 64 */
      {
        read_aligned_64(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &unsigned_long_long_value);
        return_value = ULL2NUM(unsigned_long_long_value);
      }
    } else {
      string_length = ((bit_size - 1)/ 8) + 1;
      array_length = string_length + 4; /* Required number of bytes plus slack */
      unsigned_char_array = (unsigned char*) malloc(array_length);
      read_bitfield(lower_bound, upper_bound, bit_offset, bit_size, given_bit_offset, given_bit_size, param_endianness, buffer, (int)buffer_length, unsigned_char_array);

      num_words = ((string_length - 1) / 4) + 1;
      num_bytes = num_words * 4;
      num_bits = num_bytes * 8;
      shift_needed = num_bits - bit_size;
      shift_count = shift_needed / 8;
      shift_needed = shift_needed % 8;

      for (index = 0; index < shift_count; index++) {
        unsigned_right_shift_byte_array(unsigned_char_array, num_bytes, 8);
      }

      if (shift_needed > 0) {
        unsigned_right_shift_byte_array(unsigned_char_array, num_bytes, shift_needed);
      }

      if (HOST_ENDIANNESS == symbol_LITTLE_ENDIAN) {
        for (index = 0; index < num_bytes; index += 4) {
          reverse_bytes(&(unsigned_char_array[index]), 4);
        }
      }

      if (bit_size <= 30) {
        return_value = INT2FIX(*((int*) unsigned_char_array));
      } else if (bit_size <= 32) {
        return_value = UINT2NUM(*((unsigned int*) unsigned_char_array));
      } else {
        return_value = rb_uint2big(*((unsigned int*) unsigned_char_array));
        temp_value = INT2FIX(32);
        for (index = 4; index < num_bytes; index += 4) {
          return_value = rb_big_lshift(return_value, temp_value);
          if (FIXNUM_P(return_value)) {
            signed_long_value = FIX2LONG(return_value);
            return_value = rb_int2big(signed_long_value);
          }
          return_value = rb_big_plus(return_value, rb_uint2big(*((unsigned int*) &(unsigned_char_array[index]))));
          if (FIXNUM_P(return_value)) {
            signed_long_value = FIX2LONG(return_value);
            return_value = rb_int2big(signed_long_value);
          }
        }
        return_value = rb_big_norm(return_value);
      }

      free(unsigned_char_array);
    }

  } else if (param_data_type == symbol_FLOAT) {

    /*##########################
       *# Handle :FLOAT data type
       *##########################*/

    if (byte_aligned) {
      switch (bit_size) {
        case 32:
          read_aligned_32(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &float_value);
          return_value = rb_float_new(float_value);
          break;

        case 64:
          read_aligned_64(lower_bound, upper_bound, param_endianness, buffer, (unsigned char*) &double_value);
          return_value = rb_float_new(double_value);
          break;

        default:
          rb_raise(rb_eArgError, "bit_size is %d but must be 32 or 64 for data_type %s", given_bit_size, RSTRING_PTR(rb_funcall(param_data_type, id_method_to_s, 0)));
          break;
      };
    } else {
      rb_raise(rb_eArgError, "bit_offset %d is not byte aligned for data_type %s", given_bit_offset, RSTRING_PTR(rb_funcall(param_data_type, id_method_to_s, 0)));
    }

  } else {

    /*############################
       *# Handle Unknown data types
       *############################*/

    rb_raise(rb_eArgError, "data_type %s is not recognized", RSTRING_PTR(rb_funcall(param_data_type, id_method_to_s, 0)));
  }

  return return_value;
}

.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness) ⇒ `Array`

Reads an array of binary data of any data type from a buffer

Parameters:

bit_offset (Integer) —

Bit offset to the start of the array. A negative number means to offset from the end of the buffer.
bit_size (Integer) —

Size of each item in the array in bits
data_type (Symbol) —

DATA_TYPES
array_size (Integer) —

Size in bits of the array. 0 or negative means fill the array with as many bit_size number of items that exist (negative means excluding the final X number of bits).
buffer (String) —

Binary string buffer to read from
endianness (Symbol) —

ENDIANNESS

Returns:

(Array) —

Array created from reading the buffer

Raises:

(ArgumentError)

# File 'lib/cosmos/packets/binary_accessor.rb', line 415

def self.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness)
  # Save given values of bit offset, bit size, and array_size
  given_bit_offset = bit_offset
  given_bit_size = bit_size
  given_array_size = array_size

  # Handle negative and zero bit sizes
  raise ArgumentError, "bit_size #{given_bit_size} must be positive for arrays" if bit_size <= 0

  # Handle negative bit offsets
  if bit_offset < 0
    bit_offset = ((buffer.length * 8) + bit_offset)
    raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size) if bit_offset < 0
  end

  # Handle negative and zero array sizes
  if array_size <= 0
    if given_bit_offset < 0
      raise ArgumentError, "negative or zero array_size (#{given_array_size}) cannot be given with negative bit_offset (#{given_bit_offset})"
    else
      array_size = ((buffer.length * 8) - bit_offset + array_size)
      if array_size == 0
        return []
      elsif array_size < 0
        raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size)
      end
    end
  end

  # Calculate number of items in the array
  # If there is a remainder then we have a problem
  raise ArgumentError, "array_size #{given_array_size} not a multiple of bit_size #{given_bit_size}" if array_size % bit_size != 0
  num_items = array_size / bit_size

  # Define bounds of string to access this item
  lower_bound = bit_offset / 8
  upper_bound = (bit_offset + array_size - 1) / 8

  # Check for byte alignment
  byte_aligned = ((bit_offset % 8) == 0)

  case data_type
  when :STRING, :BLOCK
    #######################################
    # Handle :STRING and :BLOCK data types
    #######################################

    if byte_aligned
      value = []
      num_items.times do
        value << self.read(bit_offset, bit_size, data_type, buffer, endianness)
        bit_offset += bit_size
      end
    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  when :INT, :UINT
    ###################################
    # Handle :INT and :UINT data types
    ###################################

    if byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)
      ###########################################################
      # Handle byte-aligned 8, 16, 32, and 64 bit :INT and :UINT
      ###########################################################

      case bit_size
      when 8
        if data_type == :INT
          value = buffer[lower_bound..upper_bound].unpack(PACK_8_BIT_INT_ARRAY)
        else # data_type == :UINT
          value = buffer[lower_bound..upper_bound].unpack(PACK_8_BIT_UINT_ARRAY)
        end

      when 16
        if data_type == :INT
          if endianness == HOST_ENDIANNESS
            value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_16_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 2)
            value = temp.to_s.unpack(PACK_NATIVE_16_BIT_INT_ARRAY)
          end
        else # data_type == :UINT
          if endianness == :BIG_ENDIAN
            value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY)
          else # endianness == :LITTLE_ENDIAN
            value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY)
          end
        end

      when 32
        if data_type == :INT
          if endianness == HOST_ENDIANNESS
            value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_32_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 4)
            value = temp.to_s.unpack(PACK_NATIVE_32_BIT_INT_ARRAY)
          end
        else # data_type == :UINT
          if endianness == :BIG_ENDIAN
            value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY)
          else # endianness == :LITTLE_ENDIAN
            value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY)
          end
        end

      when 64
        if data_type == :INT
          if endianness == HOST_ENDIANNESS
            value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 8)
            value = temp.to_s.unpack(PACK_NATIVE_64_BIT_INT_ARRAY)
          end
        else # data_type == :UINT
          if endianness == HOST_ENDIANNESS
            value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_UINT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 8)
            value = temp.to_s.unpack(PACK_NATIVE_64_BIT_UINT_ARRAY)
          end
        end
      end

    else
      ##################################
      # Handle :INT and :UINT Bitfields
      ##################################
      raise ArgumentError, "read_array does not support little endian bit fields with bit_size greater than 1-bit" if endianness == :LITTLE_ENDIAN and bit_size > 1

      value = []
      num_items.times do
        value << self.read(bit_offset, bit_size, data_type, buffer, endianness)
        bit_offset += bit_size
      end
    end

  when :FLOAT
    ##########################
    # Handle :FLOAT data type
    ##########################

    if byte_aligned
      case bit_size
      when 32
        if endianness == :BIG_ENDIAN
          value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY)
        else # endianness == :LITTLE_ENDIAN
          value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY)
        end

      when 64
        if endianness == :BIG_ENDIAN
          value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY)
        else # endianness == :LITTLE_ENDIAN
          value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY)
        end

      else
        raise ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}"
      end

    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  else
    ############################
    # Handle Unknown data types
    ############################

    raise ArgumentError, "data_type #{data_type} is not recognized"
  end

  value
end

.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow) ⇒ `Integer`

Writes binary data of any data type to a buffer

Parameters:

value (Varies) —

Value to write into the buffer
bit_offset (Integer) —

Bit offset to the start of the item. A negative number means to offset from the end of the buffer.
bit_size (Integer) —

Size of the item in bits
data_type (Symbol) —

DATA_TYPES
buffer (String) —

Binary string buffer to write to
endianness (Symbol) —

ENDIANNESS
overflow (Symbol) —

OVERFLOW_TYPES

Returns:

(Integer) —

value passed in as a parameter

# File 'lib/cosmos/packets/binary_accessor.rb', line 114

def self.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow)
  # Save given values of bit offset and bit size
  given_bit_offset = bit_offset
  given_bit_size = bit_size

  # Handle negative and zero bit sizes
  if bit_size <= 0
    if data_type == :STRING or data_type == :BLOCK
      if given_bit_offset < 0
        raise ArgumentError, "negative or zero bit_sizes (#{given_bit_size}) cannot be given with negative bit_offsets (#{given_bit_offset})"
      else
        bit_size = value.to_s.length * 8
      end
    else
      raise ArgumentError, "bit_size #{given_bit_size} must be positive for data types other than :STRING and :BLOCK"
    end
  end

  # Handle negative bit offsets
  if bit_offset < 0
    bit_offset = ((buffer.length * 8) + bit_offset)
    raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size) if bit_offset < 0
  end

  # Define bounds of string to access this item
  lower_bound = bit_offset / 8
  upper_bound = (bit_offset + bit_size - 1) / 8

  # Check for byte alignment
  byte_aligned = ((bit_offset % 8) == 0)

  # Sanity check buffer size
  if upper_bound >= buffer.length and given_bit_size > 0
    # Check special case of little endian bit field
    if endianness == :LITTLE_ENDIAN and (data_type == :INT or data_type == :UINT) and !(byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)) and lower_bound < buffer.length
      # Ok little endian bit field
    else
      raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size)
    end
  end

  # Check overflow type
  raise "unknown overflow type #{overflow}" unless OVERFLOW_TYPES.include?(overflow)

  case data_type
  when :STRING, :BLOCK
    #######################################
    # Handle :STRING and :BLOCK data types
    #######################################

    # Ensure value is the correct type
    value = value.to_s

    if byte_aligned
      temp = value
      if given_bit_size <= 0
        end_bytes = -(given_bit_size / 8)
        old_upper_bound = buffer.length - 1 - end_bytes
        if old_upper_bound < lower_bound
          # String was completely empty
          if end_bytes > 0
            # Preserve bytes at end of buffer
            buffer_length = buffer.length
            buffer << ZERO_STRING * value.length
            buffer[(lower_bound + value.length)..(buffer.length - 1)] = buffer[lower_bound..(buffer_length - 1)]
          end
        elsif bit_size == 0
          # Remove entire string
          buffer[lower_bound..old_upper_bound] = ''
        elsif upper_bound < old_upper_bound
          # Remove extra bytes from old string
          buffer[(upper_bound + 1)..old_upper_bound] = ''
        elsif upper_bound > old_upper_bound and end_bytes > 0
          # Preserve bytes at end of buffer
          buffer_length = buffer.length
          diff = upper_bound - old_upper_bound
          buffer << ZERO_STRING * diff
          buffer[(upper_bound + 1)..(buffer.length - 1)] = buffer[(old_upper_bound + 1)..(buffer_length - 1)]
        end
      else
        byte_size = bit_size / 8
        if value.length < byte_size
          temp = value.ljust(byte_size, ZERO_STRING)
        elsif value.length > byte_size
          if overflow == :TRUNCATE
            temp = value[0..(byte_size - 1)]
          else
            raise ArgumentError, "value of #{value.length} bytes does not fit into #{byte_size} bytes for data_type #{data_type}"
          end
        else
          temp = value
        end
      end
      buffer[lower_bound..upper_bound] = temp if bit_size != 0
    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  when :INT, :UINT
    ###################################
    # Handle :INT and :UINT data types
    ###################################

    # Ensure value is the correct type
    value = Integer(value)

    if byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)
      ###########################################################
      # Handle byte-aligned 8, 16, 32, and 64 bit :INT and :UINT
      ###########################################################

      case bit_size
      when 8
        if data_type == :INT
          value = self.check_overflow(value, -128, 127, 255, bit_size, data_type, overflow)
        else
          value = self.check_overflow(value, 0, 255, 255, bit_size, data_type, overflow)
        end
        buffer.setbyte(lower_bound, value % 256)

      when 16
        if data_type == :INT
          value = self.check_overflow(value, -32768, 32767, 65535, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_16_BIT_INT)
          else # endianness != HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_16_BIT_INT).reverse
          end
        else # data_type == :UINT
          value = self.check_overflow(value, 0, 65535, 65535, bit_size, data_type, overflow)
          if endianness == :BIG_ENDIAN
            buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_16_BIT_UINT)
          else # endianness == :LITTLE_ENDIAN
            buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_16_BIT_UINT)
          end
        end

      when 32
        if data_type == :INT
          # Note signed integers must allow up to the maximum unsigned value to support values given in hex
          value = self.check_overflow(value, -2147483648, 2147483647, 4294967295, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_32_BIT_INT)
          else # endianness != HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_32_BIT_INT).reverse
          end
        elsif data_type == :UINT
          value = self.check_overflow(value, 0, 4294967295, 4294967295, bit_size, data_type, overflow)
          if endianness == :BIG_ENDIAN
            buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_32_BIT_UINT)
          else # endianness == :LITTLE_ENDIAN
            buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_32_BIT_UINT)
          end
        end

      when 64
        if data_type == :INT
          # Note signed integers must allow up to the maximum unsigned value to support values given in hex
          value = self.check_overflow(value, -9223372036854775808, 9223372036854775807, 18446744073709551615, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_INT)
          else # endianness != HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_INT).reverse
          end
        elsif data_type == :UINT
          value = self.check_overflow(value, 0, 18446744073709551615, 18446744073709551615, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_UINT)
          else # endianness != HOST_ENDIANNESS
            buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_UINT).reverse
          end
        end
      end

    else
      ##################################
      # Handle :INT and :UINT Bitfields
      ##################################

      if data_type == :INT
        # Note signed integers must allow up to the maximum unsigned value to support values given in hex
        if bit_size > 1
          min_value = -(2 ** (bit_size - 1))
          max_value = -min_value - 1
          hex_max_value = (2 ** bit_size) - 1
        else
          min_value = -1
          max_value = 1
          hex_max_value = 1
        end
        value = self.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
      else
        max_value = (2 ** bit_size) - 1
        value = self.check_overflow(value, 0, max_value, max_value, bit_size, data_type, overflow)
      end

      # Extract Existing Data
      if endianness == :LITTLE_ENDIAN
        # Bitoffset always refers to the most significant bit of a bitfield
        num_bytes = (((bit_offset % 8) + bit_size - 1) / 8) + 1
        upper_bound = bit_offset / 8
        lower_bound = upper_bound - num_bytes + 1

        if lower_bound < 0
          raise ArgumentError, "LITTLE_ENDIAN bitfield with bit_offset #{given_bit_offset} and bit_size #{given_bit_size} is invalid"
        end

        temp_data = buffer[lower_bound..upper_bound].reverse
      else
        temp_data = buffer[lower_bound..upper_bound]
      end

      # Determine temp upper bound
      temp_upper = upper_bound - lower_bound

      # Determine Values needed to Handle Bitfield
      start_bits = bit_offset % 8
      start_mask = (0xFF << (8 - start_bits))
      total_bits = (temp_upper + 1) * 8
      end_bits = total_bits - start_bits - bit_size
      end_mask = ~(0xFF << end_bits)

      # Add in Start Bits
      temp = temp_data.getbyte(0) & start_mask

      # Adjust value to correct number of bits
      temp_mask = (2 ** bit_size) - 1
      temp_value = value.to_i & temp_mask

      # Add in New Data
      temp = (temp << (bit_size - (8 - start_bits))) + temp_value

      # Add in Remainder of Existing Data
      temp = (temp << end_bits) + (temp_data.getbyte(temp_upper) & end_mask)

      # Extract into an array of bytes
      temp_array = []
      (0..temp_upper).each { temp_array.insert(0, (temp & 0xFF)); temp = temp >> 8 }

      # Store into buffer
      if endianness == :LITTLE_ENDIAN
        buffer[lower_bound..upper_bound] = temp_array.pack(PACK_8_BIT_UINT_ARRAY).reverse
      else
        buffer[lower_bound..upper_bound] = temp_array.pack(PACK_8_BIT_UINT_ARRAY)
      end
    end

  when :FLOAT
    ##########################
    # Handle :FLOAT data type
    ##########################

    # Ensure value is the correct type
    value = Float(value)

    if byte_aligned
      case bit_size
      when 32
        if endianness == :BIG_ENDIAN
          buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_32_BIT_FLOAT)
        else # endianness == :LITTLE_ENDIAN
          buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT)
        end

      when 64
        if endianness == :BIG_ENDIAN
          buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_64_BIT_FLOAT)
        else # endianness == :LITTLE_ENDIAN
          buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT)
        end

      else
        raise ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}"
      end
    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  else
    ############################
    # Handle Unknown data types
    ############################

    raise ArgumentError, "data_type #{data_type} is not recognized"
  end

  value
end

.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow) ⇒ `Array`

Writes an array of binary data of any data type to a buffer

Parameters:

values (Array) —

Values to write into the buffer
bit_offset (Integer) —

Bit offset to the start of the array. A negative number means to offset from the end of the buffer.
bit_size (Integer) —

Size of each item in the array in bits
data_type (Symbol) —

DATA_TYPES
array_size (Integer) —

Size in bits of the array as represented in the buffer. Size 0 means to fill the buffer with as many bit_size number of items that exist (negative means excluding the final X number of bits).
buffer (String) —

Binary string buffer to write to
endianness (Symbol) —

ENDIANNESS

Returns:

(Array) —

values passed in as a parameter

Raises:

(ArgumentError)

# File 'lib/cosmos/packets/binary_accessor.rb', line 606

def self.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow)
  # Save given values of bit offset, bit size, and array_size
  given_bit_offset = bit_offset
  given_bit_size = bit_size
  given_array_size = array_size

  # Verify an array was given
  raise ArgumentError, "values must be an Array type class is #{values.class}" unless values.kind_of? Array

  # Handle negative and zero bit sizes
  raise ArgumentError, "bit_size #{given_bit_size} must be positive for arrays" if bit_size <= 0

  # Handle negative bit offsets
  if bit_offset < 0
    bit_offset = ((buffer.length * 8) + bit_offset)
    raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size) if bit_offset < 0
  end

  # Handle negative and zero array sizes
  if array_size <= 0
    if given_bit_offset < 0
      raise ArgumentError, "negative or zero array_size (#{given_array_size}) cannot be given with negative bit_offset (#{given_bit_offset})"
    else
      end_bytes = -(given_array_size / 8)
      lower_bound = bit_offset / 8
      upper_bound = (bit_offset + (bit_size * values.length) - 1) / 8
      old_upper_bound = buffer.length - 1 - end_bytes

      if upper_bound < old_upper_bound
        # Remove extra bytes from old buffer
        buffer[(upper_bound + 1)..old_upper_bound] = ''
      elsif upper_bound > old_upper_bound
        # Grow buffer and preserve bytes at end of buffer if necesssary
        buffer_length = buffer.length
        diff = upper_bound - old_upper_bound
        buffer << ZERO_STRING * diff
        if end_bytes > 0
          buffer[(upper_bound + 1)..(buffer.length - 1)] = buffer[(old_upper_bound + 1)..(buffer_length - 1)]
        end
      end

      array_size = ((buffer.length * 8) - bit_offset + array_size)
    end
  end

  # Get data bounds for this array
  lower_bound = bit_offset / 8
  upper_bound = (bit_offset + array_size - 1) / 8
  num_bytes   = upper_bound - lower_bound + 1

  # Check for byte alignment
  byte_aligned = ((bit_offset % 8) == 0)

  # Calculate the number of writes
  num_writes = array_size / bit_size
  # Check for a negative array_size and adjust the number of writes
  # to simply be the number of values in the passed in array
  if given_array_size <= 0
    num_writes = values.length
  end

  # Ensure the buffer has enough room
  if bit_offset + num_writes * bit_size > buffer.length * 8
    raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size)
  end

  # Ensure the given_array_size is an even multiple of bit_size
  raise ArgumentError, "array_size #{given_array_size} not a multiple of bit_size #{given_bit_size}" if array_size % bit_size != 0

  raise ArgumentError, "too many values #{values.length} for given array_size #{given_array_size} and bit_size #{given_bit_size}" if num_writes < values.length

  # Check overflow type
  raise "unknown overflow type #{overflow}" unless OVERFLOW_TYPES.include?(overflow)

  case data_type
  when :STRING, :BLOCK
    #######################################
    # Handle :STRING and :BLOCK data types
    #######################################

    if byte_aligned
      num_writes.times do |index|
        self.write(values[index], bit_offset, bit_size, data_type, buffer, endianness, overflow)
        bit_offset += bit_size
      end
    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  when :INT, :UINT
    ###################################
    # Handle :INT and :UINT data types
    ###################################

    if byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)
      ###########################################################
      # Handle byte-aligned 8, 16, 32, and 64 bit :INT and :UINT
      ###########################################################

      case bit_size
      when 8
        if data_type == :INT
          values = self.check_overflow_array(values, -128, 127, 255, bit_size, data_type, overflow)
          packed = values.pack(PACK_8_BIT_INT_ARRAY)
        else # data_type == :UINT
          values = self.check_overflow_array(values, 0, 255, 255, bit_size, data_type, overflow)
          packed = values.pack(PACK_8_BIT_UINT_ARRAY)
        end

      when 16
        if data_type == :INT
          values = self.check_overflow_array(values, -32768, 32767, 65535, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_16_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_16_BIT_INT_ARRAY)
            self.byte_swap_buffer!(packed, 2)
          end
        else # data_type == :UINT
          values = self.check_overflow_array(values, 0, 65535, 65535, bit_size, data_type, overflow)
          if endianness == :BIG_ENDIAN
            packed = values.pack(PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY)
          else # endianness == :LITTLE_ENDIAN
            packed = values.pack(PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY)
          end
        end

      when 32
        if data_type == :INT
          values = self.check_overflow_array(values, -2147483648, 2147483647, 4294967295, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_32_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_32_BIT_INT_ARRAY)
            self.byte_swap_buffer!(packed, 4)
          end
        else # data_type == :UINT
          values = self.check_overflow_array(values, 0, 4294967295, 4294967295, bit_size, data_type, overflow)
          if endianness == :BIG_ENDIAN
            packed = values.pack(PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY)
          else # endianness == :LITTLE_ENDIAN
            packed = values.pack(PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY)
          end
        end

      when 64
        if data_type == :INT
          values = self.check_overflow_array(values, -9223372036854775808, 9223372036854775807, 18446744073709551615, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_64_BIT_INT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_64_BIT_INT_ARRAY)
            self.byte_swap_buffer!(packed, 8)
          end
        else # data_type == :UINT
          values = self.check_overflow_array(values, 0, 18446744073709551615, 18446744073709551615, bit_size, data_type, overflow)
          if endianness == HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_64_BIT_UINT_ARRAY)
          else # endianness != HOST_ENDIANNESS
            packed = values.pack(PACK_NATIVE_64_BIT_UINT_ARRAY)
            self.byte_swap_buffer!(packed, 8)
          end
        end
      end

      # Adjust packed size to hold number of items written
      buffer[lower_bound..upper_bound] = adjust_packed_size(num_bytes, packed) if num_bytes > 0

    else
      ##################################
      # Handle :INT and :UINT Bitfields
      ##################################

      raise ArgumentError, "write_array does not support little endian bit fields with bit_size greater than 1-bit" if endianness == :LITTLE_ENDIAN and bit_size > 1

      num_writes.times do |index|
        self.write(values[index], bit_offset, bit_size, data_type, buffer, endianness, overflow)
        bit_offset += bit_size
      end
    end

  when :FLOAT
    ##########################
    # Handle :FLOAT data type
    ##########################

    if byte_aligned
      case bit_size
      when 32
        if endianness == :BIG_ENDIAN
          packed = values.pack(PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY)
        else # endianness == :LITTLE_ENDIAN
          packed = values.pack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY)
        end

      when 64
        if endianness == :BIG_ENDIAN
          packed = values.pack(PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY)
        else # endianness == :LITTLE_ENDIAN
          packed = values.pack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY)
        end

      else
        raise ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}"
      end

      # Adjust packed size to hold number of items written
      buffer[lower_bound..upper_bound] = adjust_packed_size(num_bytes, packed) if num_bytes > 0

    else
      raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
    end

  else
    ############################
    # Handle Unknown data types
    ############################
    raise ArgumentError, "data_type #{data_type} is not recognized"
  end # case data_type

  values
end

Class: Cosmos::BinaryAccessor

Overview

Constant Summary collapse

Class Method Summary collapse

Class Method Details

.adjust_packed_size(num_bytes, packed) ⇒ Object

.byte_swap_buffer(buffer, num_bytes_per_word) ⇒ String

.byte_swap_buffer!(buffer, num_bytes_per_word) ⇒ String

.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ Integer

.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ Array[Integer]

.read(param_bit_offset, param_bit_size, param_data_type, param_buffer, param_endianness) ⇒ Integer

.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness) ⇒ Array

.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow) ⇒ Integer

.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow) ⇒ Array

.adjust_packed_size(num_bytes, packed) ⇒ `Object`

.byte_swap_buffer(buffer, num_bytes_per_word) ⇒ `String`

.byte_swap_buffer!(buffer, num_bytes_per_word) ⇒ `String`

.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ `Integer`

.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow) ⇒ `Array[Integer]`

.read(param_bit_offset, param_bit_size, param_data_type, param_buffer, param_endianness) ⇒ `Integer`

.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness) ⇒ `Array`

.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow) ⇒ `Integer`

.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow) ⇒ `Array`