File: stream.rbs

package info (click to toggle)
ruby-http-2 1.1.1-1
  • links: PTS, VCS
  • area: main
  • in suites: forky
  • size: 13,360 kB
  • sloc: ruby: 6,031; makefile: 4
file content (94 lines) | stat: -rw-r--r-- 2,277 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
module HTTP2
  class Stream
    include FlowBuffer
    include Emitter

    STREAM_OPEN_STATES: Array[Symbol]

    attr_reader id: Integer
    attr_reader state: Symbol
    attr_reader parent: Stream?
    attr_reader weight: Integer
    attr_reader dependency: Integer
    attr_reader remote_window: Integer
    attr_reader local_window: Integer
    attr_reader closed: Symbol?

    @connection: Connection
    @local_window_max_size: Integer
    @error: bool
    @_method: String?
    @_content_length: Integer?
    @_status_code: Integer?
    @_waiting_on_trailers: bool
    @_trailers: Array[String]?
    @received_data: bool
    @activated: bool

    alias window local_window

    def closed?: () -> bool

    def receive: (frame frame) -> void

    alias << receive

    def verify_trailers: (headers_frame frame) -> void

    def calculate_content_length: (Integer?) -> void

    def send: (frame frame) -> void

    def headers: (Enumerable[header_pair] headers, ?end_headers: bool, ?end_stream: bool) -> void

    def promise: (Enumerable[header_pair] headers, ?end_headers: bool) { (Stream) -> void } -> void

    def reprioritize: (?weight: Integer, ?dependency: Integer, ?exclusive: bool) -> void

    def data: (String payload, ?end_stream: bool) -> void

    def chunk_data: (String payload, Integer max_size) { (String) -> void } -> String

    def close: (Symbol error) -> void
             | () -> void

    def cancel: () -> void

    def refuse: () -> void

    def window_update: (Integer increment) -> void

    private

    def initialize: (
      connection: Connection,
      id: Integer,
      ?weight: Integer,
      ?dependency: Integer,
      ?exclusive: bool,
      ?parent: Stream?,
      ?state: Symbol
    ) -> untyped

    def transition: (frame, bool sending) -> void

    def event: (Symbol newstate) -> void

    def activate_stream_in_conn: () -> void

    def close_stream_in_conn: (*untyped) -> void

    def complete_transition: (frame) -> void

    def process_priority: (priority_frame frame) -> void

    def end_stream?: (frame frame) -> boolish

    def stream_error: (Symbol error, ?msg: String?) -> void
                    | () -> void

    alias error stream_error

    def manage_state: (frame) { () -> void } -> void
  end
end