themis

-module(themis@internal@erlang@ets).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/themis/internal/erlang/ets.gleam").
-export([new/2, info/1, insert/3, insert_many/2, insert_raw/2, insert_new_raw/2, lookup/2, counter_increment/2, match_metric/2, match_record/2, counter_increment_by/3, delete_table/1]).
-export_type([table_builder/0, table/0, table_type/0, table_info/0, table_access/0, tid/0, table_error/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.

?MODULEDOC(false).

-type table_builder() :: {table_builder, table_type(), table_access()}.

-type table() :: any().

-type table_type() :: set | ordered_set | bag | duplicate_bag.

-type table_info() :: {table_info,
        tid(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        integer(),
        gleam@erlang@process:pid_(),
        gleam@option:option(gleam@erlang@process:pid_()),
        gleam@erlang@atom:atom_(),
        integer(),
        gleam@erlang@atom:atom_(),
        boolean(),
        table_type(),
        integer(),
        table_access()}.

-type table_access() :: public | protected | private.

-type tid() :: any().

-type table_error() :: {atom_from_string_error,
        gleam@erlang@atom:from_string_error()} |
    {decode_error, list(gleam@dynamic@decode:decode_error())} |
    insert_failed.

-file("src/themis/internal/erlang/ets.gleam", 176).
?DOC(false).
-spec guard_atom_from_string(
    binary(),
    fun((gleam@erlang@atom:atom_()) -> {ok, FDJ} | {error, table_error()})
) -> {ok, FDJ} | {error, table_error()}.
guard_atom_from_string(Table_name, Fun) ->
    R = begin
        _pipe = gleam_erlang_ffi:atom_from_string(Table_name),
        gleam@result:map_error(_pipe, fun(E) -> {atom_from_string_error, E} end)
    end,
    gleam@result:'try'(R, Fun).

-file("src/themis/internal/erlang/ets.gleam", 59).
?DOC(false).
-spec new(table_builder(), binary()) -> gleam@erlang@atom:atom_().
new(Builder, Name) ->
    _pipe = erlang:binary_to_atom(Name),
    themis_external:new(
        _pipe,
        erlang:element(2, Builder),
        erlang:element(3, Builder)
    ).

-file("src/themis/internal/erlang/ets.gleam", 64).
?DOC(false).
-spec info(gleam@erlang@atom:atom_()) -> table_info().
info(Table_name) ->
    R = themis_external:info(Table_name),
    {table_info,
        erlang:element(2, erlang:element(1, R)),
        erlang:element(2, erlang:element(2, R)),
        erlang:element(2, erlang:element(3, R)),
        erlang:element(2, erlang:element(4, R)),
        erlang:element(2, erlang:element(5, R)),
        erlang:element(2, erlang:element(6, R)),
        erlang:element(2, erlang:element(7, R)),
        erlang:element(2, erlang:element(8, R)),
        erlang:element(2, erlang:element(9, R)),
        erlang:element(2, erlang:element(10, R)),
        erlang:element(2, erlang:element(11, R)),
        erlang:element(2, erlang:element(12, R)),
        erlang:element(2, erlang:element(13, R)),
        erlang:element(2, erlang:element(14, R)),
        erlang:element(2, erlang:element(15, R))}.

-file("src/themis/internal/erlang/ets.gleam", 85).
?DOC(false).
-spec insert(binary(), any(), any()) -> {ok, boolean()} | {error, table_error()}.
insert(Table_name, Key, Value) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            {ok,
                ets:insert(
                    Table_name_atom,
                    begin
                        _pipe = {Key, Value},
                        gleam_stdlib:identity(_pipe)
                    end
                )}
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 107).
?DOC(false).
-spec insert_many(binary(), gleam@dict:dict(any(), any())) -> {ok, boolean()} |
    {error, table_error()}.
insert_many(Table_name, To_insert) ->
    Objects = begin
        _pipe = maps:to_list(To_insert),
        gleam_stdlib:identity(_pipe)
    end,
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) -> _pipe@1 = ets:insert(Table_name_atom, Objects),
            {ok, _pipe@1} end
    ).

-file("src/themis/internal/erlang/ets.gleam", 119).
?DOC(false).
-spec insert_raw(binary(), any()) -> {ok, boolean()} | {error, table_error()}.
insert_raw(Table_name, Object) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) -> _pipe = ets:insert(Table_name_atom, Object),
            {ok, _pipe} end
    ).

-file("src/themis/internal/erlang/ets.gleam", 94).
?DOC(false).
-spec insert_new_raw(binary(), gleam@dynamic:dynamic_()) -> {ok, nil} |
    {error, table_error()}.
insert_new_raw(Table_name, Object) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            R = ets:insert_new(Table_name_atom, Object),
            case gleam@dynamic@decode:run(
                R,
                {decoder, fun gleam@dynamic@decode:decode_bool/1}
            ) of
                {error, E} ->
                    {error, {decode_error, E}};

                {ok, true} ->
                    {ok, nil};

                {ok, false} ->
                    {error, insert_failed}
            end
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 124).
?DOC(false).
-spec lookup(binary(), any()) -> {ok, list(gleam@dynamic:dynamic_())} |
    {error, table_error()}.
lookup(Table_name, Key) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) -> _pipe = ets:lookup(Table_name_atom, Key),
            {ok, _pipe} end
    ).

-file("src/themis/internal/erlang/ets.gleam", 146).
?DOC(false).
-spec counter_increment(binary(), any()) -> {ok, nil} | {error, table_error()}.
counter_increment(Table_name, Key) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            themis_external:counter_increment_by(Table_name_atom, Key, 1),
            _pipe = nil,
            {ok, _pipe}
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 155).
?DOC(false).
-spec match_metric(binary(), any()) -> {ok, list(gleam@dynamic:dynamic_())} |
    {error, table_error()}.
match_metric(Table_name, Kind) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            _pipe = themis_external:match_metric(Table_name_atom, Kind),
            {ok, _pipe}
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 163).
?DOC(false).
-spec match_record(binary(), binary()) -> {ok, list(gleam@dynamic:dynamic_())} |
    {error, table_error()}.
match_record(Table_name, Name) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            _pipe = themis_external:match_record(Table_name_atom, Name),
            {ok, _pipe}
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 129).
?DOC(false).
-spec counter_increment_by(binary(), any(), themis@number:number_()) -> {ok,
        nil} |
    {error, table_error()}.
counter_increment_by(Table_name, Key, By) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) ->
            case By of
                {dec, Val} ->
                    themis_external:counter_increment_by_decimal(
                        Table_name_atom,
                        Key,
                        Val
                    );

                {int, Val@1} ->
                    themis_external:counter_increment_by(
                        Table_name_atom,
                        Key,
                        Val@1
                    );

                na_n ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"can not increment a counter by NaN"/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"themis/internal/erlang/ets"/utf8>>,
                            function => <<"counter_increment_by"/utf8>>,
                            line => 139});

                neg_inf ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"can not increment a counter by -Inf"/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"themis/internal/erlang/ets"/utf8>>,
                            function => <<"counter_increment_by"/utf8>>,
                            line => 140});

                pos_inf ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"can not increment a counter by +Inf"/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"themis/internal/erlang/ets"/utf8>>,
                            function => <<"counter_increment_by"/utf8>>,
                            line => 141})
            end,
            _pipe = nil,
            {ok, _pipe}
        end
    ).

-file("src/themis/internal/erlang/ets.gleam", 171).
?DOC(false).
-spec delete_table(binary()) -> {ok, boolean()} | {error, table_error()}.
delete_table(Table_name) ->
    guard_atom_from_string(
        Table_name,
        fun(Table_name_atom) -> _pipe = ets:delete(Table_name_atom),
            {ok, _pipe} end
    ).