Module rabbit_types

Data Types

amqp_error()

amqp_error() = #amqp_error{name = rabbit_framing:amqp_exception(), explanation = string(), method = rabbit_framing:amqp_method_name()}

auth_user()

auth_user() = #auth_user{username = username(), tags = [atom()], impl = any()}

authz_context()

authz_context() = map()

authz_data()

authz_data() = #{peeraddr := inet:ip_address() | binary(), term() => term()} | undefined

basic_message()

basic_message() = #basic_message{exchange_name = exchange_name(), routing_keys = [routing_key()], content = content(), id = msg_id(), is_persistent = boolean()}

binding()

binding() = #binding{source = exchange_name(), destination = binding_destination(), key = binding_key(), args = rabbit_framing:amqp_table()}

binding_destination()

binding_destination() = rabbit_amqqueue_name() | exchange_name()

binding_key()

binding_key() = binary()

binding_source()

binding_source() = exchange_name()

channel()

channel() = pid()

channel_exit()

channel_exit() = no_return()

channel_name()

channel_name() = binary()

channel_number()

channel_number() = non_neg_integer()

connection()

connection() = pid()

connection_exit()

connection_exit() = no_return()

connection_name()

connection_name() = binary()

content()

content() = undecoded_content() | decoded_content()

ctag()

ctag() = binary()

decoded_content()

decoded_content() = #content{class_id = rabbit_framing:amqp_class_id(), properties = rabbit_framing:amqp_property_record(), properties_bin = maybe(binary()), payload_fragments_rev = [binary()]}

delivery()

delivery() = #delivery{mandatory = boolean(), sender = pid(), message = message()}

encoded_content()

encoded_content() = #content{class_id = rabbit_framing:amqp_class_id(), properties = maybe(rabbit_framing:amqp_property_record()), properties_bin = binary(), payload_fragments_rev = [binary()]}

error()

error(A, B) = {error, A, B}

error()

error(A) = {error, A}

exchange()

exchange() = #exchange{name = exchange_name(), type = exchange_type(), durable = boolean(), auto_delete = boolean(), arguments = rabbit_framing:amqp_table()}

exchange_name()

exchange_name() = r(exchange)

exchange_type()

exchange_type() = atom()

guid()

guid() = binary()

info()

info() = {info_key(), any()}

info_key()

info_key() = atom()

info_keys()

info_keys() = [info_key()]

infos()

infos() = [info()]

listener()

listener() = #listener{node = node(), protocol = atom(), host = rabbit_net:hostname(), port = rabbit_net:ip_port()}

maybe()

maybe(T) = T | none

message()

message() = basic_message()

message_properties()

message_properties() = #message_properties{expiry = pos_integer() | undefined, needs_confirming = boolean()}

mfargs()

mfargs() = {atom(), atom(), [any()]}

msg_id()

msg_id() = guid()

node_type()

node_type() = disc | ram

ok()

ok(A) = {ok, A}

ok_or_error()

ok_or_error(A) = ok | error(A)

ok_or_error2()

ok_or_error2(A, B) = ok(A) | error(B)

ok_pid_or_error()

ok_pid_or_error() = ok_or_error2(pid(), any())

password()

password() = binary()

password_hash()

password_hash() = binary()

permission_atom()

permission_atom() = configure | write | read

proc_name()

proc_name() = term()

proc_type_and_name()

proc_type_and_name() = {atom(), proc_name()}

protocol()

protocol() = rabbit_framing:protocol()

protocol_name()

protocol_name() = amqp0_8 | amqp0_9_1 | amqp1_0 | mqtt | stomp | any()

r()

r(Kind) = r2(vhost(), Kind)

r2()

r2(VirtualHost, Kind) = r3(VirtualHost, Kind, rabbit_misc:resource_name())

r3()

r3(VirtualHost, Kind, Name) = #resource{virtual_host = VirtualHost, kind = Kind, name = Name}

rabbit_amqqueue_name()

rabbit_amqqueue_name() = rabbit_types:r(queue)

routing_key()

routing_key() = binary()

timestamp()

timestamp() = {non_neg_integer(), non_neg_integer(), non_neg_integer()}

topic_access_context()

topic_access_context() = #{routing_key => routing_key(), variable_map => map(), term() => term()}

tracked_channel()

tracked_channel() = #tracked_channel{id = tracked_channel_id(), node = node(), vhost = vhost(), name = channel_name(), pid = channel(), username = username(), connection = connection()}

tracked_channel_id()

tracked_channel_id() = {node(), channel_name()}

tracked_connection()

tracked_connection() = #tracked_connection{id = tracked_connection_id(), node = node(), vhost = vhost(), name = connection_name(), pid = connection(), protocol = protocol_name(), peer_host = rabbit_net:hostname(), peer_port = rabbit_net:ip_port(), username = username(), connected_at = integer()}

tracked_connection_id()

tracked_connection_id() = {node(), connection_name()}

undecoded_content()

undecoded_content() = #content{class_id = rabbit_framing:amqp_class_id(), properties = none, properties_bin = binary(), payload_fragments_rev = [binary()]} | #content{class_id = rabbit_framing:amqp_class_id(), properties = rabbit_framing:amqp_property_record(), properties_bin = none, payload_fragments_rev = [binary()]}

unencoded_content()

unencoded_content() = undecoded_content()

user()

user() = #user{username = username(), tags = [atom()], authz_backends = [{atom(), any()}]}

username()

username() = binary()

vhost()

vhost() = binary()


Generated by EDoc