pack

        # Array.pack

(from ruby core)
---
    arr.pack( aTemplateString ) -> aBinaryString
    arr.pack( aTemplateString, buffer: aBufferString ) -> aBufferString

---

Packs the contents of *arr* into a binary sequence according to the
directives in *aTemplateString* (see the table below) Directives ``A,''
``a,'' and ``Z'' may be followed by a count, which gives the width of
the resulting field. The remaining directives also may take a count,
indicating the number of array elements to convert. If the count is an
asterisk (```*`''), all remaining array elements will be converted. Any
of the directives ```sSiIlL`'' may be followed by an underscore
(```_`'') or exclamation mark (```!`'') to use the underlying platform's
native size for the specified type; otherwise, they use a
platform-independent size. Spaces are ignored in the template string.
See also String#unpack.

    a = [ "a", "b", "c" ]
    n = [ 65, 66, 67 ]
    a.pack("A3A3A3")   #=> "a  b  c  "
    a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
    n.pack("ccc")      #=> "ABC"

If *aBufferString* is specified and its capacity is enough, `pack` uses
it as the buffer and returns it. When the offset is specified by the
beginning of *aTemplateString*, the result is filled after the offset.
If original contents of *aBufferString* exists and it's longer than the
offset, the rest of *offsetOfBuffer* are overwritten by the result. If
it's shorter, the gap is filled with ```\0`''.

    # packed data is appended by default
    [255].pack("C", buffer:"foo".b) #=> "foo\xFF"

    # "@0" (offset 0) specifies that packed data is filled from beginning.
    # Also, original data after packed data is removed. ("oo" is removed.)
    [255].pack("@0C", buffer:"foo".b) #=> "\xFF"

    # If the offset is bigger than the original length, \x00 is filled.
    [255].pack("@5C", buffer:"foo".b) #=> "foo\x00\x00\xFF"

Note that ``buffer:'' option does not guarantee not to allocate memory
in `pack`.  If the capacity of *aBufferString* is not enough, `pack`
allocates memory.

Directives for `pack`.

    Integer       | Array   |
    Directive     | Element | Meaning
    ----------------------------------------------------------------------------
    C             | Integer | 8-bit unsigned (unsigned char)
    S             | Integer | 16-bit unsigned, native endian (uint16_t)
    L             | Integer | 32-bit unsigned, native endian (uint32_t)
    Q             | Integer | 64-bit unsigned, native endian (uint64_t)
    J             | Integer | pointer width unsigned, native endian (uintptr_t)
                  |         | (J is available since Ruby 2.3.)
                  |         |
    c             | Integer | 8-bit signed (signed char)
    s             | Integer | 16-bit signed, native endian (int16_t)
    l             | Integer | 32-bit signed, native endian (int32_t)
    q             | Integer | 64-bit signed, native endian (int64_t)
    j             | Integer | pointer width signed, native endian (intptr_t)
                  |         | (j is available since Ruby 2.3.)
                  |         |
    S_ S!         | Integer | unsigned short, native endian
    I I_ I!       | Integer | unsigned int, native endian
    L_ L!         | Integer | unsigned long, native endian
    Q_ Q!         | Integer | unsigned long long, native endian (ArgumentError
                  |         | if the platform has no long long type.)
                  |         | (Q_ and Q! is available since Ruby 2.1.)
    J!            | Integer | uintptr_t, native endian (same with J)
                  |         | (J! is available since Ruby 2.3.)
                  |         |
    s_ s!         | Integer | signed short, native endian
    i i_ i!       | Integer | signed int, native endian
    l_ l!         | Integer | signed long, native endian
    q_ q!         | Integer | signed long long, native endian (ArgumentError
                  |         | if the platform has no long long type.)
                  |         | (q_ and q! is available since Ruby 2.1.)
    j!            | Integer | intptr_t, native endian (same with j)
                  |         | (j! is available since Ruby 2.3.)
                  |         |
    S> s> S!> s!> | Integer | same as the directives without ">" except
    L> l> L!> l!> |         | big endian
    I!> i!>       |         | (available since Ruby 1.9.3)
    Q> q> Q!> q!> |         | "S>" is the same as "n"
    J> j> J!> j!> |         | "L>" is the same as "N"
                  |         |
    S< s< S!< s!< | Integer | same as the directives without "<" except
    L< l< L!< l!< |         | little endian
    I!< i!<       |         | (available since Ruby 1.9.3)
    Q< q< Q!< q!< |         | "S<" is the same as "v"
    J< j< J!< j!< |         | "L<" is the same as "V"
                  |         |
    n             | Integer | 16-bit unsigned, network (big-endian) byte order
    N             | Integer | 32-bit unsigned, network (big-endian) byte order
    v             | Integer | 16-bit unsigned, VAX (little-endian) byte order
    V             | Integer | 32-bit unsigned, VAX (little-endian) byte order
                  |         |
    U             | Integer | UTF-8 character
    w             | Integer | BER-compressed integer

    Float        | Array   |
    Directive    | Element | Meaning
    ---------------------------------------------------------------------------
    D d          | Float   | double-precision, native format
    F f          | Float   | single-precision, native format
    E            | Float   | double-precision, little-endian byte order
    e            | Float   | single-precision, little-endian byte order
    G            | Float   | double-precision, network (big-endian) byte order
    g            | Float   | single-precision, network (big-endian) byte order

    String       | Array   |
    Directive    | Element | Meaning
    ---------------------------------------------------------------------------
    A            | String  | arbitrary binary string (space padded, count is width)
    a            | String  | arbitrary binary string (null padded, count is width)
    Z            | String  | same as ``a'', except that null is added with *
    B            | String  | bit string (MSB first)
    b            | String  | bit string (LSB first)
    H            | String  | hex string (high nibble first)
    h            | String  | hex string (low nibble first)
    u            | String  | UU-encoded string
    M            | String  | quoted printable, MIME encoding (see also RFC2045)
                 |         | (text mode but input must use LF and output LF)
    m            | String  | base64 encoded string (see RFC 2045)
                 |         | (if count is 0, no line feed are added, see RFC 4648)
                 |         | (count specifies input bytes between each LF,
                 |         | rounded down to nearest multiple of 3)
    P            | String  | pointer to a structure (fixed-length string)
    p            | String  | pointer to a null-terminated string

    Misc.        | Array   |
    Directive    | Element | Meaning
    ---------------------------------------------------------------------------
    @            | ---     | moves to absolute position
    X            | ---     | back up a byte
    x            | ---     | null byte