PythonStructs

PythonStructs

The PythonStructs package implements the Python structs standard library in Julia.

BigEndianModifier = Modifier{:big_endian, :standard, :none}

• byte_order :big_endian
• size :standard
• alignment :none

LittleEndianModifier = Modifier{:little_endian, :standard, :none}

• byte_order :little_endian
• size :standard
• alignment :none

Modifier{byte_order, size, alignment}()

Modifier indicates how a Python struct string is interpreted. It is usually determined by the first character of the string.

Arguments

• byte_order is either :native (default), :littleendian, or :bigendian
• size is either :native (default) or :standard
• alignment is either :native (default) or :none

Accessing Parameters

Modifier parameters can be accessed via the following access methods applied to either the Modifier type or an instance.

• byte_order_param
• size_param
• alignment_param

Modifier parameters can also be accessed via the following properties of a Modifier instance.

• .byte_order
• .size
• .alignment

Constants

• NativeModifier, '@', corresponds to Modifier{:native, :native, :native}
• NativeStandardModifier, '=', corresponds to Modifier{:native, :standard, :none}
• LittleEndianModifier, <, corresponds to Modifier{:little_endian, :standard, :none}
• BigEndianModifier, <, corresponds to Modifier{:big_endian, :standard, :none}
• NetworkModifier, !, is the same as BigEndianModifier

Examples

julia> LittleEndianModifier
LittleEndianModifier (alias for PythonStructs.Modifier{:little_endian, :standard, :none})

julia> m = LittleEndianModifier()
LittleEndianModifier()

julia> m.byte_order
:little_endian

julia> m.size
:standard

julia> m.alignment
:none

julia> PythonStructs.byte_order_param(PythonStructs.NativeModifier)
:native

Extended Help

Endianness

Endianness indicates the order of the bytes for multiple byte number types.

• Little endian order has the least significant byte (LSB) come first.
• Big endian order has the most significant byte (MSB) come first.

Size

Size influences how the type characters are mapped to machine types.

• Native size corresponds to C types on the current system. For example, 'l' corresponds to Clong, or Int64 on 64-bit systems.
• Standard size corresponds to fixed-size machine types that may differ from their native size counterparts. For example, 'l' corresponds to Int32.

Alignment

Alignment influences whether padding bytes are employed or not.

• Native alignment corresponds with how C and Julia use padding bytes.
• No alignment (none) does not use padding bytes.

NativeModifier = Modifier{:native, :native, :native}

This constant is the default Modifier.

• byte_order :native
• size :native
• alignment :native

NativeStandardModifier = Modifier{:native, :standard, :none}}

• byte_order :native
• size :standard
• alignment :none

NetworkModifier = BigEndianModifier

Alias for BigEndianModifier

NullByte

Represents 0x00 corresponding with 'x'.

PythonStruct{T, M <: Modifier}(arg::T)
PythonStruct{T, M <: Modifier}(args...)
PythonStruct(string::AbstractString)

Wrap a type T with Modifier parameters or construct a PythonStruct type from an AbstractString.

ZeroCount{T}

Represents a 0 count of a type, which has some special meanings.

string(s::Type{<: PythonStruct})

Convert a PythonStruct to a Python struct format string. The conversion is done with standard types.

calcsize(::Type{<: PythonStruct})

Calculate the size of a PythonStruct type. This differs from sizeof in the following ways.

• The inclusion of padding bytes depends on the Modifier alignment.
• Trailing padding bytes are not included.

modifier(c::Char)
modifier(str::AbstractString)

Obtain the Modifier from a character. If an AbstractString is provided, the first character is sued.

• '@' corresponds to Modifier(:native, :native, :native)
• = corresponds to Modifier(:native, :standard, :none)
• < corresponds to Modifier(:little_endian, :standard, :none)
• > corresponds to Modifier(:big_endian, :standard, :none)
• ! corresponds to Modifier(:big_endian, :standard, :none)

modifier_char(s::Type{<: PythonStruct})

Get the modifier character for a particular Modifier constant.

pack([io::IO], s::PS) where PS <: PythonStruct
pack(PythonStruct{T,M}, [io::IO], args...)
pack(s::AbstractString, [io::IO], args...)

Pack a PythonStruct into bytes. If io is provided, the bytes are written the IO object. Otherwise, the bytes are returned as a Vector{UInt8}.

python_struct_lower_to_tuple_type(pystruct_string::AbstractString, dict::AbstractDict)

Convert python struct string to a Tuple{...} type by encoding each character or string as a component type.

python_struct_to_native_type(pystruct_string::AbstractString)

Use python_struct_to_type with the native format dictionary.

Private API

python_struct_to_standard_type(pystruct_string::AbstractString)

Use python_struct_to_type with the standard format dictionary.

Private API

python_struct_to_type(pystruct_string::AbstractString)
python_struct_to_type(pystruct_string::AbstractString, m::Modifier)
python_struct_to_type(pystruct_symbol::Symbol, modifier = default_modifier)

Convert a Python struct string to a PythonStruct type.

Private API

pystruct""

Create a PythonStruct type from type characters.