File Coverage

xsi/Parser.xsi

Criterion	Covered	Total	%
statement	77	80	96.2
branch	153	328	46.6
condition			n/a
subroutine			n/a
pod			n/a
total	230	408	56.3

MODULE = Protocol::WebSocket::Fast                PACKAGE = Protocol::WebSocket::Fast::Parser
PROTOTYPES: DISABLE

void Parser::configure (Parser::Config config)

size_t Parser::max_frame_size ()

size_t Parser::max_message_size ()

size_t Parser::max_handshake_size ()

Scalar Parser::deflate_config () {
    auto deflate_cfg = THIS->deflate_config();
    if (deflate_cfg) {
        RETVAL = xs::out(deflate_cfg.value());
    }
    else XSRETURN_UNDEF;
}

Scalar Parser::effective_deflate_config () {
    auto deflate_cfg = THIS->effective_deflate_config();
    if (deflate_cfg) {
        RETVAL = xs::out(deflate_cfg.value());
    }
    else XSRETURN_UNDEF;
}

bool Parser::established ()

bool Parser::recv_closed ()

bool Parser::send_closed ()

bool Parser::is_deflate_active ()

void Parser::get_frames (string buf = string()) {
    auto frames = buf ? THIS->get_frames(buf) : THIS->get_frames();
    if (GIMME_V == G_ARRAY) for (auto frame : frames) mXPUSHs(xs::out(frame).detach());
    else {
        if (frames.begin() == frames.end()) XSRETURN_UNDEF;
        auto itsv = xs::out(new XSFrameIterator(frames.begin()));
        mPUSHs(itsv.detach());
    }
}

void Parser::get_messages (string buf = string()) {
    auto messages = buf ? THIS->get_messages(buf) : THIS->get_messages();
    if (GIMME_V == G_ARRAY) for (auto message : messages) mXPUSHs(xs::out(message).detach());
    else {
        if (messages.begin() == messages.end()) XSRETURN_UNDEF;
        auto itsv = xs::out(new XSMessageIterator(messages.begin()));
        mPUSHs(itsv.detach());
    }
}

XSFrameSender* Parser::start_message (...) {
    Opcode opcode = Opcode::BINARY;
    auto deflate = DeflateFlag::NO;

    for (I32 i = 1; i < items - 1; i += 2) {
        auto name = xs::in(ST(i));
        if (!name.length()) continue;
        auto val = ST(i+1);
        switch (name[0]) {
            case 'd': if (name == "deflate") deflate = SvTRUE(val) ? DeflateFlag::YES : DeflateFlag::NO; break;
            case 'o': if (name == "opcode")  opcode  = (Opcode)SvIV(val); break;
        }
    }

    RETVAL = new XSFrameSender(THIS->start_message(opcode, deflate));
}

Simple Parser::send_control (int opcode, string payload = string()) {
    auto range = THIS->send_control((Opcode)opcode, payload);
    RETVAL = strings_to_sv(range);
}

Simple Parser::send_ping (string payload = string()) {
    auto range = THIS->send_ping(payload);
    RETVAL = strings_to_sv(range);
}

Simple Parser::send_pong (string payload = string()) {
    auto range = THIS->send_pong(payload);
    RETVAL = strings_to_sv(range);
}

Simple Parser::send_close (SV* code = NULL, string message = string()) {
    if (code) {
        auto range = THIS->send_close((uint16_t)SvUV(code), message);
        RETVAL = strings_to_sv(range);
    }
    else RETVAL = xs::out(THIS->send_close());
}

Simple Parser::send_message (...) : ALIAS(send_message_multiframe=1) {
    auto builder = THIS->message();

    Sv payload_sv;
    for (I32 i = 1; i < items - 1; i += 2) {
        auto name = xs::in(ST(i));
        if (!name.length()) continue;
        auto val = ST(i+1);
        switch (name[0]) {
            case 'd': if (name == "deflate" && SvOK(val)) builder.deflate(SvTRUE(val)); break;
            case 'o': if (name == "opcode")  builder.opcode((Opcode)SvIV(val)); break;
            case 'p': if (name == "payload") payload_sv = val; break;
        }
    }

    if (ix == 0) { // send_message()
        if (payload_sv.is_array_ref()) {
            Array payload(payload_sv);
            std::vector list;
            av_to_vstring(payload, list);
            auto range = builder.send(list.begin(), list.end());
            RETVAL = strings_to_sv(range);
        }
        else {
            auto payload = Simple(payload_sv).as_string();
            auto range = builder.send(payload);
            RETVAL = strings_to_sv(range);
        }
    }
    else { // send_message_multiframe()
        Array payloads(payload_sv);
        if (!payloads) throw Error("invalid argument (payload must point to array)");

        std::vector> cont;
        for (const auto& payload : payloads) {
            if (!payload.defined()) continue;
            std::vector tmp;
            tmp.push_back(xs::in(payload));
            cont.push_back(std::move(tmp));
        }

        auto range = builder.send(cont.begin(), cont.end());
        RETVAL = strings_to_sv(range);
    }
}

void Parser::reset ()

uint16_t Parser::suggested_close_code ()

void Parser::no_deflate ()