Ruby에 서명 된 리틀 엔디안 압축 풀기

Question

그래서 일부 MongoDB 프로토콜 작업을하고 있습니다. 모든 정수는 리틀 엔디안에 서명되어 있습니다.

positive_one = Array(1).pack('V') #=> '\x01\x00\x00\x00' 
negative_one = Array(-1).pack('V') #=> '\xFF\xFF\xFF\xFF' 

그러나, 다른 방법을 가고는 String#unpack 방법은 특별히 반환 설명 된 'V'형식이 : 루비의 표준 Array#pack 방법을 사용하여, 나는 이진 문자열 정수 내가 잘 할에서 을 변환 할 수 있습니다 부호 정수 : 서명 little endian의 바이트 순서에 대한 포맷터 없습니다

positive_one.unpack('V').first #=> 1 
negative_one.unpack('V').first #=> 4294967295 

. 나는 비트 - 시프 팅으로 게임을하거나 배열 패킹을 사용하지 않는 자신의 바이트 - mangling 방법을 쓸 수있을 것이라고 확신하지만, 다른 누군가가 이것을 실행하고 간단한 해결책을 찾았는지 궁금하다. 매우 감사합니다.

Answer 1

"V"으로 개봉 후에는 다음 (2**32입니다) 당신은 마법을 변경해야합니다

class Integer 
    def to_signed_32bit 
    if self & 0x8000_0000 == 0x8000_0000 
     self - 0x1_0000_0000 
    else 
     self 
    end 
    end 
end 

이 0x1_0000_0000 상수 변환 및 0x8000_0000 (2**31)를 적용 할 수 있습니다 다른 크기의 정수와 함께.

Answer 2

This question에는 도움이 될 수있는 부호가있는 부호로 변환하는 방법이 있습니다. 그것도 당신이 원하는대로 할 것 같아 보이는 bindata 보석에 대한 포인터를 가지고 있습니다.

BinData::Int16le.read("\000\f") # 3072 

은 (주석에 따라) 내가 원래 변환 된 방향을 잘못 이해

Answer 3

편집 [하지 않은 상당히 오른쪽의 압축 풀기 지시문을 제거하기 위해 편집]. 그러나 그것에 대해 생각한 후에도 솔루션은 여전히 ​​동일하다고 생각합니다. 다음은 업데이트 된 방법입니다. 그것은 똑같은 일을하지만, 코멘트 결과를 설명해야한다 : 아마

def convertLEToNative(num) 
    # Convert a given 4 byte integer from little-endian to the running 
    # machine's native endianess. The pack('V') operation takes the 
    # given number and converts it to little-endian (which means that 
    # if the machine is little endian, no conversion occurs). On a 
    # big-endian machine, the pack('V') will swap the bytes because 
    # that's what it has to do to convert from big to little endian. 
    # Since the number is already little endian, the swap has the 
    # opposite effect (converting from little-endian to big-endian), 
    # which is what we want. In both cases, the unpack('l') just 
    # produces a signed integer from those bytes, in the machine's 
    # native endianess. 
    Array(num).pack('V').unpack('l') 
end 

없는 깨끗한을하지만,이 바이트 배열을 변환합니다. 당신이 상대하고있는 경우

def convertLEBytesToNative(bytes) 
    if ([1].pack('V').unpack('l').first == 1) 
     # machine is already little endian 
     bytes.unpack('l') 
    else 
     # machine is big endian 
     convertLEToNative(Array(bytes.unpack('l'))) 
    end 
end 

Answer 4

후손을 위해서, 나는 Paul Rubel의 "classical method" 링크를 알아 내기 전에 결국 생각해 낸 방법이 있습니다. 그것은 미봉책과 문자열 조작에 따라, 그래서 아마 스크랩 하겠지만, 누군가가 언젠가는 다른 이유가 흥미있을 거라고 그래서이 작업을 수행

이

# Returns an integer from the given little-endian binary string. 
# @param [String] str 
# @return [Fixnum] 
def self.bson_to_int(str) 
    bits = str.reverse.unpack('B*').first # Get the 0s and 1s 
    if bits[0] == '0' # We're a positive number; life is easy 
    bits.to_i(2) 
    else    # Get the twos complement 
    comp, flip = "", false 
    bits.reverse.each_char do |bit| 
     comp << (flip ? bit.tr('10','01') : bit) 
     flip = true if !flip && bit == '1' 
    end 
    ("-" + comp.reverse).to_i(2) 
    end 
end 

UPDATE : 여기 사용하여 간단한 리팩토링이다 켄 블룸의 일반화 된 임의 길이 형태의 답 :

# Returns an integer from the given arbitrary length little-endian binary string. 
# @param [String] str 
# @return [Fixnum] 
def self.bson_to_int(str) 
    arr, bits, num = str.unpack('V*'), 0, 0 
    arr.each do |int| 
    num += int << bits 
    bits += 32 
    end 
    num >= 2**(bits-1) ? num - 2**bits : num # Convert from unsigned to signed 
end