hex2bytes for Vector{UInt8}

base/exports.jl

@@ -762,6 +762,7 @@ export
     graphemes,
     hex,
     hex2bytes,
+    hex2bytes!,
     ind2chr,
     info,
     is_assigned_char,

base/strings/util.jl

@@ -463,12 +463,90 @@ function hex2bytes(s::AbstractString)
     return a
 end
 
+"""
+    hex2bytes(s::AbstractVector{UInt8})
+
+Convert the hexadecimal bytes array to its binary representation. Returns
+`Vector{UInt8}`, i.e. a vector of bytes.
+"""
+@inline function hex2bytes(s::AbstractVector{UInt8})
+    len = length(s)
+    if isodd(len)
+        throw(ArgumentError("source vector length must be even"))
+    end
+    d = zeros(UInt8, div(len, 2))
+    return hex2bytes!(d, s)
+end
+
+"""
+    hex2bytes!(d::AbstractVector{UInt8}, s::AbstractVector{UInt8})
+
+Converts the hexadecimal bytes vector to its binary representation. The results are
+populated into a destination vector. The function returns the destination vector.
+
+# Examples
+```jldoctest
+julia> s = UInt8["01abEF"...]
+6-element Array{UInt8,1}:
+ 0x30
+ 0x31
+ 0x61
+ 0x62
+ 0x45
+ 0x46
+
+julia> d =zeros(UInt8, 3)
+3-element Array{UInt8,1}:
+ 0x00
+ 0x00
+ 0x00
+
+julia> hex2bytes!(d, s)
+3-element Array{UInt8,1}:
+ 0x01
+ 0xab
+ 0xef
+```
+"""
+function hex2bytes!(d::AbstractVector{UInt8}, s::AbstractVector{UInt8})
+    i, j = start(s), 0
+    # This line is important as this ensures computation happens in word boundary and not
+    # byte boundary. Boundary computation can be almost 10 times slower
+    n::UInt = 0
+    c1::UInt = 0
+    c2::UInt = 0
+    while !done(s, i)
+        n = 0
+        c1, i = next(s, i)
+        done(s, i) && throw(ArgumentError("source vector length must be even"))
+        c2, i = next(s, i)
+        n = number_from_hex(c1)
+        n <<= 4
+        n += number_from_hex(c2)
+        d[j+=1] = (n & 0xFF)
+    end
+    return d
+end
+
+@inline function number_from_hex(c::UInt)
+    DIGIT_ZERO     = UInt('0')
+    DIGIT_NINE     = UInt('9')
+    LATIN_UPPER_A  = UInt('A')
+    LATIN_UPPER_F  = UInt('F')
+    LATIN_A        = UInt('a')
+    LATIN_F        = UInt('f')
+
+    return (DIGIT_ZERO <= c <= DIGIT_NINE) ? c - DIGIT_ZERO :
+        (LATIN_UPPER_A <= c <= LATIN_UPPER_F) ? c - LATIN_UPPER_A + 10 :
+        (LATIN_A <= c <= LATIN_F) ? c - LATIN_A + 10 :
+        throw(ArgumentError("not a hexadecimal number: '$(Char(c))'"))
+end
+
 """
     bytes2hex(bin_arr::Array{UInt8, 1}) -> String
 
 Convert an array of bytes to its hexadecimal representation.
 All characters are in lower-case.
-
 # Examples
 ```jldoctest
 julia> a = hex(12345)

doc/src/stdlib/numbers.md

@@ -59,6 +59,7 @@ Base.Math.exponent
 Base.complex(::Complex)
 Base.bswap
 Base.hex2bytes
+Base.hex2bytes!
 Base.bytes2hex
 ```
 

test/strings/util.jl

@@ -247,3 +247,24 @@ bin_val = hex2bytes("07bf")
 
 #non-hex characters
 @test_throws ArgumentError hex2bytes("0123456789abcdefABCDEFGH")
+
+@testset "Issue 23161" begin
+    arr = UInt8["0123456789abcdefABCDEF"...]
+    arr1 = Vector{UInt8}(11)
+    @test hex2bytes!(arr1, arr) == arr1
+    @test "0123456789abcdefabcdef" == bytes2hex(arr1)
+    @test hex2bytes("0123456789abcdefABCDEF") == hex2bytes(arr)
+    @test hex2bytes!(arr1, UInt8[""...]) == arr1
+    @test hex2bytes(UInt8[""...]) == UInt8[]
+    @test hex2bytes(view(UInt8["012345"...],1:6)) == UInt8[0x01,0x23,0x45]
+    @test begin
+        s = view(UInt8["012345ab"...],1:6)
+        d = view(zeros(UInt8, 10),1:3)
+        hex2bytes!(d,s) == UInt8[0x01,0x23,0x45]
+    end
+    # odd size
+    @test_throws ArgumentError hex2bytes(UInt8["0123456789abcdefABCDEF0"...])
+
+    #non-hex characters
+    @test_throws ArgumentError hex2bytes(UInt8["0123456789abcdefABCDEFGH"...])
+end