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

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

NCBI C++ ToolKit: src/app/pubseq_gateway/client/processing.hpp Source File

(

pipe =

,

server =

) :

<

TItem,

... TArgs>

<

TItem>

<

TItem,

... TArgs>

(shared_ptr<CPSG_BlobData> blob_data);

(shared_ptr<CPSG_BlobInfo> blob_info);

(shared_ptr<CPSG_SkippedBlob> skipped_blob);

(shared_ptr<CPSG_BioseqInfo> bioseq_info);

(shared_ptr<CPSG_NamedAnnotInfo> named_annot_info);

(shared_ptr<CPSG_NamedAnnotStatus> named_annot_status);

(shared_ptr<CPSG_PublicComment> public_comment);

(shared_ptr<CPSG_Processor> processor);

(shared_ptr<CPSG_IpgInfo> ipg_info);

(shared_ptr<CPSG_AccVerHistory> acc_ver_history);

<

TReplyItem>

(

* name, shared_ptr<TReplyItem>& reply_item)

(

blob_id = reply_item->template GetId<CPSG_BlobId> ())

(name, *blob_id);

(

chunk_id = reply_item->template GetId<CPSG_ChunkId>())

(name, *chunk_id);

<

T>

<

T>

<

T>

<

T>

(

& obj,

* name,

optional<T>& v) {

(v)

(obj[name], *v); }

(TNode node,

&& v) {

(node.SetValue(), std::forward<T>(v)); }

(

node,

vector<CPSG_BioId>& bio_ids);

(std::move(s), rf, std::move(ua)),

(std::move(s), rf, std::move(ua)),

(

s, CPSG_Request::TFlags rf,

ua,

,

wt,

p,

srv,

dl,

ps,

e,

os,

) :

(std::move(s), rf, std::move(ua)),

<

TParams>

(

TParams& params);

(

TParams& params);

<

TMethod,

... TArgs>

(TMethod method, TArgs&&... args) :

(method, std::forward<TArgs>(args)...) {}

<

TParams>

(istream* schema_is,

single_doc);

<

TCreateContext>

vector<shared_ptr<CPSG_Request>>

(TCreateContext create_context,

report_progress_after = 0);

(

& line, istream& is = cin,

single_doc =

);

<

TParams>

chrono;

wait = params.rate > 0 ? 1s / params.rate : 0s;

parallel_processing(std::move(line));

this_thread::sleep_for(wait);

(++

>= params.rate) {

now = system_clock::now();

wait -= (now - start) /

- 1s / params.rate;

<

TRequest,

TInput,

... TArgs>

shared_ptr<TRequest> Build(

TInput&

, TArgs&&... args);

<

TInput,

... TArgs>

shared_ptr<CPSG_Request> Build(

& name,

TInput&

, TArgs&&... args);

initializer_list<SDataFlag>& GetDataFlags();

initializer_list<SInfoFlag>& GetInfoFlags();

<

TInput>

<

TInput>

<

TRequest>

vector<string> GetNamedAnnots()

;

ForEachTSE(

exclude)

;

()

{

.has(

) ?

[

].GetValue().GetInt8() : 0; }

()

{

.has(

) ? objects::CSeq_id::GetSNPScaleLimit_Value(

[

].GetValue().GetString()) : CPSG_Request_NamedAnnotInfo::ESNPScaleLimit::eSNPScaleLimit_Default; }

SetRequestFlags(shared_ptr<CPSG_Request> request)

;

<

TRequest>

user_context(std::move(uc)),

request_context(std::move(rc))

<

... TArgs>

make_shared<TRequest>(std::forward<TArgs>(args)..., std::move(user_context), std::move(request_context));

<

TReader>

shared_ptr<TRequest>

(

TReader& reader);

<

TReader>

IncludeData(shared_ptr<TRequest> request,

specified);

[&](

& name) {

.has(

) && (name ==

[

].GetValue().GetString());

[&](

& name) {

(!reader.

.

(

))

;

include_info = reader.

[

].

();

find_if(include_info.begin(), include_info.end(), equals_to) != include_info.end();

<

TInput>

{ reader.GetBioIdType(), TImpl::GetIncludeInfo(TImpl::GetSpecified(reader)), reader.GetAccSubstitution(), reader.GetBioIdResolution() };

<

TRequest,

TInput,

... TArgs>

reader.SetRequestFlags(rv);

rv->SetUserArgs(reader.GetUserArgs());

<

TInput,

... TArgs>

(name ==

) {

Build<CPSG_Request_Biodata>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_Blob>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_Resolve>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_NamedAnnotInfo>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_Chunk>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_IpgResolve>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CPSG_Request_AccVerHistory>(

, std::forward<TArgs>(args)...);

}

(name ==

) {

Build<CRawRequest>(

, std::forward<TArgs>(args)...);

<

TReader>

bio_id = reader.GetBioId();

bio_id_resolution = reader.GetBioIdResolution();

request = Create(std::move(bio_id), bio_id_resolution);

specified = GetSpecified(reader);

IncludeData(request, specified);

exclude = [&](

blob_id) { request->ExcludeTSE(blob_id); };

reader.ForEachTSE(exclude);

request->SetAccSubstitution(reader.GetAccSubstitution());

resend_timeout = reader.GetResendTimeout();

(!resend_timeout.IsDefault()) {

request->SetResendTimeout(resend_timeout);

<

TReader>

bio_id = reader.GetBioId();

bio_id_resolution = reader.GetBioIdResolution();

request = Create(std::move(bio_id), bio_id_resolution);

specified = GetSpecified(reader);

include_info = GetIncludeInfo(specified);

request->IncludeInfo(include_info);

request->SetAccSubstitution(reader.GetAccSubstitution());

<

TReader>

blob_id = reader.GetBlobId();

request = Create(std::move(blob_id));

specified = GetSpecified(reader);

IncludeData(request, specified);

<

TReader>

bio_ids = reader.GetBioIds();

named_annots = reader.GetNamedAnnots();

bio_id_resolution = reader.GetBioIdResolution();

request = Create(std::move(bio_ids), std::move(named_annots), bio_id_resolution);

specified = GetSpecified(reader);

IncludeData(request, specified);

request->SetAccSubstitution(reader.GetAccSubstitution());

request->SetSNPScaleLimit(reader.GetSNPScaleLimit());

<

TReader>

chunk_id = reader.GetChunkId();

Create(std::move(chunk_id));

<

TReader>

protein = reader.GetProtein();

ipg = reader.GetIpg();

nucleotide = reader.GetNucleotide();

Create(std::move(protein), ipg, std::move(nucleotide));

<

TReader>

bio_id = reader.GetBioId();

Create(std::move(bio_id));

<

TReader>

<

TRequest>

(

&

: GetDataFlags()) {

(specified(

.name)) {

request->IncludeData(

.value);

(acc_substitution ==

) {

}

(acc_substitution ==

) {

void AddMessage(const SPSG_Message &message)

static void SetDataLimit(size_t value)

static void Set(CJson_Object &obj, const char *name, T &&v)

static bool sm_SetReplyType

static auto sm_PreviewSize

void Set(const char *name, shared_ptr< TReplyItem > &reply_item)

static void Set(CJson_Object &obj, const char *name, const CNullable< T > &v)

static void Set(CJson_Value value, Int4 v)

void Set(const char *name, T &&v)

static void Set(CJson_Value value, bool v)

static CJsonResponse NewItem(const shared_ptr< CPSG_ReplyItem > &reply_item)

void AddRequestID(TItem, EDoNotAddRequestID)

static void Set(CJson_Value value, const string &v)

static void SetReplyType(bool value)

void AddMessage(EDoNotAddRequestID=eDoNotAddRequestID)

static void Set(CJson_Value value, double v)

static void Set(CJson_Value value, Uint4 v)

void Fill(EPSG_Status status, shared_ptr< CPSG_Reply >)

static void Set(CJson_Object &obj, const char *name, const optional< T > &v)

static void Set(CJson_Value value, const char *v)

static void SetPreviewSize(size_t value)

static void Set(TNode node, T &&v)

static void Set(CJson_Value value, Uint8 v)

static void Set(CJson_Value value, Int8 v)

void AddRequestID(TItem item, TArgs &&... args)

CJson_ConstArray GetArray(void) const

Get JSON array contents of the node.

CJson_ConstValue GetValue(void) const

Get JSON value contents of the node.

bool has(const CJson_Node::TKeyType &name) const

Test if an element with this name exists in the object.

TStringType GetString(void) const

CJson_Object SetObject(void)

Get JSON object contents of the node.

Template class allowing to store a value or null (unassigned) state.

Bio-id (such as accession)

static shared_ptr< CPSG_Request > CreateRawRequest(string abs_path_ref, shared_ptr< void > user_context, CRef< CRequestContext > request_context)

A queue to retrieve data (accession resolution info; bio-sequence; annotation blobs) from the storage...

EIncludeData

Specify which info and data is needed.

CNullable< string > TNucleotide

EIncludeInfo

Specify which info and data is needed Some processors may provide more than the flags prescribe Alway...

Request to the PSG server (see "CPSG_Request_*" below)

CParallelProcessing(const TParams &params)

void operator()(string line)

list< SThread > m_Threads

list< CPSG_EventLoop > m_PsgQueues

static bool ReadLine(string &line, istream &is=cin, bool single_doc=false)

static vector< shared_ptr< CPSG_Request > > ReadCommands(TCreateContext create_context, size_t report_progress_after=0)

static int OneRequest(const SOneRequestParams &params, shared_ptr< CPSG_Request > request)

static int ParallelProcessing(const TParams &params, istream &is=cin)

static CParallelProcessing< SBatchResolveParams > CreateParallelProcessing(const SBatchResolveParams &params)

static CJson_Document RequestSchema()

static int Performance(const SPerformanceParams &params)

static int JsonCheck(istream *schema_is, bool single_doc)

CTimeout – Timeout interval.

static SQLCHAR output[256]

bool IsNull(void) const

Check if the object is unassigned.

const TValue & GetValue(void) const

Get a const reference to the current value.

EDiagSev

Severity level for the posted diagnostics.

ESerialDataFormat

Data file format.

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

@ eDefault

Default timeout (to be interpreted by the client code)

E_Choice

Choice variants.

unsigned int TJson_Write_Flags

@ fJson_Write_NoIndentation

do not use indentation

@ fJson_Write_IndentWithSpace

use space (' ') symbol for indentation

@ fJson_Write_NoEol

do not write end-of-line symbol

chrono::system_clock::time_point time_point

const GenericPointer< typename T::ValueType > T2 value

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

double df(double x_, const double &y_)

EPSG_AccSubstitution

Whether and how to substitute version-less primary seq-ids with the "more unique" secondary seq-ids.

@ Never

No substitution whatsoever - return exact raw accession info.

@ Default

Substitute always (default)

@ Limited

Substitute only if the resolved record's seq_id_type is GI(12)

EPSG_Status

Retrieval result.

vector< CPSG_BioId > CPSG_BioIds

EPSG_BioIdResolution

Whether to try to resolve provided seq-ids before use.

@ Resolve

Try to resolve provided seq-ids.

@ NoResolve

Use provided seq-ids as is.

SImpl(const TParams &params)

void(*)(SJsonOut &, EPSG_Status, const shared_ptr< CPSG_ReplyItem > &) TItemComplete

void(*)(SJsonOut &, EPSG_Status, const shared_ptr< CPSG_Reply > &) TReplyComplete

void Init(const TParams &params)

TReplyComplete GetReplyComplete()

TItemComplete GetItemComplete()

void Process(string line)

void Submitter(CPSG_Queue &output)

CPSG_WaitingQueue< string > m_InputQueue

void(*)(SJsonOut &, const shared_ptr< CPSG_ReplyItem > &) TNewItem

SThread(TMethod method, TArgs &&... args)

SBatchResolveParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua, double r, int wt, bool p, bool srv, SResolveParams resolve_params)

CPSG_Request_Biodata::EIncludeData value

CPSG_Request_Resolve::EIncludeInfo value

SInteractiveParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua, double r, int wt, bool p, bool srv, size_t dl, size_t ps, bool e, bool os, bool t)

const size_t preview_size

static string GetService(string service, bool one_server)

const TJson_Write_Flags m_Flags

SJsonOut(bool pipe=false, bool server=false)

SJsonOut & operator<<(const CJson_Document &doc)

const ESerialDataFormat output_format

const CLogLatencies::EWhich which

SOneRequestParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua, CLogLatencies::EWhich lw, bool ld, bool de, bool dm, ESerialDataFormat df)

Arbitrary request URL arguments.

SParallelProcessingParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua, double r, int wt, bool p, bool srv)

const SPSG_UserArgs user_args

SParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua)

static EDiagSev min_severity

const CPSG_Request::TFlags request_flags

SPerformanceParams(string s, CPSG_Request::TFlags rf, SPSG_UserArgs ua, size_t ut, double d, bool lq, bool ri)

const size_t user_threads

const bool report_immediately

shared_ptr< void > user_context

SImpl(shared_ptr< void > uc={}, CRef< CRequestContext > rc={})

shared_ptr< TRequest > Build(const TReader &reader)

static void IncludeData(shared_ptr< TRequest > request, TSpecified specified)

CRef< CRequestContext > request_context

static CPSG_Request_Resolve::TIncludeInfo GetIncludeInfo(TSpecified specified)

auto Create(TArgs &&... args)

static TSpecified GetSpecified(const TReader &reader)

EPSG_BioIdResolution GetBioIdResolution() const

auto GetSNPScaleLimit() const

auto GetNucleotide() const

auto GetAbsPathRef() const

CTimeout GetResendTimeout() const

const CJson_ConstObject & input

SPSG_UserArgs GetUserArgs() const

auto GetAccSubstitution() const

SReader(const CJson_ConstObject &i)

CPSG_BioId GetBioId() const

function< void(string)> TExclude

static shared_ptr< TRequest > Build(const TInput &input, TArgs &&... args)

static EPSG_AccSubstitution GetAccSubstitution(const string &acc_substitution)

static SResolveParams GetResolveParams(const TInput &input)

function< bool(const string &)> TSpecified

const EPSG_BioIdResolution bio_id_resolution

const CPSG_Request_Resolve::TIncludeInfo include_info

const CPSG_BioId::TType type

const EPSG_AccSubstitution acc_substitution

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