Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/ncbi__http2__session_8cpp_source.html below:

NCBI C++ ToolKit: src/connect/ncbi_http2_session.cpp Source File

<

TBase>

TBase(std::move(other)),

<

TBase>

: m_Start.~TStart();

;

eData: m_Data.~TH2S_Data();

;

<

TBase>

eData:

;

eEof:

;

:

;

m_UpdateResponse(update_response),

m_ResponseQueue(std::move(response_queue))

(std::move(request));

begin =

*

(

);

(bytes_written) *bytes_written =

;

memcpy(

,

.data(), copied);

(bytes_read) *bytes_read = copied;

(queue_locked->empty()) {

queue_locked.Unlock();

(this->*member)(incoming);

(incoming.

()) {

(incoming.

()) {

NGHTTP2_ERR_DEFERRED;

*data_flags = NGHTTP2_DATA_FLAG_EOF;

& chunk =

.front();

copied =

(length, chunk.size() -

);

memcpy(

, chunk.data() +

, copied);

<

... TNgHttp2Cbs>

std::forward<TNgHttp2Cbs>(callbacks)...,

m_SessionsByQueues(sessions_by_queues)

:

;

& request =

.GetStart();

& url = request.url;

scheme = url.GetScheme();

query_string = url.GetOriginalArgsString();

abs_path_ref = url.GetPath();

(!query_string.empty()) {

abs_path_ref +=

+ query_string;

vector<THeader> nghttp2_headers{{

{

, scheme },

{

, abs_path_ref },

nghttp2_headers.reserve(request.headers.size() + nghttp2_headers.size());

(

& p : request.headers) {

(

& v : p.second) {

nghttp2_headers.emplace_back(p.first, v);

& response_queue =

.response_queue;

.emplace_front(response_queue);

nghttp2_data_provider data_prd;

data_prd.source.ptr = &*it;

it->stream_id =

.

(nghttp2_headers.data(), nghttp2_headers.size(), &data_prd);

(it->stream_id < 0) {

(

<<

<< response_queue <<

<< event);

<

TFunc>

& response_queue =

.response_queue;

it =

(response_queue);

(it->in_progress) {

it->in_progress =

;

(

<<

<< response_queue <<

<< event);

it =

(stream_id);

begin =

*

(

);

it =

(stream_id);

response_queue = it->response_queue;

((frame->hd.type == NGHTTP2_HEADERS) && (frame->headers.cat == NGHTTP2_HCAT_RESPONSE)) {

stream_id = frame->hd.stream_id;

it =

(stream_id);

(

*

(name), namelen);

v(

*

(

), valuelen);

& headers = it->headers;

hit = headers.find(

);

(hit == headers.end()) {

headers.emplace(piecewise_construct, forward_as_tuple(std::move(

)), forward_as_tuple(1, std::move(v)));

hit->second.emplace_back(std::move(v));

& response_queue = stream.response_queue;

is_headers_frame = (frame->hd.type == NGHTTP2_HEADERS) && (frame->headers.cat == NGHTTP2_HCAT_RESPONSE);

is_data_frame = frame->hd.type == NGHTTP2_DATA;

is_eof = frame->hd.flags & NGHTTP2_FLAG_END_STREAM;

(is_headers_frame || (is_data_frame && is_eof)) {

stream_id = frame->hd.stream_id;

it =

(stream_id);

& response_queue = it->response_queue;

(is_headers_frame) {

(response_queue, std::move(it->headers));

session.second.Shutdown();

queue_locked = request_queue.

();

(queue_locked->empty()) {

queue_locked.Unlock();

response_queue = outgoing.response_queue;

(outgoing.

()) {

& request = outgoing.

();

(

new_session =

(request)) {

(new_session->Request(std::move(outgoing))) {

(response_queue <<

<< outgoing);

(session->second.get().Event(outgoing,

)) {

(response_queue <<

<< outgoing);

(session->second.get().Event(outgoing,

)) {

(response_queue <<

<< outgoing);

(

queue = response_queue.lock()) {

queue->GetLock()->emplace(std::move(event));

& url = request.

;

port = url.GetPort();

(scheme ==

) {

}

(scheme ==

) {

https = scheme ==

|| (scheme.empty() && (port ==

));

(

it = range.first; it != range.second; ++it) {

(!it->second.IsFull()) {

m_ApiLock(GetApiLock())

status = headers.

(

);

(status != headers.

()) {

status_code = stoi(status->second.front());

headers.

(status);

response_queue = make_shared<TH2S_ResponseQueue>();

cred(req_cred ? req_cred->GetCert() :

(), req_cred ? req_cred->GetPKey() :

());

unique_ptr<IReaderWriter> rw(

(std::move(update_response), std::move(response_queue), std::move(request)));

bool x_Downgrade(CHttpResponse &resp, CHttpSession_Base::EProtocol &protocol) const override

static void UpdateResponse(CHttpRequest &req, CHttpHeaders::THeaders headers)

shared_ptr< void > TApiLock

Get an API lock.

void x_StartRequest(CHttpSession_Base::EProtocol protocol, CHttpRequest &req, bool use_form_data) override

static TApiLock GetApiLock()

HTTP session class, holding common data for multiple requests.

const_iterator end() const

const_iterator find(const key_type &key) const

const_iterator_pair equal_range(const key_type &key) const

void x_InitConnection2(shared_ptr< iostream > stream)

const THeaders & Get() const

int GetStatusCode(void) const

Get response status code.

void x_InitConnection(bool use_form_data)

void x_UpdateResponse(CHttpHeaders::THeaders headers, int status_code, string status_text)

CRef< CHttpHeaders > m_Headers

shared_ptr< CTlsCertCredentials > m_Credentials

void x_AdjustHeaders(bool use_form_data)

EProtocol

HTTP protocol version.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

ERW_Result

Result codes for I/O operations.

@ eRW_Eof

End of data, should be considered permanent.

@ eRW_Error

Unrecoverable error, no retry possible.

@ eRW_Success

Everything is okay, I/O completed.

const string & GetScheme(void) const

const TYPE & Get(const CNamedParameterList *param)

const GenericPointer< typename T::ValueType > T2 value

constexpr uint32_t kMaxStreams

THeader::SConvert s_GetMethodName(TReqMethod method)

constexpr size_t kReadBufSize

constexpr size_t kWriteBufSize

#define H2S_SESSION_TRACE(message)

#define H2S_IOC_TRACE(message)

SH2S_Event< SH2S_Request > TH2S_RequestEvent

#define H2S_RW_TRACE(message)

@ eError

An error was encountered while trying to send request or to read and to process the reply.

Reader-writer based streams.

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

const char * GetTypeName() const

typename TBase::SStart TStart

SH2S_Event(TStart start, TArgs &&... args)

SH2S_Session * NewSession(const SH2S_Request::SStart &request)

void Process(TH2S_RequestQueue &request_queue)

multimap< SH2S_Session::TAddrNCred, SUvNgHttp2_Session< SH2S_Session > > m_Sessions

TH2S_SessionsByQueues m_SessionsByQueues

TH2S_WeakResponseQueue response_queue

queue< TH2S_Data > pending

ssize_t DataSourceRead(void *session, uint8_t *buf, size_t length, uint32_t *data_flags)

static shared_ptr< SH2S_Io > GetInstance()

TUpdateResponse m_UpdateResponse

ERW_Result Receive(ERW_Result(SH2S_ReaderWriter::*member)(TH2S_ResponseEvent &))

ERW_Result ReadImpl(void *buf, size_t count, size_t *bytes_read)

ERW_Result ReceiveResponse(TH2S_ResponseEvent &incoming)

ERW_Result Write(const void *buf, size_t count, size_t *bytes_written=0) override

Write up to "count" bytes from the buffer pointed to by the "buf" argument onto the output device.

ERW_Result Flush() override

Flush pending data (if any) down to the output device.

ERW_Result PendingCountImpl(size_t *count)

shared_ptr< TH2S_ResponseQueue > m_ResponseQueue

function< void(CHttpHeaders::THeaders)> TUpdateResponse

ERW_Result ReadFsm(function< ERW_Result()> impl)

void Push(TH2S_RequestEvent event)

SH2S_ReaderWriter(TUpdateResponse update_response, shared_ptr< TH2S_ResponseQueue > response_queue, TH2S_RequestEvent request)

ERW_Result ReceiveData(TH2S_ResponseEvent &incoming)

SStart(EReqMethod m, CUrl u, SUvNgHttp2_Tls::TCred c, CHttpHeaders::THeaders h)

SUvNgHttp2_Tls::TCred cred

void OnReset(SUvNgHttp2_Error error) override

static ssize_t s_DataSourceRead(nghttp2_session *, int32_t, uint8_t *buf, size_t length, uint32_t *data_flags, nghttp2_data_source *source, void *user_data)

int OnFrameRecv(nghttp2_session *session, const nghttp2_frame *frame)

TH2S_SessionsByQueues & m_SessionsByQueues

map< TH2S_WeakResponseQueue, TStreams::iterator, owner_less< weak_ptr< TH2S_ResponseQueue > > > m_StreamsByQueues

bool Event(TH2S_RequestEvent &event, TFunc f)

int OnStreamClose(nghttp2_session *session, int32_t stream_id, uint32_t error_code)

unordered_map< int32_t, TStreams::iterator > m_StreamsByIds

SH2S_Session(uv_loop_t *loop, const TAddrNCred &addr_n_cred, bool https, TH2S_SessionsByQueues &sessions_by_queues, TNgHttp2Cbs &&... callbacks)

bool Request(TH2S_RequestEvent request)

int OnData(nghttp2_session *session, uint8_t flags, int32_t stream_id, const uint8_t *data, size_t len)

int OnHeader(nghttp2_session *session, const nghttp2_frame *frame, const uint8_t *name, size_t namelen, const uint8_t *value, size_t valuelen, uint8_t flags)

TStreams::iterator Find(int32_t stream_id)

void Push(TH2S_WeakResponseQueue &response_queue, TH2S_ResponseEvent event)

int32_t Submit(const nghttp2_nv *nva, size_t nvlen, nghttp2_data_provider *data_prd=nullptr)

int Resume(int32_t stream_id)

static const char * NgHttp2Str(T e)

SNgHttp2_Session m_Session

pair< string, string > TCred

static const string & Get()

void Run(uv_run_mode mode=UV_RUN_DEFAULT)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4