File Coverage

src/xs/protocol/websocket.h
Criterion Covered Total %
statement 4 4 100.0
branch 1 2 50.0
condition n/a
subroutine n/a
pod n/a
total 5 6 83.3


line stmt bran cond sub pod time code
1             #pragma once
2             #include
3             #include
4             #include
5              
6             namespace xs { namespace protocol { namespace websocket {
7              
8             using namespace panda::protocol::websocket;
9              
10             struct XSFrameIterator : FrameIterator {
11             XSFrameIterator (Parser* parser, const FrameSP& start_frame) : FrameIterator(parser, start_frame), nexted(false) { parser->retain(); }
12             XSFrameIterator (const XSFrameIterator& oth) : FrameIterator(oth), nexted(oth.nexted) { parser->retain(); }
13             XSFrameIterator (const FrameIterator& oth) : FrameIterator(oth), nexted(false) { parser->retain(); }
14              
15             FrameSP next () {
16             if (nexted) operator++();
17             else nexted = true;
18             return cur;
19             }
20              
21             ~XSFrameIterator () { parser->release(); }
22             private:
23             bool nexted;
24             };
25              
26             struct XSMessageIterator : MessageIterator {
27             XSMessageIterator (Parser* parser, const MessageSP& start_msg) : MessageIterator(parser, start_msg), nexted(false) { parser->retain(); }
28             XSMessageIterator (const XSMessageIterator& oth) : MessageIterator(oth), nexted(oth.nexted) { parser->retain(); }
29             XSMessageIterator (const MessageIterator& oth) : MessageIterator(oth), nexted(false) { parser->retain(); }
30              
31             MessageSP next () {
32             if (nexted) operator++();
33             else nexted = true;
34             return cur;
35             }
36              
37             ~XSMessageIterator () { parser->release(); }
38             private:
39             bool nexted;
40             };
41              
42             struct XSFrameSender : FrameSender {
43             XSFrameSender (FrameSender&& fb): FrameSender(std::move(fb)) {
44             // keep link to make XSFrameSender perl-safe
45             _parser.retain();
46             }
47             ~XSFrameSender () { _parser.release(); }
48             };
49              
50             void av_to_header_values (const Array& av, HeaderValues* vals);
51             Array header_values_to_av (const HeaderValues& vals);
52              
53             void av_to_vstring (const Array& av, std::vector& v);
54              
55             ConnectRequestSP make_request (const Hash& params, const ConnectRequestSP& = {});
56             ConnectResponseSP make_response (const Hash& params, const ConnectResponseSP& = {});
57              
58             void parser_config_in (Parser::Config&, const Hash&);
59             void deflate_config_in (DeflateExt::Config&, const Hash&);
60             Sv deflate_config_out (const DeflateExt::Config&);
61              
62             }}}
63              
64             namespace xs {
65              
66             template
67             struct Typemap : TypemapObject {};
68              
69             template
70             struct Typemap : Typemap {
71             static std::string package () { return "Protocol::WebSocket::Fast::ClientParser"; }
72             };
73              
74             template
75             struct Typemap : Typemap {
76             static std::string package () { return "Protocol::WebSocket::Fast::ServerParser"; }
77             };
78              
79             template
80             struct Typemap : Typemap {
81             static std::string package () { return "Protocol::WebSocket::Fast::ConnectRequest"; }
82             };
83              
84             template
85             struct Typemap> : Typemap {
86             using Super = Typemap;
87             static panda::iptr in (Sv arg) {
88             if (!arg.is_object_ref()) arg = Super::default_stash().call("new", arg);
89             return Super::in(arg);
90             }
91             };
92              
93             template
94             struct Typemap : Typemap {
95             static std::string package () { return "Protocol::WebSocket::Fast::ConnectResponse"; }
96             };
97              
98             template
99             struct Typemap> : Typemap {
100             using Super = Typemap;
101             static panda::iptr in (Sv arg) {
102             if (!arg.is_object_ref()) arg = Super::default_stash().call("new", arg);
103             return Super::in(arg);
104             }
105             };
106              
107             template
108             struct Typemap : TypemapObject {
109             static std::string package () { return "Protocol::WebSocket::Fast::Frame"; }
110             };
111              
112             template
113             struct Typemap : TypemapObject {
114             static std::string package () { return "Protocol::WebSocket::Fast::Message"; }
115             };
116              
117             template
118             struct Typemap : TypemapObject {
119             static std::string package () { return "Protocol::WebSocket::Fast::FrameIterator"; }
120             };
121              
122             template
123             struct Typemap : TypemapObject {
124             static std::string package () { return "Protocol::WebSocket::Fast::MessageIterator"; }
125             };
126              
127             template
128             struct Typemap : TypemapObject {
129             static std::string package () { return "Protocol::WebSocket::Fast::FrameSender"; }
130             };
131              
132             template struct Typemap : TypemapBase {
133 23           static TYPE in (SV* arg) {
134 23           TYPE cfg;
135 23 50         xs::protocol::websocket::deflate_config_in(cfg, arg);
136 23           return cfg;
137             }
138              
139             static Sv out (TYPE var, const Sv& = Sv()) { return xs::protocol::websocket::deflate_config_out(var); }
140             };
141              
142             template struct Typemap : TypemapBase {
143             static TYPE in (SV* arg) {
144             TYPE cfg;
145             xs::protocol::websocket::parser_config_in(cfg, arg);
146             return cfg;
147             }
148             };
149             }