Module gpb

Data Types

field()

field() = 
    #field{name = atom() | undefined,
           fnum = integer() | undefined,
           rnum = pos_integer() | undefined,
           type =
               gpb_field_type() |
               gpb_internal_intermediary_ref() |
               gpb_internal_intermediary_map_ref() |
               undefined,
           occurrence =
               required | optional | repeated | undefined,
           opts = [term()]} |
    #gpb_oneof{name = atom() | undefined,
               rnum = pos_integer() | undefined,
               fields =
                   [#field{name = atom() | undefined,
                           fnum = integer() | undefined,
                           rnum = pos_integer() | undefined,
                           type =
                               gpb_field_type() |
                               gpb_internal_intermediary_ref() |
                               gpb_internal_intermediary_map_ref() |
                               undefined,
                           occurrence =
                               required |
                               optional |
                               repeated |
                               undefined,
                           opts = [term()]}] |
                   undefined}

gpb_field_type()

gpb_field_type() = 
    int32 |
    int64 |
    uint32 |
    uint64 |
    sint32 |
    sint64 |
    fixed32 |
    fixed64 |
    sfixed32 |
    sfixed64 |
    bool |
    float |
    double |
    string |
    bytes |
    {enum, atom()} |
    {msg, atom()} |
    {group, atom()} |
    {map, gpb_map_key(), gpb_map_value()}

gpb_internal_intermediary_map_ref()

gpb_internal_intermediary_map_ref() = 
    {map,
     gpb_map_key(),
     gpb_map_value() | gpb_internal_intermediary_ref()}

gpb_internal_intermediary_ref()

gpb_internal_intermediary_ref() = 
    {ref, term()} |
    {msg, list()} |
    {group, list()} |
    {enum, list()}

gpb_map_key()

gpb_map_key() = 
    int32 |
    int64 |
    uint32 |
    uint64 |
    sint32 |
    sint64 |
    fixed32 |
    fixed64 |
    sfixed32 |
    sfixed64 |
    bool |
    string

gpb_map_value()

gpb_map_value() = gpb_scalar() | {enum, atom()} | {msg, atom()}

gpb_scalar()

gpb_scalar() = 
    int32 |
    int64 |
    uint32 |
    uint64 |
    sint32 |
    sint64 |
    fixed32 |
    fixed64 |
    sfixed32 |
    sfixed64 |
    bool |
    float |
    double |
    string |
    bytes

proplist_def()

proplist_def() = 
    {{msg, Name :: atom()}, [proplist_field()]} | term()

proplist_defs()

proplist_defs() = [proplist_def()]

proplist_field()

proplist_field() = 
    [proplist_field_item()] | [proplist_oneof_item()]

proplist_field_item()

proplist_field_item() = 
    {name, atom()} |
    {fnum, integer()} |
    {rnum, pos_integer()} |
    {type, gpb_field_type()} |
    {occurrence, required | optional | repeated} |
    {opts, [term()]}

proplist_oneof_item()

proplist_oneof_item() = 
    {name, atom()} |
    {rnum, pos_integer()} |
    {field, [proplist_field_item()]}

proplist_rpc()

proplist_rpc() = [proplist_rpc_item()]

proplist_rpc_item()

proplist_rpc_item() = 
    {name, atom()} |
    {input, [field()]} |
    {output, [field()]} |
    {input_stream, boolean()} |
    {output_stream, boolean()} |
    {opts, [term()]}

Function Index

check_scalar/2
decode_msg/3
decode_varint/1
decode_varint/2
decode_wiretype/1
defs_records_to_proplists/1
encode_msg/2
encode_varint/1
encode_wiretype/1
field_record_to_proplist/1
field_records_to_proplists/1
is_allowed_as_key_type/1
is_msg_proto3/2
is_type_packable/1
map_item_pseudo_fields/2
merge_msgs/3
proplist_to_field_record/1
proplists_to_defs_records/1
proplists_to_field_records/1
proplists_to_rpc_records/1
proto2_type_default/2
proto3_type_default/2
rpc_record_to_proplist/1
rpc_records_to_proplists/1
verify_msg/2
version_as_list/0
version_as_string/0

Function Details

check_scalar/2

check_scalar(Value :: any(), Type :: gpb_scalar()) ->
                ok | {error, Reason :: term()}

decode_msg/3

decode_msg(Bin :: binary(),
           MsgName :: atom(),
           MsgDefs :: gpb_parse:defs()) ->
              tuple()

decode_varint/1

decode_varint(Bin :: binary()) -> {non_neg_integer(), binary()}

decode_varint/2

decode_varint(Bin :: binary(), MaxNumBits :: pos_integer()) ->
                 {non_neg_integer(), binary()}

decode_wiretype/1

decode_wiretype(X1 :: non_neg_integer()) ->
                   varint |
                   bits32 |
                   bits64 |
                   group_start |
                   group_end |
                   length_delimited

defs_records_to_proplists/1

defs_records_to_proplists(Defs :: gpb_parse:defs()) ->
                             proplist_defs()

encode_msg/2

encode_msg(Msg :: tuple(), MsgDefs :: gpb_parse:defs()) ->
              binary()

encode_varint/1

encode_varint(N :: integer()) -> binary()

encode_wiretype/1

encode_wiretype(X1 :: gpb_field_type()) -> non_neg_integer()

field_record_to_proplist/1

field_record_to_proplist(Field ::
                             #field{name = atom() | undefined,
                                    fnum = integer() | undefined,
                                    rnum =
                                        pos_integer() | undefined,
                                    type =
                                        gpb_field_type() |
                                        gpb_internal_intermediary_ref() |
                                        gpb_internal_intermediary_map_ref() |
                                        undefined,
                                    occurrence =
                                        required |
                                        optional |
                                        repeated |
                                        undefined,
                                    opts = [term()]}) ->
                            [proplist_field_item()]

field_records_to_proplists/1

field_records_to_proplists(Fields :: [field()]) ->
                              [proplist_field()]

is_allowed_as_key_type/1

is_allowed_as_key_type(X1 :: gpb_field_type()) -> boolean()

is_msg_proto3/2

is_msg_proto3(Name :: atom(), MsgDefs :: gpb_parse:defs()) ->
                 boolean()

is_type_packable/1

is_type_packable(X1 :: gpb_field_type()) -> boolean()

map_item_pseudo_fields/2

map_item_pseudo_fields(KeyType :: gpb_map_key(),
                       ValueType :: gpb_map_value()) ->
                          [field()]

merge_msgs/3

merge_msgs(PrevMsg :: tuple(),
           NewMsg :: tuple(),
           MsgDefs :: gpb_parse:defs()) ->
              tuple()

proplist_to_field_record/1

proplist_to_field_record(PL :: [proplist_field_item()]) ->
                            #field{name = atom() | undefined,
                                   fnum = integer() | undefined,
                                   rnum =
                                       pos_integer() | undefined,
                                   type =
                                       gpb_field_type() |
                                       gpb_internal_intermediary_ref() |
                                       gpb_internal_intermediary_map_ref() |
                                       undefined,
                                   occurrence =
                                       required |
                                       optional |
                                       repeated |
                                       undefined,
                                   opts = [term()]}

proplists_to_defs_records/1

proplists_to_defs_records(Defs :: proplist_defs()) ->
                             gpb_parse:defs()

proplists_to_field_records/1

proplists_to_field_records(PLs :: [proplist_field()]) -> [field()]

proplists_to_rpc_records/1

proplists_to_rpc_records(PLs :: [proplist_rpc()]) ->
                            [#rpc{name = atom() | undefined,
                                  input = any(),
                                  output = any(),
                                  input_stream =
                                      boolean() | undefined,
                                  output_stream =
                                      boolean() | undefined,
                                  opts = [term()] | undefined}]

proto2_type_default/2

proto2_type_default(Type :: gpb_field_type(),
                    MsgDefs :: gpb_parse:defs()) ->
                       term()

proto3_type_default/2

proto3_type_default(Type :: gpb_field_type(),
                    MsgDefs :: gpb_parse:defs()) ->
                       term()

rpc_record_to_proplist/1

rpc_record_to_proplist(Rpc ::
                           #rpc{name = atom() | undefined,
                                input = any(),
                                output = any(),
                                input_stream =
                                    boolean() | undefined,
                                output_stream =
                                    boolean() | undefined,
                                opts = [term()] | undefined}) ->
                          proplist_rpc()

rpc_records_to_proplists/1

rpc_records_to_proplists(Rpcs ::
                             [#rpc{name = atom() | undefined,
                                   input = any(),
                                   output = any(),
                                   input_stream =
                                       boolean() | undefined,
                                   output_stream =
                                       boolean() | undefined,
                                   opts = [term()] | undefined}]) ->
                            [proplist_rpc()]

verify_msg/2

verify_msg(Msg :: tuple() | term(), MsgDefs :: gpb_parse:defs()) ->
              ok

version_as_list/0

version_as_list() -> [integer() | string()]

version_as_string/0

version_as_string() -> string()


Generated by EDoc