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__connection_8c_source.html below:

NCBI C++ ToolKit: src/connect/ncbi_connection.c Source File

const char* ctype = (conn && conn->meta.get_type \

? conn->meta.get_type(conn->meta.c_get_type) \

char* descr = (conn && conn->meta.descr \

? conn->meta.descr(conn->meta.c_descr) \

if ((EIO_Status) status == eIO_Timeout && timeout) { \

assert(timeout != kDefaultTimeout); \

sprintf(stbuf, "%s[%u.%06u]", ststr, \

timeout->usec / 1000000 + timeout->sec, \

timeout->usec % 1000000); \

assert(strlen(stbuf) < sizeof(stbuf)); \

CORE_LOGF_X(subcode, level, \

("[CONN_" #func_name "(%s%s%s)] %s%s%s", \

ctype && *ctype ? ctype : "UNDEF", \

descr && *descr ? "; " : "", descr ? descr : "", \

ststr && *ststr ? ": " : "", \

ststr ? ststr : "")); \

, conn); \

CONN_LOG_EX(0, func_name, eLOG_Trace, x_handle, 0); \

, retval); \

if (conn->magic != CONNECTION_MAGIC) { \

static const STimeout* timeout = 0

, conn); \

CONN_LOG_EX(subcode, func_name, eLOG_Critical, x_errmsg, 0); \

* timeout = 0

;

sprintf(errmsg,

,

(!(func =

->cb[idx].func))

(!

->meta.flush)

timeout =

->meta.default_timeout;

status =

->meta.flush(

->meta.c_flush, timeout);

->w_status = status;

status =

->meta.list

(x_conn =

->meta.list; x_conn; x_conn = x_conn->

) {

(x_conn == connector) {

(!x_conn->

&& x_conn ==

->meta.list)

(

->meta.list) {

(

->meta.close) {

?

->meta.default_timeout

closed =

->meta.close(

->meta.c_close, timeout);

&& (status != eIO_Closed || connector)) {

);

);

memset(&

->meta, 0,

(

->meta));

}

(!connector)

(!x_conn && connector) {

(

->state) {

(

->meta.open) {

?

->meta.default_timeout

status =

->meta.open(

->meta.c_open, timeout);

->magic = (

)(-1);

* timeout = 0

;

!

->meta.list || !

->meta.get_type

? 0 :

->meta.get_type(

->meta.c_get_type);

!

->meta.list || !

->meta.descr

? 0 :

->meta.descr(

->meta.c_descr);

* timeout = 0

;

sprintf(errbuf,

, (

) event);

(&

->oo_timeout != timeout)

->oo_timeout = *timeout;

->o_timeout = &

->oo_timeout;

->o_timeout = timeout;

(&

->rr_timeout != timeout)

->rr_timeout = *timeout;

->r_timeout = &

->rr_timeout;

->r_timeout = timeout;

(&

->ww_timeout != timeout)

->ww_timeout = *timeout;

->w_timeout = &

->ww_timeout;

->w_timeout = timeout;

(&

->cc_timeout != timeout)

->cc_timeout = *timeout;

->c_timeout = &

->cc_timeout;

->c_timeout = timeout;

sprintf(errbuf,

, (

) event);

timeout =

->o_timeout;

, 0);

timeout =

->r_timeout;

timeout =

->w_timeout;

timeout =

->c_timeout;

sprintf(errbuf,

, (

) event);

timeout =

->meta.default_timeout;

status =

->meta.wait

?

->meta.wait(

->meta.c_wait, event, timeout)

* kErrMsg[] = {

,

};

(timeout->

| timeout->

)

(timeout = 0; ; timeout = 0) {

(!(writefunc =

->meta.write)) {

?

->meta.default_timeout

->w_status = status;

->w_pos += *n_written;

(!timeout

|| (timeout->

| timeout->

))

x_written = 0;

- *n_written, &x_written);

*n_written += x_written;

(*n_written ==

)

?

->meta.default_timeout

(timeout = 0; ; timeout = 0) {

(x_read && (*n_read ==

|| !peek)) {

= (

*)

+ x_read;

(!(readfunc =

->meta.read)) {

?

->meta.default_timeout

status = readfunc(

->meta.c_read,

,

- *n_read,

->r_status = status;

->r_pos += x_read;

, 0);

}

(

&& status != eIO_Closed) {

(!timeout

|| (timeout->

| timeout->

))

- *n_read, &x_read, 0

);

(*n_read ==

)

status == eIO_Closed ?

: status;

(!

|| !line)

status == eIO_Closed ?

: status;

,

, x_read = 0;

* x_buf =

-

<

(w) ? w : line +

;

(

< x_read &&

<

) {

c = x_buf[

++];

* timeout = 0

;

, 0);

line[

] =

;

->r_status;

->w_status;

->meta.status

?

->meta.status(

->meta.c_status, dir)

status == eIO_Closed ?

: status;

* timeout = 0

;

sprintf(errbuf,

, (

)

);

(newcb || oldcb) {

->cb[idx] = *newcb;

x_conn =

->meta.list;

|| ((

= strrchr(

,

)) != 0

static CS_CONNECTION * conn

int BUF_Write(BUF *pBuf, const void *data, size_t size)

int BUF_Pushback(BUF *pBuf, const void *data, size_t size)

size_t BUF_Read(BUF buf, void *data, size_t size)

size_t BUF_Peek(BUF buf, void *data, size_t size)

void BUF_Destroy(BUF buf)

unsigned int TCONN_Flags

bitwise OR of ECONN_Flag

EIO_Status CONN_SetFlags(CONN conn, TCONN_Flags flags)

Set connection processing flags.

ECONN_Callback

Set user callback function to be invoked upon an event specified by the callback type.

EIO_Status CONN_SetUserData(CONN conn, void *data)

Associate an arbitraty user data pointer with the connection.

EIO_Status CONN_ReadLine(CONN conn, char *line, size_t size, size_t *n_read)

Read up to "size" bytes from connection into a string buffer pointed to by "line".

EIO_Status CONN_CreateEx(CONNECTOR connector, TCONN_Flags flags, CONN *connection)

Create all data necessary to establish a new connection (merely bind it to the specified CONNECTOR).

EIO_Status CONN_Read(CONN conn, void *buf, size_t size, size_t *n_read, EIO_ReadMethod how)

FConnectorGetType get_type

EIO_Status CONN_Flush(CONN conn)

Explicitly flush connection from any pending data written by CONN_Write().

void * CONN_GetUserData(CONN conn)

Get current value of the user's data pointer last associated with the connection, or NULL (if CONN is...

EIO_Status CONN_SetCallback(CONN conn, ECONN_Callback type, const SCONN_Callback *newcb, SCONN_Callback *oldcb)

unsigned int TCONN_Callback

TNCBI_BigCount CONN_GetPosition(CONN conn, EIO_Event event)

Get read ("event" == eIO_Read) or write ("event" == eIO_Write) position within the connection.

EIO_Status CONN_Write(CONN conn, const void *data, size_t size, size_t *n_written, EIO_WriteMethod how)

CONNECTOR next

linked list

EIO_Status(* FConnectorRead)(CONNECTOR connector, void *buf, size_t size, size_t *n_read, const STimeout *timeout)

Read from connector.

EIO_Status CONN_SetTimeout(CONN conn, EIO_Event event, const STimeout *timeout)

Specify timeout for the connection I/O, including "Connect" (aka "Open") and "Close".

EIO_Status(* FConnectorWrite)(CONNECTOR connector, const void *buf, size_t size, size_t *n_written, const STimeout *timeout)

Write to connector.

char * CONN_Description(CONN conn)

Return a human-readable description of the connection as a character '\0'-terminated string.

EIO_Status CONN_Create(CONNECTOR connector, CONN *conn)

Same as CONN_CreateEx() called with 0 in the "flags" parameter.

EIO_Status CONN_ReInit(CONN conn, CONNECTOR connector)

Reinit using new "connector".

EIO_Status(* FCONN_Callback)(CONN conn, TCONN_Callback type, void *data)

EIO_Status CONN_Wait(CONN conn, EIO_Event event, const STimeout *timeout)

Block on the connection until it becomes available for either reading or writing (depending on "event...

EIO_Status METACONN_Remove(SMetaConnector *meta, CONNECTOR connector)

Delete given "connector" all its descendants (all connectors if "connector" is NULL) from the connect...

EIO_Status METACONN_Insert(SMetaConnector *meta, CONNECTOR connector)

Insert a connector at the beginning of the connection's list of connectors.

void * handle

data handle of the connector

SMetaConnector * meta

back link to original meta

const char * CONN_GetType(CONN conn)

Get verbal representation of connection type as a character string.

EIO_Status CONN_Close(CONN conn)

Close the connection and destroy all relevant internal data.

EIO_Status CONN_GetSOCK(CONN conn, SOCK *sock)

Get an underlying SOCK handle for connection that is implemented as a socket.

const STimeout * CONN_GetTimeout(CONN conn, EIO_Event event)

Retrieve current timeout, return NULL(kInfiniteTimeout) if it is infinite.

TCONN_Flags CONN_GetFlags(CONN conn)

Get connection processing flags currently in effect.

EIO_Status CONN_Status(CONN conn, EIO_Event dir)

Obtain status of the last I/O operation.

EIO_Status CONN_Pushback(CONN conn, const void *data, size_t size)

Push "size" bytes from the buffer "data" back into connection.

@ eCONN_OnFlush

About to be flushed (NB: == eIO_ReadWrite)

@ eCONN_OnWrite

Write to CONNECTOR is about to occur.

@ eCONN_OnTimeout

CONNECTOR I/O has timed out.

@ eCONN_OnClose

NB: CONN has been flushed prior to the call.

@ eCONN_OnRead

Read from CONNECTOR is about to occur.

@ eCONN_OnOpen

Call prior to open (NB: "conn" still closed)

@ fCONN_Untie

do not call flush method prior to reading

@ fCONN_Supplement

supplement I/O with extended return codes

void Read(CObjectIStream &in, TObjectPtr object, const CTypeRef &type)

void Write(CObjectOStream &out, TConstObjectPtr object, const CTypeRef &type)

ELOG_Level

Log severity level.

unsigned int usec

microseconds (modulo 1,000,000)

EIO_ReadMethod

I/O read method.

EIO_WriteMethod

I/O write method.

EIO_Event

I/O event (or direction).

uint64_t TNCBI_BigCount

Big unsigned integer for file size and position.

@ eIO_Timeout

timeout expired before any I/O succeeded

@ eIO_Interrupt

signal arrival prevented any I/O to succeed

@ eIO_NotSupported

operation is not supported or is not available

@ eIO_Success

everything is fine, no error occurred

@ eIO_Reserved

reserved status code – DO NOT USE!

@ eIO_Unknown

unknown I/O error (likely fatal but can retry)

@ eIO_InvalidArg

bad argument / parameter value(s) supplied

@ eIO_ReadPlain

read readily available data only, wait if none

@ eIO_ReadPeek

do eIO_ReadPlain but leave data in input queue

@ eIO_ReadPersist

read exactly as much as requested, w/waits

@ eIO_WritePlain

write as much as possible, report back how much

@ eIO_WritePersist

write exactly as much as specified, w/waits

@ eIO_ReadWrite

eIO_Read | eIO_Write (also, eCONN_OnFlush)

@ eIO_Open

also serves as no-event indicator in SOCK_Poll

@ eIO_Close

also serves as an error indicator in SOCK_Poll

unsigned int

A callback function used to compare two keys in a database.

if(yy_accept[yy_current_state])

const struct ncbi::grid::netcache::search::fields::SIZE size

int strcmp(const char *str1, const char *str2)

#define CONN_NOT_NULL(s_c, f_n)

static EIO_Status s_CONN_Read(CONN conn, void *buf, const size_t size, size_t *n_read, int peek)

static EIO_Status s_Open(CONN conn)

static EIO_Status s_CONN_WritePersist(CONN conn, const void *data, const size_t size, size_t *n_written)

static size_t x_CB2IDX(ECONN_Callback type)

static EIO_Status s_CONN_Write(CONN conn, const void *data, const size_t size, size_t *n_written)

#define CONN_LOG(s_c, f_n, lvl, msg)

static EIO_Status s_CONN_ReadPersist(CONN conn, void *buf, const size_t size, size_t *n_read)

static EIO_Status x_CatchallCallback(CONN conn, TCONN_Callback type, void *data)

#define CONN_LOG_EX(subcode, func_name, level, message, status)

#define CONN_NOT_NULL_EX(subcode, func_name, retval)

#define CONN_CALLTRACE(func_name)

#define CONN_TRACE(f_n, msg)

static EIO_Status x_Callback(CONN conn, ECONN_Callback type, unsigned int flag)

static EIO_Status x_Flush(CONN conn, const STimeout *timeout, int isflush)

static EIO_Status x_ReInit(CONN conn, CONNECTOR connector, int close)

struct SConnectionTag SConnection

static size_t x_size(const char *dst, size_t len, const char *ptr)

const char g_kNcbiSockNameAbbr[]

string ReadLine(CNcbiIstream &in)

const STimeout * c_timeout

SCONN_Callback cb[CONN_N_CALLBACKS+1]

const STimeout * o_timeout

const STimeout * w_timeout

const STimeout * r_timeout

voidp calloc(uInt items, uInt size)

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