bitsandbobs

-module(bitsandbobs@ints).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_bitarray/1, from_x_bits/2, from_bitarray/1, map_every_x_bits/3, map/2, add/3]).

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 20).
-spec to_bitarray(integer()) -> bitstring().
to_bitarray(Int) ->
    <<Int>>.

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 36).
-spec from_x_bits(bitstring(), integer()) -> {ok, integer()} | {error, nil}.
from_x_bits(Bitarray, Bit_count) ->
    case Bitarray of
        <<Ret:Bit_count, _/bitstring>> ->
            {ok, Ret};

        _ ->
            {error, nil}
    end.

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 27).
-spec from_bitarray(bitstring()) -> integer().
from_bitarray(Bitarray) ->
    _assert_subject = begin
        _pipe = Bitarray,
        _pipe@1 = bitsandbobs:bit_size(_pipe),
        from_x_bits(Bitarray, _pipe@1)
    end,
    {ok, Int} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"bitsandbobs/ints"/utf8>>,
                        function => <<"from_bitarray"/utf8>>,
                        line => 28})
    end,
    Int.

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 49).
-spec map_every_x_bits(bitstring(), integer(), fun((integer()) -> integer())) -> bitstring().
map_every_x_bits(Bitarray, Every, F) ->
    bitsandbobs:map(
        Bitarray,
        Every,
        fun(X) ->
            _assert_subject = begin
                _pipe = X,
                from_x_bits(_pipe, Every)
            end,
            {ok, Int} = case _assert_subject of
                {ok, _} -> _assert_subject;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                value => _assert_fail,
                                module => <<"bitsandbobs/ints"/utf8>>,
                                function => <<"map_every_x_bits"/utf8>>,
                                line => 55})
            end,
            Ret = begin
                _pipe@1 = Int,
                F(_pipe@1)
            end,
            <<Ret:(lists:max([(Every), 0]))>>
        end
    ).

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 44).
-spec map(bitstring(), fun((integer()) -> integer())) -> bitstring().
map(Bitarray, F) ->
    map_every_x_bits(Bitarray, 8, F).

-file("C:\\Users\\bradl\\Desktop\\bitsandbobs\\src\\bitsandbobs\\ints.gleam", 62).
-spec add(bitstring(), bitstring(), integer()) -> bitstring().
add(First, Second, Size) ->
    First_size = bitsandbobs:bit_size(First),
    Second_size = bitsandbobs:bit_size(Second),
    Padded_size = begin
        _pipe = gleam@int:max(First_size, Second_size),
        gleam@int:max(_pipe, Size)
    end,
    case First_size of
        S when S < Padded_size ->
            _pipe@1 = First,
            _pipe@2 = bitsandbobs:pad(_pipe@1, Padded_size - First_size),
            add(_pipe@2, Second, Size);

        _ ->
            case Second_size of
                S@1 when S@1 < Padded_size ->
                    _pipe@3 = Second,
                    _pipe@4 = bitsandbobs:pad(
                        _pipe@3,
                        Padded_size - Second_size
                    ),
                    add(_pipe@4, First, Size);

                _ ->
                    _pipe@5 = bitsandbobs:zip(First, Second, Size),
                    _pipe@8 = gleam@list:map(
                        _pipe@5,
                        fun(X) ->
                            {First@1, Second@1} = X,
                            _assert_subject = begin
                                _pipe@6 = First@1,
                                from_x_bits(_pipe@6, Size)
                            end,
                            {ok, First@2} = case _assert_subject of
                                {ok, _} -> _assert_subject;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail,
                                                module => <<"bitsandbobs/ints"/utf8>>,
                                                function => <<"add"/utf8>>,
                                                line => 80})
                            end,
                            _assert_subject@1 = begin
                                _pipe@7 = Second@1,
                                from_x_bits(_pipe@7, Size)
                            end,
                            {ok, Second@2} = case _assert_subject@1 of
                                {ok, _} -> _assert_subject@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail@1,
                                                module => <<"bitsandbobs/ints"/utf8>>,
                                                function => <<"add"/utf8>>,
                                                line => 81})
                            end,
                            Result = First@2 + Second@2,
                            <<Result:(lists:max([(Size), 0]))>>
                        end
                    ),
                    gleam_stdlib:bit_array_concat(_pipe@8)
            end
    end.