Packages
thrifty

1.1.0
1.1.2 1.1.1 1.1.0 1.0.0
Pure Gleam implementation of the Apache Thrift Compact Protocol
HexDocs
Current section
Files
Jump to
Readme 4 Versions 2 Dependencies Dependants Files Activity
thrifty src thrifty@writer.erl
Raw
src/thrifty@writer.erl

-module(thrifty@writer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/thrifty/writer.gleam").
-export([write_varint/1, write_zigzag_i32_checked/1, write_zigzag_i64_checked/1, write_i8/1, write_i16/1, write_i32_checked/1, write_i64_checked/1, write_double/1, write_field_header/3, write_message_header/1, write_list_header/2, write_map_header/3, write_binary/1, write_string/1, write_list/3, write_map/4, buffer_new/0, buffer_append/2, buffer_to_bitarray/1, write_bool_inline/3, write_bool/3, write_zigzag_i32/1, write_zigzag_i64/1, write_i32/1, write_i64/1]).
-export_type([buffer/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type buffer() :: {buffer, list(bitstring())}.

-file("src/thrifty/writer.gleam", 33).
?DOC(
    " Encode a raw unsigned integer as varint bytes.\n"
    "\n"
    " Inputs\n"
    " - `value`: non-negative integer to encode.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` containing 1..10 bytes of varint-encoded data.\n"
).
-spec write_varint(integer()) -> bitstring().
write_varint(Value) ->
    thrifty@varint:encode_varint(Value).

-file("src/thrifty/writer.gleam", 63).
?DOC(
    " Checked i32 ZigZag encoder that returns the resulting bytes or an error.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer to encode.\n"
    "\n"
    " Outputs\n"
    " - `Ok(BitArray)` containing the encoded bytes on success.\n"
    " - `Error(ZigzagRangeError)` when `value` is out of the i32 range.\n"
).
-spec write_zigzag_i32_checked(integer()) -> {ok, bitstring()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_zigzag_i32_checked(Value) ->
    case thrifty@zigzag:encode_i32_checked(Value) of
        {error, Err} ->
            {error, Err};

        {ok, Encoded} ->
            {ok, thrifty@varint:encode_varint(Encoded)}
    end.

-file("src/thrifty/writer.gleam", 98).
?DOC(
    " Checked i64 ZigZag encoder that returns the resulting bytes or an error.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer to encode.\n"
    "\n"
    " Outputs\n"
    " - `Ok(BitArray)` containing the encoded bytes on success.\n"
    " - `Error(ZigzagRangeError)` when `value` is out of the i64 range.\n"
).
-spec write_zigzag_i64_checked(integer()) -> {ok, bitstring()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_zigzag_i64_checked(Value) ->
    case thrifty@zigzag:encode_i64_checked(Value) of
        {error, Err} ->
            {error, Err};

        {ok, Encoded} ->
            {ok, thrifty@varint:encode_varint(Encoded)}
    end.

-file("src/thrifty/writer.gleam", 118).
?DOC(
    " Write a single signed byte value.\n"
    "\n"
    " Inputs\n"
    " - `value`: integer in -128..127 that will be represented as a single byte.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` of length 1 containing the byte.\n"
    "\n"
    " Error modes\n"
    " - Panics when `value` is outside -128..127. Use a range check before\n"
    "   calling if the value origin is untrusted.\n"
).
-spec write_i8(integer()) -> bitstring().
write_i8(Value) ->
    case (Value < -128) orelse (Value > 127) of
        true ->
            erlang:error(#{gleam_error => panic,
                    message => (<<<<"Value "/utf8,
                            (erlang:integer_to_binary(Value))/binary>>/binary,
                        " overflows i8"/utf8>>),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_i8"/utf8>>,
                    line => 120});

        false ->
            <<Value:8/integer>>
    end.

-file("src/thrifty/writer.gleam", 135).
?DOC(
    " Write an i16 value using zigzag encoding and varint bytes.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer in -32768..32767.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` with the encoded bytes (zigzag + varint).\n"
    "\n"
    " Error modes\n"
    " - Panics when `value` is outside the i16 range.\n"
).
-spec write_i16(integer()) -> bitstring().
write_i16(Value) ->
    case (Value < -32768) orelse (Value > 32767) of
        true ->
            erlang:error(#{gleam_error => panic,
                    message => (<<<<"Value "/utf8,
                            (erlang:integer_to_binary(Value))/binary>>/binary,
                        " overflows i16"/utf8>>),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_i16"/utf8>>,
                    line => 137});

        false ->
            thrifty@varint:encode_varint(thrifty@zigzag:encode_i32(Value))
    end.

-file("src/thrifty/writer.gleam", 164).
?DOC(
    " Checked i32 writer that returns an error on overflow.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer to write.\n"
    "\n"
    " Outputs\n"
    " - `Ok(BitArray)` with encoded bytes on success.\n"
    " - `Error(ZigzagRangeError)` when the value is out of range.\n"
).
-spec write_i32_checked(integer()) -> {ok, bitstring()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_i32_checked(Value) ->
    write_zigzag_i32_checked(Value).

-file("src/thrifty/writer.gleam", 192).
?DOC(
    " Checked i64 writer that returns an error on overflow.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer to write.\n"
    "\n"
    " Outputs\n"
    " - `Ok(BitArray)` with encoded bytes on success.\n"
    " - `Error(ZigzagRangeError)` when the value is out of range.\n"
).
-spec write_i64_checked(integer()) -> {ok, bitstring()} |
    {error, thrifty@zigzag:zigzag_range_error()}.
write_i64_checked(Value) ->
    write_zigzag_i64_checked(Value).

-file("src/thrifty/writer.gleam", 205).
?DOC(
    " Write a 64-bit little-endian IEEE‑754 float value.\n"
    "\n"
    " Inputs\n"
    " - `value`: floating point number to encode.\n"
    "\n"
    " Outputs\n"
    " - `BitArray` of 8 bytes containing the IEEE‑754 little-endian encoding.\n"
).
-spec write_double(float()) -> bitstring().
write_double(Value) ->
    <<Value:64/float-little>>.

-file("src/thrifty/writer.gleam", 210).
?DOC(" Encode a field header with compact delta encoding logic.\n").
-spec write_field_header(integer(), thrifty@types:field_type(), integer()) -> bitstring().
write_field_header(Field_id, Field_type, Last_field_id) ->
    thrifty@field:encode_field_header(Field_id, Field_type, Last_field_id).

-file("src/thrifty/writer.gleam", 219).
?DOC(" Encode a message header.\n").
-spec write_message_header(thrifty@message:message_header()) -> bitstring().
write_message_header(Header) ->
    thrifty@message:encode_message_header(Header).

-file("src/thrifty/writer.gleam", 235).
?DOC(" Encode a list header.\n").
-spec write_list_header(integer(), thrifty@container:element_type()) -> bitstring().
write_list_header(Size, Element_type) ->
    thrifty@container:encode_list_header(Size, Element_type).

-file("src/thrifty/writer.gleam", 243).
?DOC(" Encode a map header.\n").
-spec write_map_header(
    integer(),
    thrifty@container:element_type(),
    thrifty@container:element_type()
) -> bitstring().
write_map_header(Size, Key_type, Value_type) ->
    thrifty@container:encode_map_header(Size, Key_type, Value_type).

-file("src/thrifty/writer.gleam", 277).
?DOC(
    " Concatenate a list of `BitArray` parts into a single contiguous `BitArray`.\n"
    "\n"
    " Inputs\n"
    " - `parts`: list of `BitArray` values to concatenate in order.\n"
    "\n"
    " Outputs\n"
    " - A single `BitArray` containing the concatenated bytes.\n"
).
-spec concat_many(list(bitstring())) -> bitstring().
concat_many(Parts) ->
    gleam@list:fold(
        Parts,
        <<>>,
        fun(Acc, Part) -> gleam_stdlib:bit_array_concat([Acc, Part]) end
    ).

-file("src/thrifty/writer.gleam", 224).
?DOC(" Write a length-prefixed binary blob.\n").
-spec write_binary(bitstring()) -> bitstring().
write_binary(Bytes) ->
    Length = erlang:byte_size(Bytes),
    concat_many([thrifty@varint:encode_varint(Length), Bytes]).

-file("src/thrifty/writer.gleam", 230).
?DOC(" Write a UTF-8 string as length-prefixed binary.\n").
-spec write_string(binary()) -> bitstring().
write_string(Value) ->
    write_binary(<<Value/binary>>).

-file("src/thrifty/writer.gleam", 252).
?DOC(" Encode a list by combining its header and payload.\n").
-spec write_list(integer(), thrifty@container:element_type(), bitstring()) -> bitstring().
write_list(Size, Element_type, Payload) ->
    concat_many([write_list_header(Size, Element_type), Payload]).

-file("src/thrifty/writer.gleam", 261).
?DOC(" Encode a map by combining its header and payload.\n").
-spec write_map(
    integer(),
    thrifty@container:element_type(),
    thrifty@container:element_type(),
    bitstring()
) -> bitstring().
write_map(Size, Key_type, Value_type, Payload) ->
    concat_many([write_map_header(Size, Key_type, Value_type), Payload]).

-file("src/thrifty/writer.gleam", 287).
?DOC(" Create a new empty buffer accumulator for high-level writer assembly.\n").
-spec buffer_new() -> buffer().
buffer_new() ->
    {buffer, []}.

-file("src/thrifty/writer.gleam", 299).
?DOC(
    " Append a part to an existing `Buffer` accumulator.\n"
    "\n"
    " Inputs\n"
    " - `buffer`: existing `Buffer`.\n"
    " - `part`: `BitArray` to append.\n"
    "\n"
    " Outputs\n"
    " - New `Buffer` with `part` added to the internal list.\n"
).
-spec buffer_append(buffer(), bitstring()) -> buffer().
buffer_append(Buffer, Part) ->
    case Buffer of
        {buffer, Parts} ->
            {buffer, [Part | Parts]}
    end.

-file("src/thrifty/writer.gleam", 309).
?DOC(
    " Convert an accumulated `Buffer` into a contiguous `BitArray`.\n"
    "\n"
    " Outputs\n"
    " - Concatenated `BitArray` in original append order.\n"
).
-spec buffer_to_bitarray(buffer()) -> bitstring().
buffer_to_bitarray(Buffer) ->
    case Buffer of
        {buffer, Parts} ->
            concat_many(lists:reverse(Parts))
    end.

-file("src/thrifty/writer.gleam", 321).
?DOC(" Write a boolean field using the inline header helper.\n").
-spec write_bool_inline(integer(), boolean(), integer()) -> bitstring().
write_bool_inline(Field_id, Value, Last_field_id) ->
    Field_type = case Value of
        true ->
            bool_true;

        false ->
            bool_false
    end,
    write_field_header(Field_id, Field_type, Last_field_id).

-file("src/thrifty/writer.gleam", 316).
?DOC(" Write a boolean field using the inline field header encoding.\n").
-spec write_bool(integer(), boolean(), integer()) -> bitstring().
write_bool(Field_id, Value, Last_field_id) ->
    write_bool_inline(Field_id, Value, Last_field_id).

-file("src/thrifty/writer.gleam", 334).
?DOC(" Format a `ZigzagRangeError` into a human readable string for panics/logs.\n").
-spec zigzag_error_to_string(thrifty@zigzag:zigzag_range_error()) -> binary().
zigzag_error_to_string(Err) ->
    case Err of
        {zigzag_range_error, Value, Bits} ->
            <<<<<<"Value "/utf8, (erlang:integer_to_binary(Value))/binary>>/binary,
                    " overflows i"/utf8>>/binary,
                (erlang:integer_to_binary(Bits))/binary>>
    end.

-file("src/thrifty/writer.gleam", 48).
?DOC(
    " Encode an i32 using ZigZag followed by varint encoding.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer expected to fit in 32-bit signed range.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` containing the zigzag-then-varint encoding.\n"
    "\n"
    " Error modes\n"
    " - Panics if `value` does not fit in the i32 range. Prefer\n"
    "   `write_zigzag_i32_checked/1` to handle overflow explicitly.\n"
).
-spec write_zigzag_i32(integer()) -> bitstring().
write_zigzag_i32(Value) ->
    case write_zigzag_i32_checked(Value) of
        {ok, Bits} ->
            Bits;

        {error, Err} ->
            erlang:error(#{gleam_error => panic,
                    message => zigzag_error_to_string(Err),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_zigzag_i32"/utf8>>,
                    line => 51})
    end.

-file("src/thrifty/writer.gleam", 83).
?DOC(
    " Encode an i64 using ZigZag followed by varint encoding.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer expected to fit in 64-bit signed range.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` containing the zigzag-then-varint encoding.\n"
    "\n"
    " Error modes\n"
    " - Panics if `value` does not fit in the i64 range. Prefer\n"
    "   `write_zigzag_i64_checked/1` to handle overflow explicitly.\n"
).
-spec write_zigzag_i64(integer()) -> bitstring().
write_zigzag_i64(Value) ->
    case write_zigzag_i64_checked(Value) of
        {ok, Bits} ->
            Bits;

        {error, Err} ->
            erlang:error(#{gleam_error => panic,
                    message => zigzag_error_to_string(Err),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_zigzag_i64"/utf8>>,
                    line => 86})
    end.

-file("src/thrifty/writer.gleam", 149).
?DOC(
    " Write an i32 value using zigzag encoding and varint bytes.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer expected to fit in i32 range.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` containing the encoded bytes or panics on overflow.\n"
).
-spec write_i32(integer()) -> bitstring().
write_i32(Value) ->
    case write_i32_checked(Value) of
        {ok, Bits} ->
            Bits;

        {error, Err} ->
            erlang:error(#{gleam_error => panic,
                    message => zigzag_error_to_string(Err),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_i32"/utf8>>,
                    line => 152})
    end.

-file("src/thrifty/writer.gleam", 177).
?DOC(
    " Write an i64 value using zigzag encoding and varint bytes.\n"
    "\n"
    " Inputs\n"
    " - `value`: signed integer expected to fit in i64 range.\n"
    "\n"
    " Outputs\n"
    " - Returns a `BitArray` with the encoded bytes or panics on overflow.\n"
).
-spec write_i64(integer()) -> bitstring().
write_i64(Value) ->
    case write_i64_checked(Value) of
        {ok, Bits} ->
            Bits;

        {error, Err} ->
            erlang:error(#{gleam_error => panic,
                    message => zigzag_error_to_string(Err),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"thrifty/writer"/utf8>>,
                    function => <<"write_i64"/utf8>>,
                    line => 180})
    end.
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT