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

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

NCBI C++ ToolKit: src/sra/readers/sra/wgsread.cpp Source File

v =

(WGS, USE_AMBIGUITY_MASK)::GetDefault();

v =

(WGS, USE_AMBIGUITY_4NA)::GetDefault();

v =

(WGS, USE_FULL_4NA_BLOCKS)::GetDefault();

SProfiler() : name(0),

(0) {}

cout << name<<

<<

<<

<<

.

()<<endl;

SProfilerGuard

SProfilerGuard(SProfiler&

,

* name)

SProfiler sw_Serialize;

SProfiler sw_Feat;

SProfiler sw_GetAccSeq_id;

SProfiler sw_GetBioseq;

SProfiler sw_GetSeq_entry;

SProfiler sw_GetSeq_entryData;

SProfiler sw_GetSplitInfo;

SProfiler sw_GetSplitInfoData;

SProfiler sw_InitSplit;

SProfiler sw_GetFeatLocIdTypeRange;

SProfiler sw_GetFeatLocIdTypeFeat;

SProfiler sw_GetFeatLocIdTypeFeatBytes;

SProfiler sw_GetFeatBytes;

SProfiler sw_GetChunk;

SProfiler sw_CreateQualityChunk;

SProfiler sw_CreateDataChunk;

SProfiler sw_CreateProductsChunk;

SProfiler sw_CreateFeaturesChunk;

SProfiler sw__GetProtFeat;

SProfiler sw___GetProtAnnot;

SProfiler sw___GetProtInst;

SProfiler sw___GetProtDescr;

SProfiler sw____GetProtWGSAcc;

SProfiler sw____GetProtAccVer;

SProfiler sw____GetProtAcc;

SProfiler sw____GetProtGI;

SProfiler sw____GetProtGISeq_id;

SProfiler sw____GetProtGnlSeq_id;

SProfiler sw____GetProtAccSeq_id;

SProfiler sw___GetProtIds;

SProfiler sw__GetProtBioseq;

SProfiler sw_GetProtEntry;

SProfiler sw__GetScaffoldFeat;

SProfiler sw___GetScaffoldQual;

SProfiler sw___GetScaffoldAnnot;

SProfiler sw___GetScaffoldInst;

SProfiler sw___GetScaffoldDescr;

SProfiler sw___GetScaffoldIds;

SProfiler sw__GetScaffoldBioseq;

SProfiler sw_GetScaffoldEntry;

SProfiler sw__GetContigFeat;

SProfiler sw___GetContigQual;

SProfiler sw____GetContigQualSize;

SProfiler sw____GetContigQualData;

SProfiler sw____GetContigQualMinMax;

SProfiler sw___GetContigAnnot;

SProfiler sw____IsGap;

SProfiler sw____Get2naLen;

SProfiler sw____Get4naLen;

SProfiler sw____GetGapLen;

SProfiler sw____GetRaw2na;

SProfiler sw____GetRaw4na;

SProfiler sw____GetAmb2Mask;

SProfiler sw____Get4na2Mask;

SProfiler sw____Scan4na;

SProfiler sw____GetCvt4na;

SProfiler sw____GetAmb4na;

SProfiler sw____GetBlk4na;

SProfiler sw____SetGaps;

SProfiler sw___GetContigInst;

SProfiler sw___GetContigDescr;

SProfiler sw___GetContigIds;

SProfiler sw__GetContigBioseq;

SProfiler sw_GetContigEntry;

SProfiler sw_FeatIterator;

SProfiler sw_ProtIterator;

SProfiler sw_ScafIterator;

SProfiler sw_SeqIterator;

SProfiler sw_WGSOpen;

dst.assign(

.begin()+2,

.end()-2);

dst.assign(

.begin(),

.end());

.Write(

.m_Bytes.data(),

.m_Bytes.size());

m_READ_2na(m_Cursor,

,

(

() && m_GAP_START && m_GAP_LEN && m_AMBIGUITY_POS && m_AMBIGUITY_4NA ) {

m_AMBIGUITY_POS.Reset();

m_AMBIGUITY_4NA.Reset();

m_QUALITY.ResetIfAlwaysEmpty(

);

.FindVariant(

)

.FindMember(

)

.FindMember(

)

.FindMember(

)

byte_index = block_index/8;

byte_bit = 1<<(block_index%8);

byte_index = block_index/8;

byte_bit = 1<<(block_index%8);

(S4naReader& reader)

;

<

Value>

dst.resize(src.

());

copy_n(src.

(), src.

(), dst.data());

: m_Prefix(db.GetIdPrefixWithVersion()),

m_HasGapInfo(

),

m_HasAmbiguityMask(

),

m_HasAmbiguityPos(

),

m_Has4naBlocks(

)

( cur.m_GAP_START ) {

( cur.m_GAP_LINKAGE ) {

kVerify4na =

;

vector<Uint1> m_ExpectedAmbiguityMask;

vector<INSDC_coord_zero> m_ExpectedAmbiguityPos;

vector<INSDC_4na_bin> m_ExpectedAmbiguity4na;

( cur.m_AMBIGUITY_MASK ) {

( cur.m_AMBIGUITY_POS && cur.m_AMBIGUITY_4NA ) {

mask_bit_count = 0;

(

block_index = 0;

byte_index = block_index/8;

byte_bit = 1<<(block_index%8);

exp_bit = byte_index < m_ExpectedAmbiguityMask.size() &&

(m_ExpectedAmbiguityMask[byte_index] & byte_bit);

( bit != exp_bit ) {

<<block_index<<

<<oct<<block_index<<dec<<

<<bit<<

<<exp_bit);

index = 0, exp_index = 0;

( index <

.size() || exp_index < m_ExpectedAmbiguityPos.size() ) {

exp_pos = exp_index < m_ExpectedAmbiguityPos.size()? m_ExpectedAmbiguityPos[exp_index]:

;

exp_base = exp_index < m_ExpectedAmbiguityPos.size()? m_ExpectedAmbiguity4na[exp_index]: 0;

( pos == exp_pos ) {

( base != exp_base ) {

<<pos<<

<<oct<<pos<<dec<<

<<base<<

<<exp_base);

( pos < exp_pos ) {

<<pos<<

<<oct<<pos<<dec<<

<<base<<

);

<<exp_pos<<

<<oct<<exp_pos<<dec<<

<<exp_base);

memory = GetUsedMemory();

(

<<m_Prefix<<

<<m_RowId<<

kAllocateGap =

(

*)*2;

ret = kAllocateGap +

(*this);

ret += kAllocateGap + m_GapStart.size()*

(m_GapStart.front());

ret += kAllocateGap + m_GapLen.size()*

(m_GapLen.front());

ret += kAllocateGap + m_GapProps.size()*

(m_GapProps.front());

ret += kAllocateGap + m_GapLinkage.size()*

(m_GapLinkage.front());

ret += kAllocateGap + m_AmbiguityMask.size()*

(m_AmbiguityMask.front());

( m_HasAmbiguityPos || m_Has4naBlocks ) {

ret += kAllocateGap + m_AmbiguityPos.size()*

(m_AmbiguityPos.front());

ret += kAllocateGap + m_Ambiguity4na.size()*

(m_Ambiguity4na.front());

kBlockUsedMemory =

kAllocateGap + 4*

(

*) +

(

);

ret += kBlockUsedMemory * m_4naBlocks.size();

gap_info.

= m_GapLen.data();

&& !(

&(

-1));

( ; ptr != end; ++ptr ) {

+base_count;

( gap_info.

(pos) ) {

[16] = {

0x11, 0x12, 0x14, 0x18,

0x21, 0x22, 0x24, 0x28,

0x41, 0x42, 0x44, 0x48,

0x81, 0x82, 0x84, 0x88

[bits_2na & 0xf];

( base_count >= 4 ) {

bits_2na = src_2na[0];

bits_2na = src_2na[0] & (0xff00 >> base_count*2);

( base_count < 2 ) {

dst_4na[0] = bits_4na;

( base_count > 2 ) {

vector<char>& src_2na_vec,

dst_4na_byte_count = (base_count+1)/2;

dst_4na_vec.reserve((dst_4na_byte_count+7)/8*8);

dst_4na_vec.resize(dst_4na_byte_count);

& dst = dst_4na_vec[

/2];

dst = (dst & 0xf) | (amb << 4);

dst = (dst & 0xf0) | amb;

* dst = dst_4na_vec.data()+ (

/2);

(

>= 2 ) {

* src_4na,

src_offset,

( !base_count ) {

dst_4na += dst_offset/2;

src_4na += src_offset/2;

( dst_offset != 0 ) {

dst_b = dst_4na[0];

src_b = src_4na[0];

src_4na += src_offset;

( !src_offset ) {

dst_b = (dst_b & 0xf0) | (src_b & 0xf);

( src_offset == 0 ) {

copy_bytes = base_count / 2;

dst_4na = copy_n(src_4na, copy_bytes, dst_4na);

src_4na += copy_bytes;

( base_count >= 2 ) {

src_b0 = src_4na[0];

src_b1 = src_4na[1];

dst_b = (src_b0 << 4) | (src_b1 >> 4);

dst_b = dst_4na[0];

src_b = src_4na[0];

dst_b = (dst_b & 0xf) | (src_b & 0xf0);

* src_4na,

( base_count >= 2 ) {

b0 = src_4na[0];

b1 = src_4na[1];

packed_bb = (b0 << 4)+b1;

*dst_packed_4na = packed_bb;

b0 = src_4na[0];

packed_bb = (b0 << 4);

*dst_packed_4na = packed_bb;

vector<INSDC_coord_zero>& amb_pos,

vector<INSDC_4na_bin>& amb_4na)

iter_pos = lower_bound(amb_pos.begin(), amb_pos.end(),

(pos));

iter_4na = amb_4na.begin() + (iter_pos-amb_pos.begin());

( ; iter_pos != amb_pos.end() && *iter_pos < end; ++iter_pos, ++iter_4na ) {

(dst_4na_vec, *iter_pos-pos, *iter_4na);

(

iter =

.lower_bound(block_pos);

iter !=

.end() && iter->first < end;

block_pos = iter->first;

( block_pos < pos ) {

src_offset = pos-block_pos;

dst_offset = block_pos-pos;

(dst_4na_vec.data(), dst_offset, iter->second.m_Packed4na, src_offset, copy_len);

( ;

> 0; ) {

( gap_info.

(pos) ) {

ambiguous =

;

( gap_info.

(pos) ) {

m_AmbiguityPos.push_back(pos+

);

m_Ambiguity4na.push_back(

);

( m_HasAmbiguityMask ) {

( m_HasAmbiguityPos ) {

(

ambiguity_count = m_AmbiguityPos.size() ) {

last_byte_index = last_block_index/8;

m_AmbiguityMask.resize(last_byte_index+1);

(

= 0;

< ambiguity_count; ++

) {

memory = GetUsedMemory();

mask_bit_count = 0;

(

: m_AmbiguityMask ) {

(

<<m_Prefix<<

<<m_RowId<<

<<

cur4na = db.

(m_RowId);

read4na = cur4na->READ(m_RowId);

mask_bit_count = 0;

m_AmbiguityMask.resize((block_count+7)/8);

(

block_index = 0; block_index < block_count; ++block_index ) {

* base_ptr = read4na.

() + block_pos;

ambiguous =

;

( use_full_4na_blocks ) {

ambiguous = x_AddAmbiguousBlock(base_ptr, base_count, block_pos, gap_info);

ambiguous = x_AddAmbiguities(base_ptr, base_count, block_pos, gap_info);

x_SetAmbiguousBlock(block_index);

( use_full_4na_blocks ) {

m_Has4naBlocks =

;

m_HasAmbiguityPos =

;

memory = GetUsedMemory();

(

<<m_Prefix<<

<<m_RowId<<

m_HasAmbiguityMask =

;

( m_HasAmbiguityPos || m_Has4naBlocks ) {

bit_count = 0;

wrong_bit_count = 0;

(

block_byte = 0; block_byte < m_AmbiguityMask.size(); ++block_byte ) {

(

bits = m_AmbiguityMask[block_byte] ) {

cur4na = db.

(m_RowId);

read4na = cur4na->READ(m_RowId);

(

block_bit = 0; block_bit < 8; ++block_bit ) {

( bits & (1<<block_bit) ) {

block_index = block_byte*8+block_bit;

* base_ptr = read4na.

() + block_pos;

ambiguous =

;

gap_info.

(block_pos);

( use_full_4na_blocks ) {

ambiguous = x_AddAmbiguousBlock(base_ptr, base_count, block_pos, gap_info);

ambiguous = x_AddAmbiguities(base_ptr, base_count, block_pos, gap_info);

(

<<m_Prefix<<

<<m_RowId<<

<<

<<block_pos);

( use_full_4na_blocks ) {

m_Has4naBlocks =

;

m_HasAmbiguityPos =

;

memory = GetUsedMemory();

(

<<m_Prefix<<

<<m_RowId<<

<<

(

= 0;

< 2 &&

< m_AmbiguityPos.size(); ++

) {

(

<<m_Prefix<<

<<m_RowId<<

<<

<<m_AmbiguityPos[

]<<

<<m_Ambiguity4na[

]*1);

( m_HasAmbiguityPos ) {

reader.

= pos;

( m_HasAmbiguityPos ) {

lower_bound(m_AmbiguityPos.begin(), m_AmbiguityPos.end(),

(pos)) - m_AmbiguityPos.begin();

( m_HasAmbiguityPos ) {

base == 0xf? eBase_Gap:

(base)? eBase_2na: eBase_4na;

( m_HasAmbiguityPos ) {

( m_HasAmbiguityPos ) {

iter = lower_bound(m_AmbiguityPos.begin(), m_AmbiguityPos.end(),

(pos));

( iter == m_AmbiguityPos.end() ||

(*iter) >= end ) {

(

block_iter = m_4naBlocks.lower_bound(block_pos);

block_iter != m_4naBlocks.end() && block_iter->first < end;

in_block_pos = pos <= block_iter->first? 0: pos-block_iter->first;

in_block_pos, in_block_len));

( amb_pos < in_block_pos+in_block_len ) {

(block_iter->first+amb_pos) - pos;

(

< stop_2na_len ) {

reader = Get4naReader(pos, db, cur);

rem_len =

, len2na = 0, gap_len = 0;

( ; rem_len; --rem_len, Advance(reader) ) {

base_type = GetBaseType(reader);

( base_type == eBase_2na ) {

( len2na == stop_2na_len-1 ) {

-(rem_len+len2na);

( gap_len == stop_gap_len-1 ) {

-(rem_len+gap_len);

(len2na < stop_2na_len);

reader = Get4naReader(pos, db, cur);

( ; rem_len; --rem_len, Advance(reader) ) {

base_type = GetBaseType(reader);

( base_type != eBase_Gap ) {

-rem_len;

bytes = (

+3)/4;

.reserve((bytes+7)/8*8);

.resize(bytes);

seq_2na = Get2na(pos,

, cur);

( m_HasAmbiguityPos ) {

( pos != end ) {

( x_AmbiguousBlock(block_index) ) {

( pos != end ) {

( !x_AmbiguousBlock(block_index) ) {

used_memory =

->GetUsedMemory();

( !seq->m_Cursor.TryOpenRow(1) ) {

( m_IdRowDigits < 6 || m_IdRowDigits > 8 ) {

<<acc);

has_static_taxid = seq->m_TAXID && seq->m_TAXID.IsStatic(seq->m_Cursor);

( has_static_taxid ) {

= seq->TAXID(1);

(

.size() != 1 ) {

has_static_taxid =

;

static_taxid =

[0];

= node.GetSize();

( node.GetSize() != 0 ) {

( !test_path.empty() ) {

( !vol_path.

() ) {

vector<CTempString> dirs;

( vector<CTempString>, it, dirs ) {

path_or_acc.

(

) == string::npos ) {

acc = path_or_acc.

(start);

acclen = acc.

();

digit_pos = acc.find_first_of(

);

(digit_pos == string::npos && (acclen == 4 || acclen == 6)) {

(path_or_acc) +

;

}

((digit_pos == 4 || digit_pos == 6) &&

acclen > digit_pos + 2) {

path_or_acc.

(0, start+digit_pos+2);

atomic<bool>& table_is_opened,

( !table_is_opened.load(memory_order_acquire) ) {

table_is_opened.store(

, memory_order_release);

atomic<Int1>& index_is_opened,

* index_name,

* backup_index_name)

( !index_is_opened.load(memory_order_acquire) ) {

( backup_index_name ) {

index_is_opened.store(

, memory_order_release);

index_is_opened.store(-1, memory_order_release);

,

);

,

);

,

);

,

);

pair<TVDBRowId, CWGSDb_Impl::ERowType>

TAllowRowType allow_type)

(prefix_len ==

|| prefix_len >= acc.

() - 2)

prefix_len += 2;

(

[0] ==

) {

(

[0] ==

) {

( ret.first < 0 ) {

( is_scaffold ) {

pair<TVDBRowId, TRowType> rt =

(acc, allow_type);

( is_scaffold ) {

(

* text_id =

.GetTextseq_Id() ) {

(

* text_id =

.GetTextseq_Id() ) {

*

(text_id)->SetAccession(accession);

kSetErrno = 0;

kSetNcbiError = 0;

= 0, ret = -1;

=

.size();

v =

.data()[0] -

;

(

= 1;

<

; ++

) {

d =

.data()[

] -

;

nv = v * 10 + d;

kOverflowLimit = (INT_MAX - 9) / 10 + 1;

( v >= kOverflowLimit ) {

( v > kOverflowLimit || nv > INT_MAX) {

ret =

(v);

(kSetNcbiError &&

) {

(

.size() == 1 ||

.data()[0] !=

) {

( !bytes.

() ) {

(

& desc :

.Set() ) {

descr.

().push_back(desc);

(

.HaveMoreData() ) {

descr.

().push_back(desc);

( !bytes.

() ) {

(

.HaveMoreData() ) {

annot_set.push_back(annot);

split_id.

(

.GetGi());

split_id.

(

.GetGi());

split_ids.push_back(split_id);

loc_gi.

(

.GetGi());

( prefix.

() ) {

& dbtag =

->SetGeneral();

dbtag.

(prefix);

TGnlIdFlags gnl_id_flags)

& dbtag =

->SetGeneral();

( colon !=

) {

dbtag.

(

.substr(0, colon));

=

.substr(colon+1);

[db.size()] ==

) {

=

.substr(db.size()+1);

TGnlIdFlags gnl_id_flags)

(

.empty() ) {

(

.empty() ) {

( cur.m_SEQID_GNL_PREFIX ) {

(

.empty() ) {

( cur.m_SEQID_GNL_PREFIX ) {

(

.empty() ) {

( cur.m_SEQID_GNL_PREFIX ) {

( !acc.

() ) {

master_acc.resize(master_acc.size() + 2 +

,

);

=

(master_acc);

>> *master_entry;

( id->IsPatent() ) {

( master_entry->IsSetDescr() ) {

( desc.

() ) {

eDescr_force;

eDescr_default;

( name ==

||

name ==

||

name ==

||

name ==

||

name ==

) {

eDescr_default;

(uo_type ==

) {

((*it)->GetLabel().IsStr() &&

(*it)->GetLabel().GetStr() ==

) {

= ((*it)->GetData().IsStr() ?

(

) (*it)->GetData().GetStr() :

uo_type +=

+

;

(!uo_type.empty() && existing_uo_types.count(uo_type) == 0) {

existing_uo_types.

(uo_type);

type_mask = 0;

type_mask |= 1 << desc.

();

(

& desc : main_seq->

().

()) {

type_mask |= 1 << desc->Which();

(type_mask & (1 << desc.

())) ) {

(!uo_type.empty() && existing_uo_types.count(uo_type) == 0)

descr.

().push_back(*it);

& user_object = desc->

();

user_object.SetData();

descr.

().push_back(desc);

.

();

method<<

<<gi);

( idx->m_NUC_ROW_ID ) {

idx->m_NUC_ROW_ID.GetRowIdRange(idx->m_Cursor);

( row_range.second ) {

ret.first =

(row_range.first,

);

ret.second =

(row_range.first + row_range.second - 1,

);

( idx->m_PROT_ROW_ID ) {

idx->m_PROT_ROW_ID.GetRowIdRange(idx->m_Cursor);

( row_range.second ) {

ret.first =

(row_range.first,

);

ret.second =

(row_range.first + row_range.second - 1,

);

( ranges.empty() ) {

(ranges.begin(), ranges.end());

TGiRanges::iterator dst = ranges.begin();

( TGiRanges::iterator

= dst+1;

!= ranges.end(); ++

) {

(

->GetFrom() == dst->GetToOpen() ) {

dst->SetToOpen(

->GetToOpen());

ranges.erase(dst+1, ranges.end());

gi_start = -1, gi_end = -1;

row_range = seq->m_GI.GetRowIdRange(seq->m_Cursor);

row_id = row_range.first+

;

( gi != gi_end ) {

( gi_end != gi_start ) {

ranges.push_back(

(gi_start, gi_end));

( gi_end != gi_start ) {

ranges.push_back(

(gi_start, gi_end));

( prefix < acc.

() &&

(acc[prefix]&0xff) ) {

( prefix == acc.

() || prefix == 0 || acc.

()-prefix > 9 ) {

( c < '0' || c >

) {

v = v*10 + (c-

);

acc = m_AccPrefix;

acc.resize(m_IdLength,

);

(

= m_IdLength; id;

/= 10 ) {

acc[--

] +=

% 10;

row_range = seq->m_GB_ACCESSION.GetRowIdRange(seq->m_Cursor);

row_id = row_range.first+

;

( acc.

() ) {

( it == ranges.

() || it->first !=

) {

( id < it->second.GetFrom() ) {

it->second.SetFrom(

);

(

>= it->second.GetToOpen() ) {

it->second.SetTo(

);

pair<TVDBRowId, bool> ret;

( idx->m_NUC_ROW_ID ) {

( !

.empty() ) {

ret.first = *

;

( !ret.first && idx->m_PROT_ROW_ID ) {

( !

.empty() ) {

ret.first = *

;

( idx->m_NUC_ROW_ID ) {

( !

.empty() ) {

( idx->m_PROT_ROW_ID ) {

( !

.empty() ) {

range.second? range.first: 0;

range.second? range.first: 0;

( seq->m_CONTIG_NAME_ROW_RANGE ) {

seq->m_Cursor.SetParam(

, name);

( !

.empty() ) {

* query_param_name;

(

(idx->m_ROW_ID.GetName(),

) ) {

query_param_name =

;

query_param_name =

;

( !

.empty() ) {

( range.first && range.first <= range.second ) {

( !prot_rows.

() ) {

( ask_version > 0 ) {

version_index = size_t(prot_rows.

() == 1? 0: ask_version-1);

( version_index < prot_rows.

() ) {

prot_row_id = prot_rows[version_index];

( prot_row_id ) {

actual_version = *

->ACC_VERSION(prot_row_id);

( actual_version != ask_version ) {

( ask_version == -1 ) {

prot_row_id = prot_rows[prot_rows.

()-1];

can_have_gis =

;

gi_range = cur->m_Cursor.GetRowIdRange(cur->m_GI.GetIndex());

( gi_range.second ) {

can_have_gis =

;

can_have_gis;

(

cur =

() ) {

feature_count = cur->m_Cursor.GetRowIdRange().second;

feature_count;

(sw_GetFeatLocIdTypeRange);

row_range = seq->m_Cursor.GetRowIdRange(seq->m_FEAT_ROW_START.GetIndex());

seq_row_id = row_range.first+

;

row_start = seq->FEAT_ROW_START(seq_row_id);

( !row_start.empty() ) {

feat_row_id = *row_start;

( exception&

) {

(sw_GetFeatLocIdTypeFeat);

(sw_GetFeatLocIdTypeFeatBytes);

bytes = *cur->SEQ_FEAT(feat_row_id);

cur.GetNCObject().m_ObjStr.OpenFromBuffer(bytes.

(), bytes.

());

cur.GetNCObject().m_ObjStr >> *feat;

(

*

= !seq_id? 0: seq_id->GetTextseq_Id() ) {

( id->IsSetVersion() ) {

( exception&

) {

( *

&& GetToOpen() <= pos ) {

split_prod(

),

split_data(

),

split_feat(

),

split_qual(

),

x_SetFlags(

);

x_SetSplitVersion(split_version);

x_SetFlags(TFlags

);

<

Iter>

main_id = it.GetId(

);

( feat_id->

() ) {

<

Iter>

vector<TVDBRowId>& product_row_ids);

vector<TVDBRowId>& product_row_ids);

vector<TVDBRowId>& product_row_ids);

x_AddProducts(

vector<TVDBRowId>& product_row_ids);

= GetGBState();

( !(m_IncludeFlags & TIncludeFlags(1 <<

)) ) {

GetDb().Put(m_Cur0, m_CurrId);

GetDb().Put(m_Cur, m_CurrId);

m_CurrId = m_FirstGoodId = m_FirstBadId = 0;

m_AccVersion = eLatest;

: m_AccVersion(eLatest)

(

!= &iter ) {

m_AccVersion(eLatest),

m_IncludeFlags(fIncludeDefault),

m_ClipByQuality(

)

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type);

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type,

);

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type, first_row, last_row);

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type, acc);

TIncludeFlags include_flags,

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type);

TIncludeFlags include_flags,

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type,

);

TIncludeFlags include_flags,

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type, first_row, last_row);

TIncludeFlags include_flags,

: m_AccVersion(eLatest)

(wgs_db, include_flags, clip_type, acc);

: m_AccVersion(eLatest)

: m_AccVersion(eLatest)

: m_AccVersion(eLatest)

: m_AccVersion(eLatest)

TIncludeFlags include_flags,

(wgs_db, include_flags, clip_type, 0);

TIncludeFlags include_flags,

(wgs_db, include_flags, clip_type,

);

TIncludeFlags include_flags,

(wgs_db, include_flags, clip_type, first_row);

TIncludeFlags include_flags,

(wgs_db, include_flags, clip_type,

);

TIncludeFlags include_flags,

( clip_type ) {

<<method<<

);

(

);

(

);

<= latest_version &&

<<

<<

oldest_version<<

<<latest_version);

(

->m_GI ) {

(

().HasCommonTaxId() ) {

->m_HASH;

<<

<<

<<

ids.push_back(

);

ids.push_back(

);

ids.push_back(

);

(

->m_DESCR ) {

(

);

(

);

(

->m_NUC_PROT_DESCR ) {

( !

().GetMasterDescr().

() ) {

( ret->

().empty() ) {

(

);

( !

->m_FEAT_ROW_START ) {

( start_val.

() ) {

( end < start ) {

<<start<<

<<end);

(

);

->m_QUALITY;

(sw____GetContigQualSize);

quality_vec.clear();

quality_vec.reserve((

+7)/8*8);

quality_vec.resize(

);

quality_vec.data());

;

min_v0 = 0xff, max_v0 = 0;

min_v1 = 0xff, max_v1 = 0;

min_v2 = 0xff, max_v2 = 0;

min_v3 = 0xff, max_v3 = 0;

( v0 < min_v0 ) min_v0 = v0;

( v1 < min_v1 ) min_v1 = v1;

(

< min_v2 ) min_v2 =

;

( v3 < min_v3 ) min_v3 = v3;

( v0 > max_v0 ) max_v0 = v0;

( v1 > max_v1 ) max_v1 = v1;

(

> max_v2 ) max_v2 =

;

( v3 > max_v3 ) max_v3 = v3;

( v0 < min_v0 ) min_v0 = v0;

( v0 > max_v0 ) max_v0 = v0;

min_v0 =

(min_v0, min_v2);

max_v0 =

(max_v0, max_v2);

min_v1 =

(min_v1, min_v3);

max_v1 =

(max_v1, max_v3);

min_v =

(min_v0, min_v1);

max_v =

(max_v0, max_v1);

TFlags

)

.x_SetId(*

);

(sw____GetContigQualData);

values.reserve((

+7)/8*8);

values.resize(

);

min_q = 0, max_q = 0;

(sw____GetContigQualMinMax);

annot->

().Set().push_back(name);

graph->

(

);

annot->

().SetGraph().push_back(graph);

annot_set.push_back(annot);

(

->m_GB_STATE ) {

( !

->m_PUBLIC_COMMENT ) {

( !

->m_PUBLIC_COMMENT ) {

->m_GAP_START;

evidence->SetType(

);

kLenTypeMask =

kGapTypeMask =

len_type = -(-props & kLenTypeMask);

gap_type = -(-props & kGapTypeMask);

( gap_type || gap_linkage ) {

( gap_type ) {

( ; bit && bit <= gap_linkage; bit<<=1, ++

) {

( gap_linkage & bit ) {

segments.push_back(seg);

TInstSegmentFlags

)

( ;

> 0; ) {

( gap_info.

(pos) ) {

(segments, pos - raw_offset, gap_len, gap_info);

rem_len =

(rem_len, chunk_end - pos);

seg_len = ambiguity->Get2naLengthBlock(pos, rem_len);

( seg_len == rem_len ) {

seg_len = ambiguity->Get2naLengthBlock(pos,

(rem_len,

));

( seg_len >=

|| seg_len == rem_len ) {

seg_len_2na = seg_len;

seg_len += ambiguity->Get4naLengthBlock(pos+seg_len,

( seg_len == seg_len_2na ) {

segments.push_back(seg);

kMinGapSize = 20;

kUnknownGapSize = 100;

( ;

> 0; ) {

seg_len_2na = seg_len;

( seg_len == kUnknownGapSize ) {

( seg_len == seg_len_2na ) {

segments.push_back(seg);

(it->range.GetFrom() == pos);

( it->literal ) {

(it->range.GetLength() == it->literal->GetLength());

seq->SetLiteral(it->literal.GetNCObject());

seq->SetLiteral().SetLength(it->range.GetLength());

.push_back(seq);

pos += it->range.GetLength();

( segments.size() == 1 && !segments[0].is_gap ) {

( length == 0 ) {

( !

.split_data ) {

pos = it->range.GetFrom();

end = it->range.GetToOpen();

( !chunk || chunk->GetId() != chunk_id ) {

chunk->SetId().Set(chunk_id);

.split->SetChunks().push_back(chunk);

chunk->SetContent().push_back(content);

this->flags =

;

<<

<<

);

( bytes.

() ) {

seqset->

().push_back(main_entry);

vector<TVDBRowId>& product_row_ids)

(

product_row_id = feat_it.GetProductRowId() ) {

product_row_ids.push_back(product_row_id);

( !product_features ) {

product_features = &annot->

().SetFtable();

dst = product_features;

( !main_features ) {

main_features = &annot->

().SetFtable();

dst = main_features;

kMaxGap = 100000;

vector<TVDBRowId>& product_row_ids,

product_index);

( gi_range_stop == gi_range_start ) {

( gi_range_stop == gi_range_start+

(1) ) {

gi_range.

(gi_range_start);

loc_set.push_back(loc);

vector<TVDBRowId>& product_row_ids,

product_index)

(

[0].HasFeatures() ) {

chunk->SetContent().push_back(content);

content->SetSeq_annot_place().SetBioseqs().Set().push_back(

);

(

[1].HasFeatures() ) {

chunk->SetContent().push_back(content);

content->SetSeq_annot_place().SetBioseq_sets().Set().push_back(

);

& loc_set = annot_info.

().SetLoc_set();

loc_set.push_back(old_loc);

(

it = product_row_ids.begin()+product_index; it != product_row_ids.end(); ++it ) {

<<*it);

( gi != gi_range_stop ) {

gi_range_start = gi;

loc_set.push_back(loc);

chunk->SetContent().push_back(content);

content->SetFeat_ids();

annot_info.

().push_back(type_info);

interval->SetStart(

.GetFrom());

interval->SetLength(

.GetLength());

intervals.

().push_back(interval);

vector<TVDBRowId>& product_row_ids)

chunk_index = 0;

product_index = 0;

with_product =

;

(

product_row_id = feat_it.GetProductRowId() ) {

product_row_ids.push_back(product_row_id);

with_product =

;

c.

(with_product, feat_it.GetFeatType(), feat_it.GetLocRange());

product_row_ids, product_index));

product_index = product_row_ids.size();

product_row_ids, product_index));

( !product_row_ids.empty() ) {

vector<TVDBRowId>& product_row_ids)

x_AddFeaturesSplit(range, product_row_ids);

x_AddFeaturesDirect(range, product_row_ids);

( !main_features ) {

main_seq->SetAnnot().push_back(annot);

main_features = &annot->

().SetFtable();

x_AddFeature(feat_it, *main_features);

.split->SetChunks().push_back(chunk);

chunk->SetId().Set(chunk_id);

chunk->SetContent().push_back(content);

content->SetFeat_ids();

content->SetSeq_annot();

annot_info.

(GetQualityAnnotName());

chunk->SetContent().push_back(content);

content->SetSeq_annot_place().SetBioseqs().Set().push_back(place);

(sw__GetContigBioseq);

.x_SetSeq(*

);

(

.entry ) {

.entry->SetSeq(*

.main_seq);

(sw___GetContigDescr);

( m_Cur->m_DESCR ) {

( !descr.

() ) {

.x_AddDescr(*descr);

.main_seq->SetDescr(*descr);

(sw___GetContigAnnot);

GetAnnotSet(

.main_seq->SetAnnot(),

.flags);

has_split_annot =

;

(

.split_qual ) {

x_AddQualityChunkInfo(

);

has_split_annot =

;

x_GetQualityAnnot(

.main_seq->SetAnnot(),

);

( !has_split_annot &&

.main_seq->GetAnnot().empty() ) {

.main_seq->ResetAnnot();

.main_seq->SetInst(*x_GetSeq_inst(

));

( feat_it.GetProductRowId() ) {

TFlags save_flags =

;

chunk->SetData().push_back(chunk_data);

bioseqs = &chunk_data->SetBioseqs();

( vector<TVDBRowId>, it, product_row_ids ) {

<<*it);

entry->

(*main_seq);

bioseqs->push_back(main_seq);

main_seq = save_seq;

(entry->IsSeq() && &entry->GetSeq() == main_seq);

vector<TVDBRowId> product_row_ids;

x_AddFeatures(range, product_row_ids);

( !product_row_ids.empty() ) {

(entry && entry->IsSet());

chunk_index = 0;

prod_count = 0;

( vector<TVDBRowId>, it, product_row_ids ) {

->SetChunks().push_back(chunk);

chunk->SetContent().push_back(content);

content->SetFeat_ids();

chunk->SetContent().push_back(content);

content->SetBioseq_place().push_back(place_info);

ids = &place_info->SetSeq_ids().Set();

<<*it);

x_AddProducts(product_row_ids);

( !db->GetMasterDescr().empty() ) {

db->AddMasterDescr(

.entry->SetDescr(),

.main_seq,

);

x_CreateBioseq(

);

x_CreateBioseq(

);

.x_CreateProtSet(GetLocFeatRowIdRange());

( !descr.

() ) {

.split =

;

.split_data =

;

.split_prod =

;

.split_feat =

;

CanHaveQualityGraph() ) {

.split_qual =

;

( !

.split_data && !

.split_prod && !

.split_feat &&

!

.split_qual ) {

.split->SetSkeleton(*

.entry);

.split->SetChunks();

x_CreateEntry(

);

index)

(sw_CreateQualityChunk);

x_GetQualityAnnot(

->SetAnnots(),

,

.chunk->SetData().push_back(

);

index)

GetGapInfo(gap_info);

TInstSegmentFlags inst_flags = fInst_MakeData;

x_GetSegmentsWithExplicitGaps(segments, range, gap_info, inst_flags);

(it->literal && it->literal->IsSetSeq_data());

piece->SetStart(it->range.GetFrom());

piece->SetData().push_back(it->literal);

->SetSeq_data().push_back(piece);

.chunk->SetData().push_back(

);

index)

(sw_CreateProductsChunk);

vector<TVDBRowId> product_row_ids;

(

row_id = feat_it.GetProductRowId() ) {

product_row_ids.push_back(row_id);

.x_AddProducts(product_row_ids);

index)

(sw_CreateFeaturesChunk);

range = GetLocFeatRowIdRange();

feat_stop =

(range.first+range.second, feat_start+

);

range.first = feat_start;

range.second =

(feat_start, feat_stop)-feat_start;

.chunk->SetData();

( feat_it.GetProductRowId() ) {

( !product_features ) {

.chunk->SetData().push_back(

);

->SetAnnots().push_back(annot);

product_features = &annot->

().SetFtable();

dst = product_features;

( !main_features ) {

.chunk->SetData().push_back(

);

->SetId().SetSeq_id(*

.main_id);

->SetAnnots().push_back(annot);

main_features = &annot->

().SetFtable();

dst = main_features;

.x_AddFeature(feat_it, *dst);

.x_SetId(*

);

x_CreateQualityChunk(

, index);

x_CreateProductsChunk(

, index);

x_CreateFeaturesChunk(

, index);

x_CreateDataChunk(

, index);

<<chunk_id<<

<<

);

x_CheckValid(

);

x_CreateBioseq(

);

.main_seq;

x_CheckValid(

);

x_CreateEntry(

);

(sw_GetSeq_entryData);

x_CheckValid(

);

x_CreateEntry(

);

GetSplitInfoAndVersion(

).first;

x_CheckValid(

);

( x_InitSplit(

) ) {

x_CreateSplit(

);

make_pair(

.split,

.split_version);

GetSplitInfoDataAndVersion(

).first;

(sw_GetSplitInfoData);

x_CheckValid(

);

( x_InitSplit(

) ) {

x_CreateSplit(

);

TFlags

)

x_CheckValid(

);

x_CreateChunk(

, chunk_id);

x_CheckValid(

);

x_CreateChunk(

, chunk_id);

TFlags

)

x_CheckValid(

);

x_CreateChunk(

, chunk_id);

x_CheckValid(

);

x_CreateChunk(

, chunk_id);

m_CurrId = m_FirstGoodId = m_FirstBadId = 0;

(

!= &iter ) {

<<method<<

);

( !

->m_ACCESSION ) {

(

);

(

->m_GB_STATE ) {

( !acc.

() ) {

<<

<<

<<

(sw___GetScaffoldIds);

ids.push_back(

);

ids.push_back(

);

ids.push_back(

);

(

);

( ret->

().empty() ) {

(

= 0;

< lens.

(); ++

) {

(

);

( !

->m_FEAT_ROW_START ) {

( start_val.

() ) {

( end < start ) {

<<start<<

<<end);

(

->m_COMPONENT_LINKAGE ) {

( !linkages_val.

() ) {

gaps_count = 0;

(

= 0;

< lens.

(); ++

) {

( linkages_val.

() != gaps_count ) {

);

linkages = linkages_val.

();

(

= 0;

< lens.

(); ++

) {

( start == 0 ||

== 0 ) {

+

interval.

(*

().GetContigSeq_id(row_id));

.push_back(seg);

(sw__GetScaffoldBioseq);

.x_SetSeq(*

);

(

.entry ) {

.entry->SetSeq(*

.main_seq);

(sw___GetContigDescr);

.main_seq->SetDescr(*descr);

(sw_GetScaffoldEntry);

.main_seq;

(

!= &iter ) {

(wgs_db, seq_type);

(wgs_db, seq_type);

( (seq_type ==

|| !

->m_NUC_ROW_ID) &&

(seq_type ==

|| !

->m_PROT_ROW_ID) ) {

( !

.empty() ) {

( !

.empty() ) {

: m_CurrId(0), m_FirstGoodId(0), m_FirstBadId(0)

: m_CurrId(0), m_FirstGoodId(0), m_FirstBadId(0)

(

!= &iter ) {

<<method<<

);

( !gi.

() ) {

(*gi,

);

(

->m_GB_ACCESSION ) {

(sw____GetProtAccVer);

(sw____GetProtAccSeq_id);

( !acc.

() ) {

(sw____GetProtGISeq_id);

<<

<<

<<

ids.push_back(

);

ids.push_back(

);

ids.push_back(

);

(

);

(

);

(

().HasCommonTaxId() ) {

->m_TAXID;

(

().HasCommonTaxId() ) {

->m_HASH;

->m_REF_ACC;

(

->m_GB_STATE ) {

(

);

( !

->m_PUBLIC_COMMENT ) {

(

);

( !

->m_PUBLIC_COMMENT ) {

( !

->m_TITLE ) {

(

);

( !

->m_FEAT_ROW_START ) {

( start_val.

() ) {

( end < start ) {

<<start<<

<<end);

(

);

( !

->m_FEAT_PRODUCT_ROW_ID ) {

(

);

( !

->m_FEAT_PRODUCT_ROW_ID ) {

(

);

( !

->m_FEAT_PRODUCT_ROW_ID ) {

.empty()? 0:

[

.size()-1];

(

);

( !

->m_FEAT_PRODUCT_ROW_ID ) {

.empty()? 0: *

;

(

);

(

->m_REPLACED_BY ) {

( !

.empty() ) {

(

);

(

->m_REPLACES ) {

( !

.empty() ) {

(

->m_DESCR ) {

( !title.

() ) {

ret->

().push_back(desc);

( ret->

().empty() ) {

( replaced_by_row || replaces_row ) {

( replaced_by_row ) {

( replaces_row ) {

.x_SetSeq(*

);

(

.entry ) {

.entry->SetSeq(*

.main_seq);

(

->m_DESCR ) {

( !descr.

() ) {

.x_AddDescr(*descr);

.main_seq->SetDescr(*descr);

( !

.db->FeatTable() ) {

(

.main_seq->GetAnnot().empty() ) {

.main_seq->ResetAnnot();

.main_seq;

(

!= &iter ) {

row_range.first+row_range.second);

<<method<<

);

(

);

(

);

( !

->m_PRODUCT_ROW_ID ) {

.empty()? 0: *

;

#define READ(buf, off, bytes, endian)

CAsnBinData(CSerialObject &obj)

virtual void Serialize(CObjectOStreamAsnBinary &out) const

CRef< CSerialObject > m_MainObject

virtual ~CAsnBinData(void)

const TInfoMap & info_map

CWGSAsnBinData::TDescrInfo TInfo

map< TKey, TInfo > TInfoMap

virtual void WriteClassMember(CObjectOStream &out, const CConstObjectInfoMI &member)

CDescrWriteHook(const TInfoMap &info_map)

virtual void WriteChoiceVariant(CObjectOStream &out, const CConstObjectInfoCV &variant)

map< TKey, TInfo > TInfoMap

const CSeq_annot::TData::TFtable * TKey

CWGSAsnBinData::SFtableInfo TInfo

const TInfoMap & info_map

CFtableWriteHook(const TInfoMap &info_map)

void Release()

Manually force the resource to be released.

CID2S_Bioseq_place_Info –.

CID2S_Feat_type_Info –.

CID2S_Seq_annot_Info –.

CID2S_Seq_id_Interval –.

CID2S_Sequence_Piece –.

void GetData(char *buffer, size_t size, size_t offset=0) const

size_t GetSize(void) const

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

Writing containers (SET OF, SEQUENCE OF).

Helper class: installs hooks in constructor, and uninstalls in destructor.

CObjectIStreamAsnBinary –.

CObjectOStreamAsnBinary –.

@Seq_descr.hpp User-defined methods of the data storage class.

namespace ncbi::objects::

Base class for all serializable objects.

CTempString implements a light-weight string on top of a storage buffer whose lifetime management is ...

Template class for iteration on objects of class C (non-medifiable version)

uint32_t GetElementCount(TVDBRowId row, const CVDBColumn &column, uint32_t elem_bits) const

void ReadElements(TVDBRowId row, const CVDBColumn &column, uint32_t elem_bits, uint32_t start, uint32_t count, void *buffer) const

TVDBRowIdRange GetRowIdRange(TVDBColumnIdx column=0) const

TVDBRowIdRange Find(const string &value) const

const TValue * data() const

const_iterator begin() const

static bool IsPlainAccession(const string &acc_or_path)

void AddFeature(TFtable &ftable, const CTempString &data)

vector< char > TDescrInfo

void AddDescr(CBioseq &seq, const CTempString &data)

CWGSAsnBinData(CSerialObject &obj)

virtual void Serialize(CObjectOStreamAsnBinary &out) const

CSeq_annot::TData::TFtable TFtable

map< const TFtable *, SFtableInfo > TFtableMap

virtual ~CWGSAsnBinData(void)

map< const CBioseq *, TDescrInfo > TDescrMap

CRef< CSeq_descr > m_EmptyDescr

CVDBTableIndex m_ProteinNameIndex

CRef< CSeq_id > GetGeneralOrPatentSeq_id(CTempString str, TVDBRowId row, TGnlIdFlags gnl_id_flags=fGnlId_Default) const

CVDBObjectCache< SProtIdxTableCursor > m_ProtIdx

CRef< SSeqTableCursor > Seq(TVDBRowId row=0)

CVDBObjectCache< SProt0TableCursor > m_Prot0

atomic< bool > m_GiIdxTableIsOpened

NCBI_gb_state m_ProjectGBState

const CVDBTableIndex & ContigNameIndex(void)

const CVDBTableIndex & ProductNameIndex(void)

pair< TGi, TGi > GetNucGiRange(void)

CRef< CSeq_id > GetGeneralSeq_id(CTempString prefix, CTempString tag) const

bool LoadMasterDescr(int filter)

const CVDBTable & GiIdxTable(void)

COpenRange< TIntId > TGiRange

EFeatLocIdType GetFeatLocIdType()

CRef< CSeq_entry > GetMasterDescrEntry(void)

atomic< bool > m_FeatTableIsOpened

CVDBTableIndex m_ScaffoldNameIndex

atomic< bool > m_ScfTableIsOpened

string m_IdPrefixDbWithVersion

CRef< SSeq0TableCursor > Seq0(TVDBRowId row=0)

CRef< SProtTableCursor > Prot(TVDBRowId row=0)

bool HasCommonTaxId(void) const

CRef< CSeq_id > GetAccSeq_id(CTempString acc, int version) const

CRef< SGiIdxTableCursor > GiIdx(TVDBRowId row=0)

void ResetMasterDescr(void)

TAmbiguityCache m_AmbiguityCache

TVDBRowId GetNucGiRowId(TGi gi)

const CVDBTableIndex & ScaffoldNameIndex(void)

CRef< CSeq_entry > GetMasterSeq_entry(void) const

void SetMasterDescr(const TMasterDescr &descr, int filter)

void OpenScaffoldNameIndex(void)

CRef< SAmbiguityInfo > GetAmbiguityInfo(TVDBRowId row)

TTaxId GetCommonTaxId(void) const

void PutAmbiguityInfo(CRef< SAmbiguityInfo > &ambiguity)

pair< TVDBRowId, bool > GetGiRowId(TGi gi)

TVDBRowCount GetTotalFeatureCount()

void x_SortGiRanges(TGiRanges &ranges)

CRef< SProtIdxTableCursor > ProtIdx(TVDBRowId row=0)

void OpenGiIdxTable(void)

EFeatLocIdType DetermineFeatLocIdType()

const CVDBTable & ScfTable(void)

static pair< TVDBRowId, ERowType > ParseRowType(CTempString acc, TAllowRowType allow)

void AddMasterDescr(CSeq_descr &descr, const CBioseq *main_seq=0, TFlags flags=fDefaultFlags) const

CVDBTableIndex m_ProtAccIndex

TMasterDescr m_MasterDescr

CRef< CSeq_entry > m_MasterEntry

void OpenIndex(const CVDBTable &table, CVDBTableIndex &index, atomic< Int1 > &index_is_opened, const char *index_name, const char *backup_index_name=0)

void OpenProteinNameIndex(void)

TVDBRowId GetScaffoldNameRowId(const string &name)

TVDBRowId GetContigNameRowId(const string &name)

CRef< CSeq_id > GetProteinSeq_id(TVDBRowId row_id) const

CVDBObjectCache< SSeqTableCursor > m_Seq

CSeq_inst::TMol GetScaffoldMolType(void) const

atomic< Int1 > m_ScaffoldNameIndexIsOpened

atomic< bool > m_ProtIdxTableIsOpened

NCBI_gb_state GetProjectGBState() const

CRef< SProt0TableCursor > Prot0(TVDBRowId row=0)

TVDBRowId GetProductNameRowId(const string &name)

CRef< CSeq_id > GetMasterSeq_id(void) const

TVDBRowId GetProtAccRowId(const string &acc, int version=-1)

CVDBObjectCache< SProtTableCursor > m_Prot

CRef< SFeatTableCursor > Feat(TVDBRowId row=0)

TVDBRowId GetProteinNameRowId(const string &name)

atomic< Int1 > m_ProductNameIndexIsOpened

vector< TGiRange > TGiRanges

TVDBRowId Lookup(const string &name, const CVDBTableIndex &index, bool upcase)

CRef< CSeq_id > GetPatentSeq_id(int id) const

virtual ~CWGSDb_Impl(void)

void OpenProtIdxTable(void)

list< CRef< CSeqdesc > > TMasterDescr

TProtAccRanges GetProtAccRanges(void)

CFastMutex m_AmbiguityCacheMutex

static string NormalizePathOrAccession(CTempString path_or_acc, CTempString vol_path=CTempString())

const CVDBTableIndex & ProteinNameIndex(void)

TGiRanges GetProtGiRanges(void)

TVDBRowId ParseRow(CTempString acc, bool *is_scaffold) const

TGiRanges GetNucGiRanges(void)

CVDBObjectCache< SScfTableCursor > m_Scf

void Put(CRef< SSeq0TableCursor > &curs, TVDBRowId row=0)

CRef< SSeq4naTableCursor > Seq4na(TVDBRowId row=0)

bool IsSetMasterDescr(void) const

CVDBTableIndex m_ContigNameIndex

void OpenProtAccIndex(void)

CVDBObjectCache< SSeq0TableCursor > m_Seq0

CSeq_inst::TMol GetContigMolType(void) const

void x_LoadMasterDescr(int filter)

CRef< CSeq_id > m_PatentId

void SetPatentId(CRef< CSeq_id > id)

atomic< bool > m_ProtTableIsOpened

TGi GetMasterGi(void) const

CRef< SScfTableCursor > Scf(TVDBRowId row=0)

const CVDBTable & FeatTable(void)

const CVDBTable & SeqTable(void)

CRef< CSeq_id > GetContigSeq_id(TVDBRowId row_id) const

pair< TGi, TGi > GetProtGiRange(void)

CSeq_inst::TMol m_ContigMolType

CWGSDb_Impl(CVDBMgr &mgr, CTempString path_or_acc, CTempString vol_path=CTempString())

string m_IdPrefixWithVersion

size_t GetMasterDescrBytes(TMasterDescrBytes &buffer)

void OpenProductNameIndex(void)

atomic< Int1 > m_ProtAccIndexIsOpened

CSeq_id::E_Choice m_SeqIdType

const TMasterDescr & GetMasterDescr(void) const

atomic< EFeatLocIdType > m_FeatLocIdType

CVDBTableIndex m_ProductNameIndex

CVDBObjectCache< SFeatTableCursor > m_Feat

void OpenContigNameIndex(void)

const CVDBTable & ProtIdxTable(void)

const CVDBTable & ProtTable(void)

bool HasStandardFeatLocIdType()

CSeq_inst::TMol GetProteinMolType(void) const

CVDBObjectCache< SGiIdxTableCursor > m_GiIdx

atomic< Int1 > m_ProteinNameIndexIsOpened

void OpenTable(CVDBTable &table, atomic< bool > &table_is_opened, const char *table_name)

CRef< CSeq_id > GetScaffoldSeq_id(TVDBRowId row_id) const

void x_InitIdParams(void)

TVDBRowId GetProtGiRowId(TGi gi)

const string & GetWGSPath(void) const

atomic< Int1 > m_ContigNameIndexIsOpened

static TVDBRowId ParseProteinRow(CTempString acc)

static TVDBRowId ParseScaffoldRow(CTempString acc)

static EDescrType GetMasterDescrType(const CSeqdesc &desc)

static TVDBRowId ParseContigRow(CTempString acc)

CRange< TSeqPos > GetLocRange(void) const

CWGSDb_Impl & GetDb(void) const

TVDBRowId GetLocRowId(void) const

NCBI_WGS_seqtype GetProductSeqType(void) const

NCBI_WGS_feattype GetFeatType(void) const

TVDBRowId GetProductRowId(void) const

TSeqPos GetLocLength(void) const

CRef< CSeq_feat > GetSeq_feat() const

CWGSFeatureIterator & SelectRow(TVDBRowId row)

CTempString GetSeq_featBytes(void) const

CWGSFeatureIterator & operator=(const CWGSFeatureIterator &iter)

void x_ReportInvalid(const char *method) const

CWGSFeatureIterator & SelectRowRange(TVDBRowIdRange row_range)

NCBI_WGS_seqtype GetLocSeqType(void) const

TSeqPos GetLocStart(void) const

CWGSFeatureIterator(void)

CRef< CWGSDb_Impl::SFeatTableCursor > m_Cur

void x_Init(const CWGSDb &wgs_db)

~CWGSFeatureIterator(void)

void x_CheckValid(const char *method) const

void x_Init(const CWGSDb &wgs_db, ESeqType seq_type)

CRef< CWGSDb_Impl::SGiIdxTableCursor > m_Cur

CWGSDb_Impl & GetDb(void) const

CWGSGiIterator & operator=(const CWGSGiIterator &iter)

CRef< CSeq_id > GetAccSeq_id(void) const

CBioseq::TAnnot TAnnotSet

TVDBRowId GetReplacesRowId(void) const

void x_CreateEntry(SWGSCreateInfo &info) const

CTempString GetPublicComment(void) const

CWGSProteinIterator & SelectRow(TVDBRowId row)

CRef< CBioseq > GetBioseq(TFlags flags=fDefaultFlags) const

CWGSProteinIterator(void)

CRef< CSeq_id > GetGiSeq_id(void) const

NCBI_gb_state GetGBState(void) const

size_t GetProductFeatCount(void) const

bool HasTaxId(void) const

TVDBRowId GetBestProductFeatRowId(void) const

TSeqPos GetSeqLength(void) const

CWGSDb_Impl & GetDb(void) const

bool HasTitle(void) const

NCBI_gb_state GetRawGBState(void) const

TVDBRowIdRange GetLocFeatRowIdRange(void) const

TVDBRowId GetProductFeatRowId(void) const

CWGSProteinIterator & operator=(const CWGSProteinIterator &iter)

CRef< CSeq_inst > GetSeq_inst(TFlags flags=fDefaultFlags) const

CSeq_id::TGi GetGi(void) const

THash GetSeqHash(void) const

bool HasAnnotSet(void) const

void x_CheckValid(const char *method) const

CRef< CWGSDb_Impl::SProtTableCursor > m_Cur

CRef< CSeq_entry > GetSeq_entry(TFlags flags=fDefaultFlags) const

int GetAccVersion(void) const

void x_CreateBioseq(SWGSCreateInfo &info) const

CTempString GetTitle(void) const

void GetIds(CBioseq::TId &ids, TFlags flags=fDefaultFlags) const

~CWGSProteinIterator(void)

void x_Init(const CWGSDb &wgs_db)

CTempString GetAccession(void) const

CRef< CSeq_id > GetGeneralOrPatentSeq_id(void) const

CRef< CSeq_id > GetId(TFlags flags=fDefaultFlags) const

bool HasPublicComment(void) const

CRef< CSeq_id > GetGeneralSeq_id(void) const

bool HasSeqHash(void) const

void GetAnnotSet(TAnnotSet &annot_set, TFlags flags=fDefaultFlags) const

CTempString GetRefAcc(void) const

TTaxId GetTaxId(void) const

CTempString GetProductName(void) const

void x_ReportInvalid(const char *method) const

CTempString GetProteinName(void) const

CRef< CWGSDb_Impl::SProt0TableCursor > m_Cur0

CRef< CSeq_descr > GetSeq_descr(TFlags flags=fDefaultFlags) const

TVDBRowId GetReplacedByRowId(void) const

bool HasRefAcc(void) const

bool HasSeq_descr(TFlags flags=fDefaultFlags) const

void x_Init(const CWGSDb &wgs_db)

void x_ReportInvalid(const char *method) const

CWGSScaffoldIterator(void)

bool HasSeq_descr(TFlags flags=fDefaultFlags) const

void x_CreateEntry(SWGSCreateInfo &info) const

CRef< CSeq_id > GetAccSeq_id(void) const

CWGSScaffoldIterator & SelectRow(TVDBRowId row)

CTempString GetScaffoldName(void) const

void x_CreateBioseq(SWGSCreateInfo &info) const

TVDBRowIdRange GetLocFeatRowIdRange(void) const

CRef< CSeq_id > GetGeneralOrPatentSeq_id(void) const

bool IsCircular(void) const

CRef< CSeq_descr > GetSeq_descr(TFlags flags=fDefaultFlags) const

NCBI_gb_state GetRawGBState(void) const

CRef< CBioseq > GetBioseq(TFlags flags=fDefaultFlags) const

void GetIds(CBioseq::TId &ids, TFlags flags=fDefaultFlags) const

CRef< CSeq_entry > GetSeq_entry(TFlags flags=fDefaultFlags) const

CRef< CSeq_inst > GetSeq_inst(TFlags flags=fDefaultFlags) const

CWGSScaffoldIterator & operator=(const CWGSScaffoldIterator &iter)

CRef< CWGSDb_Impl::SScfTableCursor > m_Cur

int GetAccVersion(void) const

CRef< CSeq_id > GetGeneralSeq_id(void) const

TSeqPos GetSeqLength(void) const

CRef< CSeq_id > GetId(TFlags flags=fDefaultFlags) const

NCBI_gb_state GetGBState(void) const

void x_CheckValid(const char *method) const

~CWGSScaffoldIterator(void)

CWGSDb_Impl & GetDb(void) const

CTempString GetAccession(void) const

CRef< CSeq_id > GetGiSeq_id(void) const

void x_CreateChunk(SWGSCreateInfo &info, TChunkId chunk_id) const

CRef< CAsnBinData > GetSeq_entryData(TFlags flags=fDefaultFlags) const

CRef< CSeq_data > Get4na(TSeqPos pos, TSeqPos len) const

void x_Select(const CWGSDb &wgs_db, TIncludeFlags include_flags, EClipType clip_type)

void x_Init(const CWGSDb &wgs_db, TIncludeFlags include_flags, EClipType clip_type, TVDBRowId get_row)

bool x_Excluded(void) const

void x_CreateSplit(SWGSCreateInfo &info) const

CRef< CSeq_descr > GetSeq_descr(TFlags flags=fDefaultFlags) const

void x_SetDelta(CSeq_inst &inst, const TSegments &segments) const

CTempString GetTitle(void) const

bool CanHaveQualityGraph(void) const

TIncludeFlags m_IncludeFlags

CTempString GetPublicComment(void) const

bool x_InitSplit(SWGSCreateInfo &info) const

CRef< CAsnBinData > GetChunkDataForVersion(TChunkId chunk_id, TSplitVersion split_version) const

CTempString GetContigName(void) const

CWGSSeqIterator & SelectRow(TVDBRowId row)

CRef< CSeq_id > GetGeneralOrPatentSeq_id(void) const

TSeqPos GetRawSeqLength(void) const

CWGSSeqIterator & operator++(void)

CRef< CID2S_Chunk > GetChunkForVersion(TChunkId chunk_id, TSplitVersion split_version) const

CRef< CAsnBinData > GetChunkData(TChunkId chunk_id, TFlags flags=fDefaultFlags) const

SAmbiguityAccess GetAmbiguity() const

void GetQualityAnnot(TAnnotSet &annot_set, TFlags flags=fDefaultFlags) const

TTaxId GetTaxId(void) const

CTempString GetAccession(void) const

TVDBRowIdRange GetLocFeatRowIdRange(void) const

void x_AddQualityChunkInfo(SWGSCreateInfo &info) const

bool IsCircular(void) const

CRef< CSeq_id > GetGeneralSeq_id(void) const

bool HasQualityGraph(void) const

bool HasClippingInfo(void) const

CRef< CAsnBinData > GetSplitInfoData(TFlags flags=fDefaultFlags) const

TSeqPos GetClipQualityLength(void) const

string GetQualityAnnotName(void) const

NCBI_gb_state GetRawGBState(void) const

COpenRange< TSeqPos > x_NormalizeSeqRange(COpenRange< TSeqPos > range) const

void x_ReportInvalid(const char *method) const

void x_GetSegmentsWithRecoveredGaps(TSegments &segments, COpenRange< TSeqPos > range) const

bool HasPublicComment(void) const

CTempString GetNucProtDescrBytes(void) const

CSeq_id::TGi GetGi(void) const

void SelectAccVersion(int version)

void x_CreateBioseq(SWGSCreateInfo &info) const

bool HasGapInfo(void) const

CWGSSeqIterator & operator=(const CWGSSeqIterator &iter)

bool HasTitle(void) const

void GetQualityVec(vector< INSDC_quality_phred > &quality_vec) const

CRef< CSeq_inst > x_GetSeq_inst(SWGSCreateInfo &info) const

CRef< CSeq_id > GetGiSeq_id(void) const

void x_CreateProductsChunk(SWGSCreateInfo &info, unsigned index) const

CRef< CWGSDb_Impl::SSeq0TableCursor > m_Cur0

bool HasAnnotSet(void) const

CRef< CSeq_id > GetAccSeq_id(void) const

int GetAccVersion(void) const

bool HasSeqHash(void) const

CTempString GetAnnotBytes(void) const

THash GetSeqHash(void) const

SVersionSelector x_GetAccVersionSelector(int version) const

CRef< CID2S_Chunk > GetChunk(TChunkId chunk_id, TFlags flags=fDefaultFlags) const

pair< CRef< CAsnBinData >, TSplitVersion > GetSplitInfoDataAndVersion(TFlags flags=fDefaultFlags) const

void x_CreateDataChunk(SWGSCreateInfo &info, unsigned index) const

void x_GetSegmentsWithExplicitGaps(TSegments &data, COpenRange< TSeqPos > range, TWGSContigGapInfo gap_info, TInstSegmentFlags flags) const

void x_CreateEntry(SWGSCreateInfo &info) const

void x_GetQualityAnnot(TAnnotSet &annot_set, SWGSCreateInfo &info, TSeqPos pos=0, TSeqPos len=kInvalidSeqPos) const

bool HasSeq_descr(TFlags flags=fDefaultFlags) const

void GetGapInfo(TWGSContigGapInfo &gap_info) const

void x_CreateQualityChunk(SWGSCreateInfo &info, unsigned index) const

CRef< CSeq_data > Get2na(TSeqPos pos, TSeqPos len) const

bool HasTaxId(void) const

CBioseq::TAnnot TAnnotSet

struct CWGSSeqIterator::SWGSContigGapInfo TWGSContigGapInfo

TSeqPos GetSeqLength(EClipType clip_type=eDefaultClip) const

CRef< CBioseq > GetBioseq(TFlags flags=fDefaultFlags) const

CRef< CWGSDb_Impl::SAmbiguityInfo > m_AmbiguityInfo

SVersionSelector m_AccVersion

TSeqPos x_GetQualityArraySize(void) const

CRef< CWGSDb_Impl::SSeqTableCursor > m_Cur

void x_SetDeltaOrData(CSeq_inst &inst, const TSegments &segments) const

TSeqPos GetClipQualityLeft(void) const

pair< CRef< CID2S_Split_Info >, TSplitVersion > GetSplitInfoAndVersion(TFlags flags=fDefaultFlags) const

CRef< CID2S_Split_Info > GetSplitInfo(TFlags flags=fDefaultFlags) const

bool HasAccVersion(int version) const

unsigned GetAccVersionCount(void) const

void GetAnnotSet(TAnnotSet &annot_set, TFlags flags=fDefaultFlags) const

CRef< CSeq_inst > GetSeq_inst(TFlags flags=fDefaultFlags) const

vector< Uint1 > GetAmbiguityBytes() const

bool HasNucProtDescrBytes(void) const

CTempString GetSeqDescrBytes(void) const

int GetLatestAccVersion(void) const

vector< SSegment > TSegments

TSeqPos GetSeqOffset(EClipType clip_type=eDefaultClip) const

void GetIds(CBioseq::TId &ids, TFlags flags=fDefaultFlags) const

CRef< CSeq_entry > GetSeq_entry(TFlags flags=fDefaultFlags) const

bool HasSeqDescrBytes(void) const

void x_AddGap(TSegments &segments, TSeqPos pos, TSeqPos len, const TWGSContigGapInfo &gap_info) const

void x_CreateFeaturesChunk(SWGSCreateInfo &info, unsigned index) const

bool GetClipByQualityFlag(EClipType clip_type=eDefaultClip) const

void x_CheckValid(const char *method) const

CRef< CSeq_id > GetId(TFlags flags=fDefaultFlags) const

NCBI_gb_state GetGBState(void) const

CWGSDb_Impl & GetDb(void) const

Write hook for a choice variant (CHOICE)

Write hook for data member of a containing object (eg, SEQUENCE)

void Cleanup(TGlobalAmbiguityCache &)

TGlobalAmbiguityCache * Create()

void put(const key_type &key, const mapped_type &value, const resource_type &resource_used)

mapped_type get(const key_type &key)

container_type::const_iterator const_iterator

container_type::iterator iterator

const_iterator end() const

const_iterator lower_bound(const key_type &key) const

iterator_bool insert(const value_type &val)

container_type::value_type value_type

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

const_iterator end() const

The NCBI C++ standard methods for dealing with std::string.

int GetSeqLength(const CBioseq &bioseq)

static vector< string > arr

std::ofstream out("events_result.xml")

main entry point for tests

static const char table_name[]

static const char * str(char *buf, int n)

#define GI_FROM(T, value)

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

SStrictId_Tax::TId TTaxId

Taxon id type.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

#define TAX_ID_FROM(T, value)

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

#define LOG_POST(message)

This macro is deprecated and it's strongly recomended to move in all projects (except tests) to macro...

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

void Warning(CExceptionArgs_Base &args)

#define NCBI_THROW_FMT(exception_class, err_code, message)

The same as NCBI_THROW but with message processed as output to ostream.

static void SetErrno(int errno_code)

Set last error using errno code.

static string MakePath(const string &dir=kEmptyStr, const string &base=kEmptyStr, const string &ext=kEmptyStr)

Assemble a path from basic components.

const TPrim & Get(void) const

C * SerialClone(const C &src)

Create on heap a clone of the source object.

CBeginInfo Begin(C &obj)

Get starting point of object hierarchy.

CObjectTypeInfo GetPointedType(void) const

Get type information of data to which this type refers.

CObjectTypeInfo GetMemberType(void) const

Get data type information.

const CConstObjectInfo & GetClassObject(void) const

Get containing class data.

void DefaultWrite(CObjectOStream &out, const CConstObjectInfoCV &variant)

CConstObjectInfo GetVariant(void) const

Get variant data.

ETypeFamily GetTypeFamily(void) const

Get data type family.

TConstObjectPtr GetObjectPtr(void) const

Get pointer to object.

void DefaultWrite(CObjectOStream &out, const CConstObjectInfoMI &member)

void OpenFromBuffer(const char *buffer, size_t size)

Attach reader to a data source.

Uint8 TCount

Alias for value type of counter.

TObjectType * GetNCPointer(void) const THROWS_NONE

Get pointer,.

CRef< C > Ref(C *object)

Helper functions to get CRef<> and CConstRef<> objects.

void Reset(void)

Reset reference object.

TObjectType & GetNCObject(void) const

Get object.

#define NCBI_PARAM_TYPE(section, name)

Generate typename for a parameter from its {section, name} attributes.

@ eParam_NoThread

Do not use per-thread values.

uint8_t Uint1

1-byte (8-bit) unsigned integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

int8_t Int1

1-byte (8-bit) signed integer

position_type GetLength(void) const

TThisType & SetFrom(position_type from)

TThisType & SetToOpen(position_type toOpen)

position_type GetToOpen(void) const

position_type GetFrom(void) const

TThisType & SetLength(position_type length)

NCBI_NS_STD::string::size_type SIZE_TYPE

CTempString literal(const char(&str)[Size])

Templatized initialization from a string literal.

static list< string > & Split(const CTempString str, const CTempString delim, list< string > &arr, TSplitFlags flags=0, vector< SIZE_TYPE > *token_pos=NULL)

Split a string using specified delimiters.

static Uint8 StringToUInt8_DataSize(const CTempString str, TStringToNumFlags flags=0)

Convert string that can contain "software" qualifiers to Uint8.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

const char * data(void) const

Return a pointer to the array represented.

bool empty(void) const

Return true if the represented string is empty (i.e., the length is zero)

static bool StartsWith(const CTempString str, const CTempString start, ECase use_case=eCase)

Check if a string starts with a specified prefix value.

CTempString substr(size_type pos) const

Obtain a substring from this string, beginning at a given offset.

static bool IsUpper(const CTempString str)

Checks if all letters in the given string have a upper case.

size_type find_first_of(const CTempString match, size_type pos=0) const

Find the first occurrence of any character in the matching string within the current string,...

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

size_type find(const CTempString match, size_type pos=0) const

Find the first instance of the entire matching string within the current string, beginning at an opti...

static bool Equal(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2, ECase use_case=eCase)

Test for equality of a substring with another string.

static string & ToUpper(string &str)

Convert string to upper case – string& version.

size_type size(void) const

Return the length of the represented array.

@ fConvErr_NoThrow

Do not throw an exception on error.

@ fWithCommas

Use commas as thousands separator.

double Elapsed(void) const

Return time elapsed since first Start() or last Restart() call (in seconds).

void Stop(void)

Suspend the timer.

void Start(void)

Start the timer.

void SetFrom(TFrom value)

Assign a value to From data member.

bool IsStr(void) const

Check if variant Str is selected.

const TStr & GetStr(void) const

Get the variant data.

TStr & SetStr(void)

Select the variant.

const TData & GetData(void) const

Get the Data member data.

void SetType(TType &value)

Assign a value to Type data member.

const TType & GetType(void) const

Get the Type member data.

void SetDb(const TDb &value)

Assign a value to Db data member.

TId & SetId(void)

Select the variant.

vector< CRef< CUser_field > > TData

TGi & SetGi(void)

Select the variant.

void SetName(const TName &value)

Assign a value to Name data member.

void SetStart(TStart value)

Assign a value to Start data member.

list< CRef< C_E > > Tdata

TSeq_id_interval & SetSeq_id_interval(void)

Select the variant.

list< CRef< CID2S_Seq_loc > > TLoc_set

TSeq_id & SetSeq_id(void)

Select the variant.

TWhole_gi_range & SetWhole_gi_range(void)

Select the variant.

TGi_interval & SetGi_interval(void)

Select the variant.

TSeq_id & SetSeq_id(void)

Select the variant.

void SetGi(TGi value)

Assign a value to Gi data member.

void SetSeq_id(TSeq_id &value)

Assign a value to Seq_id data member.

void SetSeq_loc(TSeq_loc &value)

Assign a value to Seq_loc data member.

TGi & SetGi(void)

Select the variant.

void SetCount(TCount value)

Assign a value to Count data member.

list< CRef< CBioseq > > TBioseqs

void SetStart(TStart value)

Assign a value to Start data member.

void SetStart(TStart value)

Assign a value to Start data member.

TWhole_gi & SetWhole_gi(void)

Select the variant.

TFeat & SetFeat(void)

Assign a value to Feat data member.

TContent & SetContent(void)

Assign a value to Content data member.

TWhole_seq_id & SetWhole_seq_id(void)

Select the variant.

void SetSeq_id(TSeq_id &value)

Assign a value to Seq_id data member.

void SetGraph(void)

Set NULL data member (assign 'NULL' value to Graph data member).

void SetLength(TLength value)

Assign a value to Length data member.

void ResetSeq_loc(void)

Reset Seq_loc data member.

TInts & SetInts(void)

Assign a value to Ints data member.

void SetLength(TLength value)

Assign a value to Length data member.

const TLocation & GetLocation(void) const

Get the Location member data.

E_Choice

Choice variants.

@ e_not_set

No variant selected.

@ e_MaxChoice

== e_Variation+1

void SetSeqid(TSeqid value)

Assign a value to Seqid data member.

void SetTo(TTo value)

Assign a value to To data member.

TPatent & SetPatent(void)

Select the variant.

void SetId(TId &value)

Assign a value to Id data member.

void SetFrom(TFrom value)

Assign a value to From data member.

TGi GetGi(void) const

Get the variant data.

TGi & SetGi(void)

Select the variant.

E_Choice

Choice variants.

bool IsGi(void) const

Check if variant Gi is selected.

void SetStrand(TStrand value)

Assign a value to Strand data member.

void SetCit(TCit &value)

Assign a value to Cit data member.

@ e_not_set

No variant selected.

void SetMin(TMin value)

Assign a value to Min data member.

void SetTitle(const TTitle &value)

Assign a value to Title data member.

void SetNumval(TNumval value)

Assign a value to Numval data member.

TValues & SetValues(void)

Assign a value to Values data member.

void SetGraph(TGraph &value)

Assign a value to Graph data member.

void SetMax(TMax value)

Assign a value to Max data member.

void SetLoc(TLoc &value)

Assign a value to Loc data member.

void SetAxis(TAxis value)

Assign a value to Axis data member.

const TSeq & GetSeq(void) const

Get the variant data.

TSet & SetSet(void)

Select the variant.

TAnnot & SetAnnot(void)

Assign a value to Annot data member.

bool IsSeq(void) const

Check if variant Seq is selected.

void SetId(TId &value)

Assign a value to Id data member.

bool IsSet(void) const

Check if variant Set is selected.

void SetClass(TClass value)

Assign a value to Class data member.

list< CRef< CSeq_entry > > TSeq_set

TSeq & SetSeq(void)

Select the variant.

TSeq_set & SetSeq_set(void)

Assign a value to Seq_set data member.

@ eClass_nuc_prot

nuc acid and coded proteins

@ e_not_set

No variant selected.

void ResetStrand(void)

Reset Strand data member.

void SetLength(TLength value)

Assign a value to Length data member.

void SetData(TData &value)

Assign a value to Data data member.

list< CRef< CSeqdesc > > Tdata

TId & SetId(void)

Assign a value to Id data member.

const TUser & GetUser(void) const

Get the variant data.

TTitle & SetTitle(void)

Select the variant.

void SetSeq_data(TSeq_data &value)

Assign a value to Seq_data data member.

void SetDesc(TDesc &value)

Assign a value to Desc data member.

void SetExt(TExt &value)

Assign a value to Ext data member.

void SetHist(THist &value)

Assign a value to Hist data member.

TAnnot & SetAnnot(void)

Assign a value to Annot data member.

const TId & GetId(void) const

Get the Id member data.

TName & SetName(void)

Select the variant.

const Tdata & Get(void) const

Get the member data.

void SetType(TType value)

Assign a value to Type data member.

TLength GetLength(void) const

Get the Length member data.

list< CRef< CSeq_id > > TId

void SetReplaces(TReplaces &value)

Assign a value to Replaces data member.

void SetFuzz(TFuzz &value)

Assign a value to Fuzz data member.

void SetInst(TInst &value)

Assign a value to Inst data member.

bool IsSetDescr(void) const

descriptors Check if a value has been assigned to Descr data member.

void SetTopology(TTopology value)

Assign a value to Topology data member.

EMol

molecule class in living organism

void SetDescr(TDescr &value)

Assign a value to Descr data member.

const TNcbi4na & GetNcbi4na(void) const

Get the variant data.

TUser & SetUser(void)

Select the variant.

void SetRepr(TRepr value)

Assign a value to Repr data member.

TNcbi2na & SetNcbi2na(void)

Select the variant.

list< CRef< CSeq_feat > > TFtable

const TNcbi2na & GetNcbi2na(void) const

Get the variant data.

E_Choice Which(void) const

Which variant is currently selected.

void SetReplaced_by(TReplaced_by &value)

Assign a value to Replaced_by data member.

Tdata & Set(void)

Assign a value to data member.

list< CRef< CSeq_annot > > TAnnot

void SetLength(TLength value)

Assign a value to Length data member.

list< CRef< CDelta_seq > > Tdata

void SetStrand(TStrand value)

Assign a value to Strand data member.

TLinkage_evidence & SetLinkage_evidence(void)

Assign a value to Linkage_evidence data member.

void SetLinkage(TLinkage value)

Assign a value to Linkage data member.

void SetSeq_data(TSeq_data &value)

Assign a value to Seq_data data member.

void ResetExt(void)

Reset Ext data member.

TNcbi4na & SetNcbi4na(void)

Select the variant.

const TDescr & GetDescr(void) const

Get the Descr member data.

const TSeq_data & GetSeq_data(void) const

Get the Seq_data member data.

void SetMol(TMol value)

Assign a value to Mol data member.

bool IsUser(void) const

Check if variant User is selected.

@ eRepr_delta

sequence made by changes (delta) to others

@ eRepr_raw

continuous sequence

@ eRepr_virtual

no seq data

@ e_Embl

EMBL specific information.

@ e_User

user defined object

@ e_Update_date

date of last update

@ e_Pub

a reference to the publication

@ e_Genbank

GenBank specific info.

@ e_Comment

a more extensive comment

@ e_Molinfo

info on the molecule and techniques

@ e_Create_date

date entry first created/released

@ e_Source

source of materials, includes Org-ref

@ eStrand_ds

double strand

unsigned int

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

Definition of all error codes used in SRA C++ support libraries.

where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is whole

<!DOCTYPE HTML >< html > n< header > n< title > PubSeq Gateway Help Page</title > n< style > n table

Lightweight interface for getting lines of data with minimal memory copying.

constexpr auto sort(_Init &&init)

constexpr bool empty(list< Ts... >) noexcept

const string version

version string

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

const struct ncbi::grid::netcache::search::fields::KEY key

string s_Value(TValue value)

const GenericPointer< typename T::ValueType > T2 value

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

std::istream & in(std::istream &in_, double &x_)

Int4 delta(size_t dimension_, const Int4 *score_)

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

void split(std::vector< std::string > *strVec, const std::string &str_, const std::string &split_)

static bool GetIds(const T &d, set< string > &labels, const string name="", bool detect=false, bool found=false)

#define row(bind, expected)

void AddFeature(const CTempString &data)

char m_Packed4na[kAmbiguityBlockSize/2]

T4naBlocks::const_iterator m_4naBlocksIter

EBaseType GetBaseType(const S4naReader &reader) const

CWGSDb_Impl::SSeqTableCursor SSeqTableCursor

void x_CalculateAmbiguityMask(CWGSDb_Impl &db)

SAmbiguityInfo(TVDBRowId row_id, CWGSDb_Impl &db, SSeqTableCursor &cur)

bool x_AmbiguousBlock(size_t block_index) const

bool x_IsValid(const S4naReader &reader) const

vector< INSDC_coord_len > m_GapLen

vector< NCBI_WGS_component_props > m_GapProps

bool x_AddAmbiguousBlock(const Uint1 *ptr, TSeqPos count, TSeqPos pos, TWGSContigGapInfo &gap_info) const

bool x_AddAmbiguities(const Uint1 *ptr, TSeqPos count, TSeqPos pos, TWGSContigGapInfo &gap_info) const

vector< INSDC_coord_zero > m_GapStart

vector< Uint1 > GetAmbiguityBytes(SSeqTableCursor &cur)

void Advance(S4naReader &reader) const

TWGSContigGapInfo GetGapInfo() const

void x_SetAmbiguousBlock(size_t block_index)

map< TSeqPos, S4naBlock > T4naBlocks

CWGSSeqIterator::TWGSContigGapInfo TWGSContigGapInfo

TSeqPos Get2naLengthExact(TSeqPos pos, TSeqPos len, CWGSDb_Impl &db, SSeqTableCursor &cur) const

CRef< CSeq_data > Get4na(TSeqPos pos, TSeqPos len, CWGSDb_Impl &db, SSeqTableCursor &cur) const

void x_Calculate4na(CWGSDb_Impl &db) const

S4naReader Get4naReader(TSeqPos pos, CWGSDb_Impl &db, SSeqTableCursor &cur) const

vector< INSDC_4na_bin > m_Ambiguity4na

vector< Uint1 > m_AmbiguityMask

CRef< CSeq_data > Get2na(TSeqPos pos, TSeqPos len, SSeqTableCursor &cur) const

TSeqPos Get4naLengthBlock(TSeqPos pos, TSeqPos len) const

TSeqPos Get2naLengthBlock(TSeqPos pos, TSeqPos len) const

vector< NCBI_WGS_gap_linkage > m_GapLinkage

TSeqPos GetGapLengthExact(TSeqPos pos, TSeqPos len, CWGSDb_Impl &db, SSeqTableCursor &cur) const

vector< INSDC_coord_zero > m_AmbiguityPos

void x_Need4na(CWGSDb_Impl &db) const

size_t GetUsedMemory() const

TSeqPos Get4naLengthExact(TSeqPos pos, TSeqPos len, TSeqPos stop_2na_len, TSeqPos stop_gap_len, CWGSDb_Impl &db, SSeqTableCursor &cur) const

SFeatTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(TVDBRowId, PRODUCT_ROW_ID)

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, PRODUCT_START)

CObjectIStreamAsnBinary m_ObjStr

DECLARE_VDB_COLUMN_AS_STRING(LOC_ACCESSION)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_feattype, FEAT_TYPE)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_seqtype, LOC_SEQ_TYPE)

DECLARE_VDB_COLUMN_AS_STRING(PRODUCT_ACCESSION)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_seqtype, PRODUCT_SEQ_TYPE)

DECLARE_VDB_COLUMN_AS(TVDBRowId, LOC_ROW_ID)

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, LOC_START)

DECLARE_VDB_COLUMN_AS_STRING(SEQ_FEAT)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_loc_strand, LOC_STRAND)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, LOC_LEN)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, PRODUCT_LEN)

SGiIdxTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(TVDBRowId, PROT_ROW_ID)

DECLARE_VDB_COLUMN_AS(TVDBRowId, NUC_ROW_ID)

SProt0TableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(NCBI_gi, GI)

DECLARE_VDB_COLUMN_AS_STRING(GB_ACCESSION)

DECLARE_VDB_COLUMN_AS(uint32_t, ACC_VERSION)

DECLARE_VDB_COLUMN_AS_STRING(SEQID_GNL_PREFIX)

DECLARE_VDB_COLUMN_AS_STRING(PROTEIN_NAME)

string GetAcc(Uint4 id) const

pair< TVDBRowId, TVDBRowId > row_range_t

DECLARE_VDB_COLUMN_AS(row_range_t, NAME_ROW_RANGE)

SProtIdxTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(TVDBRowId, ROW_ID)

DECLARE_VDB_COLUMN_AS_STRING(PUBLIC_COMMENT)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_START)

DECLARE_VDB_COLUMN_AS(TVDBRowId, REPLACED_BY)

SProtTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS_STRING(DESCR)

DECLARE_VDB_COLUMN_AS_STRING(PROTEIN)

DECLARE_VDB_COLUMN_AS(NCBI_taxid, TAXID)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_END)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_PRODUCT_ROW_ID)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, PROTEIN_LEN)

DECLARE_VDB_COLUMN_AS(NCBI_gb_state, GB_STATE)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_hash, HASH)

DECLARE_VDB_COLUMN_AS_STRING(PRODUCT_NAME)

DECLARE_VDB_COLUMN_AS_STRING(TITLE)

DECLARE_VDB_COLUMN_AS_STRING(REF_ACC)

DECLARE_VDB_COLUMN_AS(TVDBRowId, REPLACES)

DECLARE_VDB_COLUMN_AS_STRING(ANNOT)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_component_props, COMPONENT_PROPS)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_START)

SScfTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_gap_linkage, COMPONENT_LINKAGE)

DECLARE_VDB_COLUMN_AS_STRING(ACCESSION)

DECLARE_VDB_COLUMN_AS(TVDBRowId, COMPONENT_ID)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, COMPONENT_LEN)

DECLARE_VDB_COLUMN_AS(NCBI_gb_state, GB_STATE)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_PRODUCT_ROW_ID)

DECLARE_VDB_COLUMN_AS(INSDC_coord_one, COMPONENT_START)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_END)

DECLARE_VDB_COLUMN_AS_STRING(SCAFFOLD_NAME)

DECLARE_VDB_COLUMN_AS(bool, CIRCULAR)

DECLARE_VDB_COLUMN_AS_STRING(SEQID_GNL_PREFIX)

SSeq0TableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(NCBI_taxid, TAXID)

DECLARE_VDB_COLUMN_AS_STRING(SEQID_GNL_PREFIX)

DECLARE_VDB_COLUMN_AS(Uint1, MOL)

DECLARE_VDB_COLUMN_AS_STRING(ACC_PREFIX)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, ACC_CONTIG_LEN)

DECLARE_VDB_COLUMN_AS(INSDC_4na_bin, READ)

SSeq4naTableCursor(const CVDBTable &table)

SSeqTableCursor(const CVDBTable &table)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_PRODUCT_ROW_ID)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_hash, HASH)

CVDBColumnBits< 2 > m_READ_2na

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, TRIM_START)

DECLARE_VDB_COLUMN_AS_STRING(LABEL)

DECLARE_VDB_COLUMN_AS(INSDC_quality_phred, QUALITY)

DECLARE_VDB_COLUMN_AS_STRING(CONTIG_NAME)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_gap_linkage, GAP_LINKAGE)

DECLARE_VDB_COLUMN_AS(INSDC_4na_bin, AMBIGUITY_4NA)

DECLARE_VDB_COLUMN_AS(NCBI_gb_state, GB_STATE)

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, AMBIGUITY_POS)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, GAP_LEN)

DECLARE_VDB_COLUMN_AS_STRING(TITLE)

DECLARE_VDB_COLUMN_AS(NCBI_gi, GI)

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, READ_START)

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, READ_LEN)

DECLARE_VDB_COLUMN_AS_STRING(ANNOT)

DECLARE_VDB_COLUMN_AS(Uint1, AMBIGUITY_MASK)

DECLARE_VDB_COLUMN_AS(bool, CIRCULAR)

DECLARE_VDB_COLUMN_AS_STRING(ACCESSION)

DECLARE_VDB_COLUMN_AS_STRING(DESCR)

DECLARE_VDB_COLUMN_AS(INSDC_coord_zero, GAP_START)

DECLARE_VDB_COLUMN_AS(row_range_t, CONTIG_NAME_ROW_RANGE)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_START)

DECLARE_VDB_COLUMN_AS(uint32_t, ACC_VERSION)

DECLARE_VDB_COLUMN_AS_STRING(PUBLIC_COMMENT)

DECLARE_VDB_COLUMN_AS(NCBI_WGS_component_props, GAP_PROPS)

DECLARE_VDB_COLUMN_AS_STRING(NUC_PROT_DESCR)

DECLARE_VDB_COLUMN_AS_STRING(NAME)

pair< TVDBRowId, TVDBRowId > row_range_t

DECLARE_VDB_COLUMN_AS(INSDC_coord_len, TRIM_LEN)

DECLARE_VDB_COLUMN_AS(TVDBRowId, FEAT_ROW_END)

CRef< CSeq_data > Get4na(TSeqPos pos, TSeqPos len) const

TSeqPos Get4naLengthExact(TSeqPos pos, TSeqPos len, TSeqPos stop_2na_len, TSeqPos stop_gap_len) const

TSeqPos Get2naLengthExact(TSeqPos pos, TSeqPos len) const

CRef< CWGSDb_Impl::SAmbiguityInfo > m_AmbiguityInfo

CRef< CWGSDb_Impl::SSeqTableCursor > m_Seq

vector< Uint1 > GetAmbiguityBytes() const

SAmbiguityInfo * operator->() const

SAmbiguityAccess(CRef< CWGSDb_Impl::SAmbiguityInfo > &info, CWGSDb_Impl &db, const CRef< CWGSDb_Impl::SSeqTableCursor > &seq, TVDBRowId row_id)

CRef< CSeq_data > Get2na(TSeqPos pos, TSeqPos len) const

SAmbiguityAccess(const SAmbiguityAccess &)=delete

TSeqPos GetGapLengthExact(TSeqPos pos, TSeqPos len) const

void operator=(const SAmbiguityAccess &)=delete

CRef< CSeq_literal > literal

COpenRange< TSeqPos > range

const INSDC_coord_len * gaps_len

bool IsInGap(TSeqPos pos) const

TSeqPos GetGapLength(TSeqPos pos, TSeqPos len) const

const NCBI_WGS_component_props * gaps_props

TSeqPos GetFrom(void) const

const INSDC_coord_zero * gaps_start

TSeqPos GetDataLength(TSeqPos pos, TSeqPos len) const

const NCBI_WGS_gap_linkage * gaps_linkage

CRef< CID2S_Split_Info > split

void x_CreateProtSet(TVDBRowIdRange range)

void x_AddFeature(const CWGSFeatureIterator &it, CSeq_annot::TData::TFtable &dst)

void x_AddProducts(const vector< TVDBRowId > &product_row_ids)

void x_AddDescr(CTempString bytes)

SWGSCreateInfo(const CWGSDb &db)

void x_SetSplitVersion(TSplitVersion split_version)

void x_SetFlags(TFlags flags)

void x_SetSeq(CWGSProteinIterator &it)

void x_AddFeaturesSplit(TVDBRowIdRange range, vector< TVDBRowId > &product_row_ids)

CRef< CWGSAsnBinData > data

CBioseq_set & x_GetProtSet(void)

CRef< CID2S_Chunk > chunk

void x_AddFeatures(TVDBRowIdRange range, vector< TVDBRowId > &product_row_ids)

SWGSCreateInfo(const CWGSDb &db, EFromFlags, TFlags flags)

SWGSCreateInfo(const CWGSDb &db, EFromSplitVersion, TSplitVersion split_version)

TSplitVersion split_version

void x_AddFeaturesDirect(TVDBRowIdRange range, vector< TVDBRowId > &product_row_ids)

@ eFeatLocIdUninitialized

static const TSplitVersion kDefaultSplitVersion

void AddFeature(NCBI_WGS_feattype type, COpenRange< TSeqPos > range)

void AddFeatType(NCBI_WGS_feattype feat_type)

static bool ExpandRange(COpenRange< TSeqPos > &dst, COpenRange< TSeqPos > src)

void AddFeatRange(COpenRange< TSeqPos > range)

bitset< CSeqFeatData::e_MaxChoice > feat_types

vector< COpenRange< TSeqPos > > loc_ranges

void AddContent(CID2S_Chunk_Info &chunk, CSeq_id &feat_id)

void AddFeature(bool with_product, NCBI_WGS_feattype type, COpenRange< TSeqPos > range)

CRef< CID2S_Chunk_Info > CreateChunkInfo(int index, CWGSProteinIterator &prot_it, const vector< TVDBRowId > &product_row_ids, size_t product_index)

CRef< CID2S_Bioseq_Ids::C_E > seq_place

SWGSFeatChunkInfo(CSeq_id &main_id, CSeq_id &feat_id)

static DP_BlockInfo * blocks

#define INIT_VDB_COLUMN(name)

#define INIT_VDB_COLUMN_AS(name, type)

#define INIT_VDB_COLUMN_BACKUP(name, backup_name)

pair< TVDBRowId, TVDBRowCount > TVDBRowIdRange

#define INIT_OPTIONAL_VDB_COLUMN(name)

int32_t NCBI_WGS_gap_linkage

int16_t NCBI_WGS_component_props

@ NCBI_WGS_gap_linkage_evidence_paired_ends

@ NCBI_WGS_gap_linkage_linked

@ NCBI_WGS_gap_unknown_type

@ NCBI_WGS_gap_centromere

@ NCBI_WGS_gap_heterochromatin

static const char kMasterDescrMark[]

static const bool kRecoverGaps

static const size_t kProdPerChunk

static TTaxId s_GetTaxId(const CVDBValueFor< NCBI_taxid > &value)

#define DEFAULT_AMBIGUITY_CACHE_SIZE

void sx_SetSplitInterval(CID2S_Seq_loc &split_loc, CSeq_id &id, TSeqPos pos, TSeqPos end)

static CSafeStatic< TGlobalAmbiguityCache, SStaticGlobalAmbiguityCacheCallbacks > s_GlobalAmbiguityCache

static bool s_UseAmbiguity4na(void)

static void s_Convert_2na_to_4na(char *dst_4na, const char *src_2na, size_t base_count)

static bool sx_HasAmbiguity(const Uint1 *ptr, const Uint1 *end)

static void s_Set_4na_gap(vector< char > &dst_4na_vec, size_t offset, size_t len)

static int kAssignedDefaultSplitVersion

static CRef< CSeq_literal > sx_MakeGapLiteral(TSeqPos len, NCBI_WGS_component_props props, NCBI_WGS_gap_linkage gap_linkage)

static const size_t kMinFeatCountToSplit

static bool s_UseFull4naBlocks(void)

static void s_AddUserObjectType(const CSeqdesc &desc, set< string > &existing_uo_types)

static const TSeqPos kDataChunkSize

static CWGSSeqIterator::TIncludeFlags s_ToFlags(CWGSSeqIterator::EWithdrawn withdrawn)

static const size_t kFeatPerChunk

static const Uint1 * sx_FindAmbiguity(const Uint1 *ptr, const Uint1 *end)

static const TSeqPos kChunk2naSize

static void s_GetMinMax(const Uint1 *arr, size_t size, Uint1 &min_v, Uint1 &max_v)

static void s_Copy_4na(char *dst_4na, TSeqPos dst_offset, const char *src_4na, TSeqPos src_offset, size_t base_count)

static char s_ConvertBits_2na_to_4na_2nd(char bits_2na)

static size_t sx_Find_4na_Ambiguity(const char *ptr, size_t offset, size_t base_count)

void sx_SetSplitId(CID2S_Bioseq_Ids::C_E &split_id, CSeq_id &id)

void sx_AddAnnotBytes(CBioseq::TAnnot &annot_set, CTempString bytes)

static bool s_GetClipByQuality(void)

static const TSeqPos kMinDataSplitSize

static char s_ConvertBits_2na_to_4na(char bits_2na)

static bool kEnableSplitData

static void s_Set_4na(vector< char > &dst_4na_vec, size_t offset, INSDC_4na_bin amb)

static bool kEnableSplitProd

static Uint1 sx_Get_4na(const char *ptr, size_t offset)

static void sx_AddMasterDescr(const CWGSDb &db, SWGSCreateInfo &info, SWGSDb_Defs::TFlags flags)

int sx_StringToNonNegativeInt(const CTempString &str)

void sx_AddSplitIds(CID2S_Bioseq_Ids::Tdata &split_ids, const CBioseq::TId &ids)

static bool s_UseAmbiguityMask(void)

static const TSeqPos kMin2naSize

static bool sx_Is2na(Uint1 b)

bool sx_SetAccession(CSeq_id &id, CTempString accession)

static const char kSeq_descrFirstByte

static const TSeqPos kChunk4naSize

void sx_SetTag(CDbtag &tag, CTempString str)

static int s_GetDebugLevel(void)

static bool kEnableSplitQual

static const TSeqPos kAmbiguityBlockSize

int sx_GetStringId(CTempString str)

static void sx_Assign(vector< Value > &dst, const CVDBValueFor< Value > &src)

void sx_AddDescrBytes(CSeq_descr &descr, CTempString bytes)

static bool kEnableSplitFeat

NCBI_PARAM_DEF_EX(int, WGS, DEBUG, 0, eParam_NoThread, WGS_DEBUG)

static void sx_AddEvidence(CSeq_gap &gap, CLinkage_evidence::TType type)

static TGi s_ToGi(TVDBRowId gi, const char *method)

limited_resource_map< pair< string, TVDBRowId >, CRef< CWGSDb_Impl::SAmbiguityInfo >, size_t > TGlobalAmbiguityCache

static char s_ConvertBits_2na_to_4na_1st(char bits_2na)

static bool s_UseGapInfo(void)

static void s_SetAmbiguitiesPos(vector< char > &dst_4na_vec, TSeqPos pos, TSeqPos len, const vector< INSDC_coord_zero > &amb_pos, const vector< INSDC_4na_bin > &amb_4na)

static bool sx_HasMoreProducts(const CWGSDb &db, TVDBRowIdRange range, size_t count)

NCBI_DEFINE_ERR_SUBCODE_X(19)

DEFINE_STATIC_FAST_MUTEX(s_GlobalAmbiguityCacheMutex)

static void s_AddGiRange(CID2S_Seq_loc::TLoc_set &loc_set, CSeq_id::TGi gi_range_start, CSeq_id::TGi gi_range_stop)

static void s_SetGaps(vector< char > &dst_4na_vec, TSeqPos pos, TSeqPos len, CWGSSeqIterator::TWGSContigGapInfo gap_info)

static size_t s_GetAmbiguityCacheSize(void)

static const TSeqPos kQualChunkSize

static const TSeqPos kSplit2naSize

bool sx_SetVersion(CSeq_id &id, int version)

static void s_SetAmbiguitiesBlocks(vector< char > &dst_4na_vec, TSeqPos pos, TSeqPos len, const CWGSDb_Impl::SAmbiguityInfo::T4naBlocks &blocks)

static string s_GetUserObjectType(const CSeqdesc &desc)

void sx_AddSplitId(CID2S_Bioseq_Ids::Tdata &split_ids, CSeq_id &id)

NCBI_PARAM_DEF(bool, WGS, MASTER_DESCR, true)

static const TSeqPos kSplit4naSize

int sx_NewStringToNonNegativeInt(CTempString str)

static void s_Pack_4na(char *dst_packed_4na, const Uint1 *src_4na, size_t base_count)

NCBI_PARAM_DECL(int, WGS, DEBUG)

@ NCBI_gb_state_eWGSGenBankReplaced

@ NCBI_gb_state_eWGSGenBankMissing

@ NCBI_gb_state_eWGSGenBankLive

uint8_t INSDC_quality_phred

uint8_t NCBI_WGS_loc_strand

uint8_t NCBI_WGS_feattype

static wxAcceleratorEntry entries[3]

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