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

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

NCBI C++ ToolKit: src/objtools/readers/fasta.cpp Source File

<

TStack>

<

TObject>

c >=

&& c <=

;

c >=

&& c <=

;

c + (

-

);

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

list<string>& stringFlags,

: m_LineReader(&reader), m_MaskVec(0),

m_gapNmin(0), m_gap_Unknown_length(0),

m_fIdCheck(f_idcheck)

m_gapNmin(0), m_gap_Unknown_length(0),

m_fIdCheck(f_idcheck)

need_defline =

;

<<

(),

strmodified.append(

.data(),

.length());

next_line = strmodified;

need_defline =

;

(line.

()) {

(c ==

|| c ==

|| c ==

) {

}

(need_defline) {

need_defline =

;

strmodified.append(

.data(),

.length());

+

() +

,

bad_residue_positions );

<<

(),

ids = std::move(

.ids);

hasRange =

.has_range;

rangeStart =

.range_start;

rangeEnd =

.range_end;

seqTitles = std::move(

.titles);

denseg.

().push_back(new_id);

denseg.

().push_back(old_id);

denseg.

().push_back(range_start);

(range_start > range_end) {

denseg.

().push_back(range_start + 1 - range_end);

denseg.

().push_back(range_end + 1 - range_start);

(

pId : ids) {

(

.ids.empty()) {

<<

(),

<< h.

()

<<

<<

(),

has_range,

(defline_ids.empty()) {

kWarnTitleLength = 1000;

( lineInfo.

.length() > kWarnTitleLength ) {

<< lineInfo.

.length()

<<

<< kWarnTitleLength <<

,

().push_back(

);

good = 0, bad = 0;

(70));

bIsNuc = (

ambig_nuc = 0;

(

pos = 0; pos < len_to_check; ++pos) {

c = s[pos];

}

( c ==

) {

( ! bIgnoreHyphens ) {

}

(

(c) || (c >=

&& c <=

)) {

}

(c ==

) {

(bad >= good / 3 &&

(len_to_check > 3 || good == 0 || bad > good))

<<

,

kWarnPercentAmbiguous = 40;

percent_ambig = (good == 0)?100:((ambig_nuc * 100) / good);

( len_to_check > 3 && percent_ambig > kWarnPercentAmbiguous ) {

<< percent_ambig <<

<< kWarnPercentAmbiguous <<

,

s_len = s.

();

( ; pos < s_len && (c = s[pos]) !=

; ++pos) {

bIsNuc = (

bad_pos_line_num = -1;

vector<TSeqPos> bad_pos_vec;

bHyphensAreGaps =

bAllowLetterGaps =

bIgnorableHyphenSeen =

;

eCharType_NormalNonGap,

eCharType_MaskedNonGap,

eCharType_JustIgnore,

eCharType_HyphenToIgnoreAndWarn,

(

pos = 0; pos < s_len; ++pos) {

c = s[pos];

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

:

= (bIsNuc ? eCharType_Bad : eCharType_MaskedNonGap );

= ( bIsNuc && bAllowLetterGaps ?

eCharType_Gap : eCharType_NormalNonGap );

= ( bIsNuc && bAllowLetterGaps ?

eCharType_Gap : eCharType_MaskedNonGap );

bAllowLetterGaps ? eCharType_Gap :

eCharType_NormalNonGap);

bAllowLetterGaps ? eCharType_Gap :

eCharType_MaskedNonGap);

bHyphensAreGaps ? eCharType_Gap :

bHyphensIgnoreAndWarn ? eCharType_HyphenToIgnoreAndWarn :

eCharType_NormalNonGap );

:

:

:

:

:

:

eCharType_NormalNonGap:

eCharType_MaskedNonGap:

eCharType_Gap: {

pos2 = pos + 1;

( pos2 < s_len && s[pos2] == c ) {

eCharType_JustIgnore:

eCharType_HyphenToIgnoreAndWarn:

bIgnorableHyphenSeen =

;

eCharType_Comment:

( bad_pos_line_num < 0 ) {

bad_pos_vec.push_back(pos);

( bIgnorableHyphenSeen ) {

( bHyphensIgnoreAndWarn );

<<

(),

( ! bad_pos_vec.empty() ) {

+

() +

,

stringstream warn_strm;

warn_strm <<

<<

()

<<

;

((

== pos) || (

== pos + (*

()).length() && atStartOfLine)) {

& gap_linkage_evidence =

gap_linkage_evidence));

sRemainingLine = sRemainingLine.

(3);

( uNumDigits != sRemainingLine.

() &&

::

(sRemainingLine[uNumDigits]) )

( uGapSize <= 0 ) {

<<

(),

sRemainingLine = sRemainingLine.

(sDigits.

());

TModKeyValueMultiMap modKeyValueMultiMap;

( ! sRemainingLine.

() ) {

uOpenBracketPos = 0;

uPosOfEqualSign = sRemainingLine.

(

, uOpenBracketPos + 1);

uCloseBracketPos = sRemainingLine.

(

, uPosOfEqualSign + 1);

sRemainingLine.

(uOpenBracketPos + 1,

(uPosOfEqualSign - uOpenBracketPos - 1) ) );

sRemainingLine.

(uPosOfEqualSign + 1,

uCloseBracketPos - uPosOfEqualSign - 1) );

modKeyValueMultiMap.insert(

sRemainingLine = sRemainingLine.

(uCloseBracketPos + 1);

bConflictingGapTypes =

;

(

&& modKeyValueMultiMap.empty())

(rec.second.m_eType == *pGapType)

eLinkEvid = rec.second.m_eLinkEvid;

(TModKeyValueMultiMap, modKeyValue_it, modKeyValueMultiMap) {

& sKey = modKeyValue_it->first;

& sValue = modKeyValue_it->second;

( canonicalKey ==

) {

( pGapTypeInfo ) {

}

( eGapType != *pGapType ) {

bConflictingGapTypes =

;

<< sValue,

( canonicalKey ==

) {

vector<CTempString> arrLinkageEvidences;

(vector<CTempString>, link_evid_it, arrLinkageEvidences) {

( find_iter != linkage_evidence_to_value_map.

() ) {

setOfLinkageEvidence.

(

find_iter->second));

<< sValue,

,

<< sKey,

( bConflictingGapTypes ) {

<<

(),

( ! pGapType && ! setOfLinkageEvidence.

() ) {

( eLinkEvid ) {

( setOfLinkageEvidence.

() ) {

}

( setOfLinkageEvidence.

() > 1 ||

,

setOfLinkageEvidence.

();

( ! setOfLinkageEvidence.

() ) {

,

setOfLinkageEvidence.

();

( setOfLinkageEvidence.

() ) {

( setOfLinkageEvidence.

() == 1 &&

,

uPos, uGapSize, eIsKnown,

(), pGapType,

setOfLinkageEvidence ) );

vector<TSeqPos> badIndexes;

( ! badIndexes.empty() ) {

+

() +

,

gap_char(inst.

() ?

:

);

bHasSpecifiedGapType =

bHasSpecifiedLinkEvid =

( ! (*it)->m_setOfLinkageEvidence.empty() &&

( (*it)->m_setOfLinkageEvidence.size() > 1 ||

( bHasSpecifiedGapType || bHasSpecifiedLinkEvid )

,

((*it)->m_uPos > pos) {

new_data.append(

, pos, (*it)->m_uPos - pos);

pos = (*it)->m_uPos;

new_data.append((*it)->m_uLen, gap_char);

,

(

==0 ||

[0]->m_uPos > 0)

(

[

]->m_uLen == 0) {

gap_ds->SetLoc().SetNull();

gap_ds->SetLiteral().SetLength(

[

]->m_uLen);

(

[

]->m_pGapType || !

[

]->m_setOfLinkageEvidence.empty() ) {

& seq_gap = gap_ds->SetLiteral().SetSeq_data().SetGap();

( !

[

]->m_setOfLinkageEvidence.empty() ) {

[

]->m_setOfLinkageEvidence )

pNewLinkEvid->SetType( *link_evid_it );

vecLinkEvids.push_back(std::move(pNewLinkEvid));

delta_ext.

().push_back(std::move(gap_ds));

(next_start !=

[

]->m_uPos) {

(delta_ext.

().size() == 1) {

->SetLiteral().SetSeq_data());

pDesc->SetMolinfo().SetBiomol(biomol);

bioseq.

().Set().emplace_back(std::move(pDesc));

& seqInst = bioseq.

();

(find_if(beginSeqData, endSeqData, [](

c) {

(c==

|| c ==

); }) != endSeqData);

(find_if(beginSeqData, endSeqData, [](

c) {

(c==

|| c ==

); }) != endSeqData);

(hasT && !hasU) {

(hasU && !hasT) {

inst.SetMol(default_mol);

(inst.IsSetMol()) {

inst.SetMol(default_mol);

& sLineText,

kWarnNumNucCharsAtEnd = 20;

kWarnAminoAcidCharsAtEnd = 50;

length = sLineText.

();

last_pos_to_check_for_nuc = (sLineText.

() - kWarnNumNucCharsAtEnd);

( ; pos_to_check >= last_pos_to_check_for_nuc; --pos_to_check ) {

( pos_to_check < last_pos_to_check_for_nuc ) {

<< kWarnNumNucCharsAtEnd

<<

<<

,

last_pos_to_check_for_amino_acid =

( sLineText.

() - kWarnAminoAcidCharsAtEnd );

( ; pos_to_check >= last_pos_to_check_for_amino_acid; --pos_to_check ) {

ch = sLineText[pos_to_check];

( ( ch >=

&& ch <=

) || (ch >=

&& ch <=

) ) {

( pos_to_check < last_pos_to_check_for_amino_acid ) {

<< kWarnAminoAcidCharsAtEnd

<<

<<

,

( !entry->

()

(

(reference_row + 1, 2)))

,

}

(reference_row >= 0) {

vector<TSeqPos> lengths;

ids.push_back(

);

vector<TSeqPos>::const_iterator it(lengths.begin());

(++it; it != lengths.end(); ++it) {

<<

(),

vector<TBuilderRef> builders(rows);

(

!= reference_row) {

builders[

].Reset(

TBuilder(ids[reference_row], ids[

]));

& submap = it->second;

(rr_it2 == submap.

()) {

builders[

]->AddData(it->first, TBuilder::kContinued,

(it2 != submap.

() &&

== it2->first) {

(

!= reference_row) {

builders[

]->AddData(it->first, rr_it2->second,

builders[

]->AddData(it->first, rr_it2->second,

TBuilder::kContinued);

(

!= reference_row) {

annot_align.push_back(builders[

]->GetCompletedAlignment());

& submap = it->second;

(it2 != submap.

() &&

== it2->first) {

dss.push_back(it2->second);

(dss.size() >=

(rows) && old_len > 0);

dss.push_back(last_pos);

dss.push_back(last_pos + old_len);

annot.

().SetAlign().push_back(sa);

:

(reader,

, f_idcheck), m_Map(fasta_map)

( !

.is_open() ) {

( !

.is_open() ) {

( !

->AtEOF() ) {

(se->

()) {

( !

->AtEOF() ) {

(

&

: mods) {

(postponed_mods.begin(), postponed_mods.end(),

[](

& mod_name) { return CModHandler::GetCanonicalName(mod_name); });

& title,

processed_title = title;

(line_number, bioseq, processed_title, pMessageListener);

,

(!processed_title.empty()) {

pDesc->SetTitle() = processed_title;

bioseq.

().Set().push_back(std::move(pDesc));

& processed_title,

* pFirstID = bioseq.

();

idString = pFirstID->AsFastaString();

errorReporter(idString, line_number, pMessageListener);

logInfo =

processed_title = remainder;

it = mods.begin();

(it != mods.end()) {

mit->second.second.push_back(*it);

it = mods.

(it);

newString.reserve(sValue.

());

ch = sValue[ii];

newString.push_back(

(ch));

}

( ch ==

|| ch ==

) {

newString.push_back(

);

newString.push_back(ch);

m_eKnownSize(eKnownSize),

m_uLineNumber(uLineNumber),

m_pGapType(pGapType),

m_setOfLinkageEvidence(setOfLinkageEvidence)

(

& key_val : countToEvidenceMap) {

& input_evidence_set = key_val.second;

(

& evidence : input_evidence_set) {

(

& evidence : evidences) {

(_eSeverity),

(_uLineNum),

sSeqId, (_sFeature),

(_sQualName), (_sQualValue),

( ! pMessageListener && (_eSeverity) <=

) {

}

( ! pMessageListener || ! pMessageListener->

( *pLineExpt ) )

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

static const NStr::TNumToStringFlags kFlags

void transform(Container &c, UnaryFunction *op)

const SBadResiduePositions & GetBadResiduePositions(void) const THROWS_NONE

const CSeq_id * GetFirstId() const

void AddAndSplit(const CTempString &src, CSeq_data::E_Choice format, TSeqPos length, bool gaps_ok=false, bool allow_packing=true)

add a chunk of sequence, splitting it as necessary for the sake of compactness (isolating ambiguous p...

Helper class to build pairwise alignments, with double gaps automatically spliced out.

static TSeqPos ParseRange(const CTempString &s, TSeqPos &start, TSeqPos &end, ILineErrorListener *pMessageListener)

static size_t s_MaxGeneralTagLength

static size_t s_MaxAccessionLength

static void ParseDefline(const CTempString &defline, const SDeflineParseInfo &info, const TIgnoredProblems &ignoredErrors, TIds &ids, bool &hasRange, TSeqPos &rangeStart, TSeqPos &rangeEnd, TSeqTitles &seqTitles, ILineErrorListener *pMessageListener)

static size_t s_MaxLocalIDLength

bool CacheIdHandle(CSeq_id_Handle idh)

virtual CRef< CSeq_id > GenerateID(bool unique_id)

void SetGenerator(CSeqIdGenerator &generator)

void ParseDefLine(const TStr &s, ILineErrorListener *pMessageListener)

void ParseTitle(const SLineTextAndLoc &lineInfo, ILineErrorListener *pMessageListener=0)

SFastaFileMap::SFastaEntry m_MapEntry

void AssembleSeq(ILineErrorListener *pMessageListener)

CFastaMapper(ILineReader &reader, SFastaFileMap *fasta_map, TFlags flags, FIdCheck f_idcheck=CSeqIdCheck())

Base class for reading FASTA sequences.

@ eST_Lax

Implement historic behavior, risking false positives.

@ eST_Strict

Require 100% encodability of printable non-digits.

@ eST_Default

Be relatively strict, but still allow for typos.

static ESequenceType SequenceType(const char *str, unsigned length=0, ESTStrictness strictness=eST_Default)

Guess sequence type.

static void Apply(const CModHandler &mod_handler, CBioseq &bioseq, TSkippedMods &skipped_mods, FPostMessage fPostMessage=nullptr)

void SetExcludedMods(const vector< string > &excluded_mods)

static const string & GetCanonicalName(const TModEntry &mod_entry)

void SetIgnoredMods(const list< string > &ignored_mods)

list< CModData > TModList

void AddMods(const TModList &mods, EHandleExisting handle_existing, TModList &rejected_mods, FReportError fReportError=nullptr)

static CObjReaderLineException * Create(EDiagSev eSeverity, unsigned int uLine, const std::string &strMessage, EProblem eProblem=eProblem_GeneralParsingError, const std::string &strSeqId=string(""), const std::string &strFeatureName=string(""), const std::string &strQualifierName=string(""), const std::string &strQualifierValue=string(""), CObjReaderLineException::EErrCode eErrCode=eFormat, const TVecOfLines &vecOfOtherLines=TVecOfLines())

Please use this instead of the constructor because the ctor is protected.

@ eFormat

Some of these are pretty specialized.

Defines and provides stubs for a general interface to a variety of file readers.

static void xAddStringFlagsWithMap(const list< string > &stringFlags, const map< string, TReaderFlags > flagMap, TReaderFlags &baseFlags)

void SetCounter(TCount count)

TCount GetCounter(void) const

static const TGapTypeMap & GetNameToGapTypeInfoMap(void)

This is for if the user needs to get the gap-type string to SGapTypeInfo info directly (For example,...

ELinkEvid

indicates which linkage-evidences a given gap-type can accept, if any

@ eLinkEvid_UnspecifiedOnly

only the "unspecified" linkage-evidence is allowed

@ eLinkEvid_Forbidden

no linkage-evidence is allowed

@ eLinkEvid_Required

any linkage-evidence is allowed, and at least one is required

static const SGapTypeInfo * NameToGapTypeInfo(const CTempString &sName)

From a gap-type string, get the SGapTypeInfo, insensitive to case, etc.

static bool IsAa(EMol mol)

static void Validate(const CSeq_data &in_seq, vector< TSeqPos > *badIdx, TSeqPos uBeginIdx=0, TSeqPos uLength=0)

static TSeqPos Pack(CSeq_data *in_seq, TSeqPos uLength=ncbi::numeric_limits< TSeqPos >::max())

CTempPusher(TStack &s, const TValue &v)

TStack::value_type TValue

CRef< TObject > & m_pObj1

CRef< TObject > & m_pObj2

CTempRefSwap(CRef< TObject > &pObj1, CRef< TObject > &pObj2)

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

static bool HasMods(const CTempString &title)

static void Apply(const CTempString &title, TModList &mods, string &remainder)

CUser_object & AddField(const string &label, const string &value, EParseField parse=eParse_String)

add a data field to the user object that holds a given value

Callback interface to scan fasta file for entries.

virtual bool PutError(const ILineError &)=0

Store error in the container, and return true if error was stored fine, and return false if the calle...

@ eProblem_InvalidResidue

@ eProblem_IgnoredResidue

@ eProblem_ParsingModifiers

@ eProblem_UnexpectedAminoAcids

@ eProblem_ModifierFoundButNoneExpected

@ eProblem_UnexpectedNucResidues

@ eProblem_TooManyAmbiguousResidues

@ eProblem_UnrecognizedQualifierName

@ eProblem_NonPositiveLength

@ eProblem_ContradictoryModifiers

@ eProblem_ExpectedModifierMissing

@ eProblem_ExtraModifierFound

Abstract base class for lightweight line-by-line reading.

container_type::const_iterator const_iterator

const_iterator begin() const

const_iterator end() const

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator begin() const

ECharType

Porter's Stemming Algorithm.

static bool s_ASCII_IsUnAmbigNuc(unsigned char c)

bool s_ASCII_IsAmbigNuc(unsigned char c)

bool s_ASCII_IsUpper(unsigned char c)

unsigned char s_ASCII_MustBeLowerToUpper(unsigned char c)

CTempPusher< stack< CFastaReader::TFlags > > CFlagGuard

#define FASTA_WARNING(_uLineNum, _MessageStrmOps, _eProblem, _Feature)

#define FASTA_PROGRESS(_MessageStrmOps)

bool s_ASCII_IsLower(unsigned char c)

static void s_AppendMods(const CModHandler::TModList &mods, string &title)

#define FASTA_WARNING_EX(_uLineNum, _MessageStrmOps, _eProblem, _Feature, _sQualName, _sQualValue)

static bool sRefineNaMol(const char *beginSeqData, const char *endSeqData, CBioseq &bioseq)

bool s_ASCII_IsAlpha(unsigned char c)

#define FASTA_ERROR(_uLineNum, _MessageStrmOps, _eErrCode)

static void s_AddBiomol(CMolInfo::EBiomol biomol, CBioseq &bioseq)

Operators to edit gaps in sequences.

Helper class to build pairwise alignments, with double gaps automatically spliced out.

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

#define ITERATE_0_IDX(idx, up_to)

idx loops from 0 (inclusive) to up_to (exclusive)

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

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

#define LOG_POST_X(err_subcode, message)

#define DIAG_COMPILE_INFO

Make compile time diagnostic information object to use in CNcbiDiag and CException.

EDiagSev

Severity level for the posted diagnostics.

@ eDiag_Info

Informational message.

@ eDiag_Warning

Warning message.

void Warning(CExceptionArgs_Base &args)

#define NCBI_THROW2(exception_class, err_code, message, extra)

Throw exception with extra parameter.

#define ENUM_METHOD_NAME(EnumName)

virtual bool ParseGapLine(const TStr &s, ILineErrorListener *pMessageListener)

virtual void ParseTitle(const SLineTextAndLoc &lineInfo, ILineErrorListener *pMessageListener)

TFastaSeqIds all_seq_ids

List of all seq.ids.

TSeqTitles m_CurrentSeqTitles

bool TestFlag(EFlags flag) const

TSeqPos m_CurrentGapLength

void SetIgnoredMods(const list< string > &ignored_mods)

virtual bool IsValidLocalID(const TStr &s) const

const CSeqIdGenerator & GetIDGenerator(void) const

virtual void CheckDataLine(const TStr &s, ILineErrorListener *pMessageListener)

virtual CRef< CSeq_entry > ReadOneSeq(ILineErrorListener *pMessageListener=nullptr)

Read a single effective sequence, which may turn out to be a segmented set.

void SetGapLinkageEvidence(CSeq_gap::EType type, const set< int > &defaultEvidence, const map< TSeqPos, set< int >> &countToEvidenceMap)

virtual ~CFastaReader(void)

static size_t ParseRange(const TStr &s, TSeqPos &start, TSeqPos &end, ILineErrorListener *pMessageListener)

SGap::TNullableGapType m_gap_type

virtual CRef< CSerialObject > ReadObject(ILineReader &lr, ILineErrorListener *pErrors)

CReaderBase overrides.

std::string x_NucOrProt(void) const

void x_ApplyMods(const string &title, TSeqPos line_number, CBioseq &bioseq, ILineErrorListener *pMessageListener)

TFlags GetFlags(void) const

CRef< CSeq_entry > ReadSet(int max_seqs=kMax_Int, ILineErrorListener *pMessageListener=nullptr)

Read multiple sequences (by default, as many as are available.)

static string CanonicalizeString(const CTempString &sValue)

CSeqIdGenerator & SetIDGenerator(void)

static CRef< ILineReader > New(const string &filename)

Return a new ILineReader object corresponding to the given filename, taking "-" (but not "....

void SaveMasks(TMasks *masks)

long TFlags

binary OR of EFlags

virtual CRef< CSeq_entry > ReadSeqEntry(ILineReader &lr, ILineErrorListener *pErrors)

Read an object from a given line reader, render it as a single Seq-entry, if possible.

SGap::TLinkEvidSet m_DefaultLinkageEvidence

virtual void x_CloseMask(void)

virtual void UngetLine(void)=0

Unget current line, which must be valid.

virtual bool CreateWarningsForSeqDataInTitle(const TStr &sLineText, TSeqPos iLineNum, ILineErrorListener *pMessageListener) const

void SetGapLinkageEvidences(CSeq_gap::EType type, const set< int > &evidences)

CRef< CSeq_loc > SaveMask(void)

Directs the *following* call to ReadOneSeq to note the locations of lowercase letters.

CRef< CFastaIdHandler > m_IDHandler

SGap(TSeqPos pos, TSignedSeqPos len, EKnownSize eKnownSize, Uint8 uLineNumber, TNullableGapType pGapType=TNullableGapType(), const set< CLinkage_evidence::EType > &setOfLinkageEvidence=set< CLinkage_evidence::EType >())

TSeqPos m_gap_Unknown_length

CRef< CSeq_entry > x_ReadSeqsToAlign(TIds &ids, ILineErrorListener *pMessageListener)

static void AddStringFlags(const list< string > &stringFlags, TFlags &baseFlags)

virtual void AssembleSeq(ILineErrorListener *pMessageListener)

CRef< ILineReader > m_LineReader

void x_AddMultiwayAlignment(CSeq_annot &annot, const TIds &ids)

const CSeq_id & GetBestID(void) const

CBioseq::TId & SetIDs(void)

TSeqPos GetCurrentPos(EPosType pos_type)

const TPostponedModMap & GetPostponedModMap() const

void x_CheckForPostponedMods(const string &idString, TSeqPos line_number, CModHandler::TModList &mods)

TPostponedModMap m_PostponedModMap

virtual void PostProcessIDs(const CBioseq::TId &defline_ids, const string &defline, bool has_range=false, TSeqPos range_start=kInvalidSeqPos, TSeqPos range_end=kInvalidSeqPos)

CRef< CBioseq > m_CurrentSeq

virtual void EntryFound(CRef< CSeq_entry > se, CNcbiStreampos stream_position)=0

Callback function, called after reading the fasta entry.

void SetMinGaps(TSeqPos gapNmin, TSeqPos gap_Unknown_length)

vector< CRef< CSeq_id > > TIds

virtual void x_OpenMask(void)

bool xSetSeqMol(const list< CRef< CSeq_id >> &ids, CSeq_inst_Base::EMol &mol)

CRef< CSeq_entry > ReadAlignedSet(int reference_row, ILineErrorListener *pMessageListener=nullptr)

Read as many sequences as are available, and interpret them as an alignment, with hyphens marking rel...

void x_AddMods(TSeqPos line_number, CBioseq &bioseq, string &processed_title, ILineErrorListener *pMessageListener)

virtual void ParseDataLine(const TStr &s, ILineErrorListener *pMessageListener)

std::vector< ILineError::EProblem > m_ignorable

virtual void x_CloseGap(TSeqPos len, bool atStartOfLine, ILineErrorListener *pMessageListener)

CNcbiStreampos stream_offset

Molecule offset in file.

vector< ILineError::EProblem > TIgnoredProblems

void x_AddPairwiseAlignments(CSeq_annot &annot, const TIds &ids, TRowNum reference_row)

CRef< CSeq_align > xCreateAlignment(CRef< CSeq_id > old_id, CRef< CSeq_id > new_id, TSeqPos range_start, TSeqPos range_end)

void SetExcludedMods(const vector< string > &excluded_mods)

static void ParseDefLine(const TStr &defLine, const SDefLineParseInfo &info, const TIgnoredProblems &ignoredErrors, list< CRef< CSeq_id >> &ids, bool &hasRange, TSeqPos &rangeStart, TSeqPos &rangeEnd, TSeqTitles &seqTitles, ILineErrorListener *pMessageListener)

bool AtEOF(void) const

Indicates (negatively) whether there is any more input.

virtual bool AtEOF(void) const =0

Indicates (negatively) whether there is any more input.

void SetMaxIDLength(Uint4 max_len)

If this is set, an exception will be thrown if a Sequence ID exceeds the given length.

CFastaReader(ILineReader &reader, TFlags flags=0, FIdCheck f_idcheck=CSeqIdCheck())

void ScanFastaFile(IFastaEntryScan *scanner, CNcbiIfstream &input, CFastaReader::TFlags fread_flags)

Scan FASTA files, call IFastaEntryScan::EntryFound (payload function)

Uint8 LineNumber(void) const

Int8 StreamPosition(void) const

string seq_id

Primary sequence Id.

virtual char PeekChar(void) const =0

Returns the first character of the next string without consuming it.

CFastaDeflineReader::FIdCheck FIdCheck

void SetPostponedMods(const list< string > &postponed_mods)

virtual ~IFastaEntryScan()

void ReadFastaFileMap(SFastaFileMap *fasta_map, CNcbiIfstream &input)

Function reads input stream (assumed that it is FASTA format) one molecule entry after another fillin...

bool m_bModifiedMaxIdLength

virtual void AssignMolType(ILineErrorListener *pMessageListener)

string description

Molecule description.

void CloseGap(bool atStartOfLine=false, ILineErrorListener *pMessageListener=nullptr)

unordered_set< string > m_PostponedMods

ILineReader & GetLineReader(void)

void IgnoreProblem(ILineError::EProblem problem)

const CBioseq::TId & GetIDs(void) const

void x_SetDeflineParseInfo(SDefLineParseInfo &info)

vector< SLineTextAndLoc > TSeqTitles

TCountToLinkEvidMap m_GapsizeToLinkageEvidence

CRef< CSeq_entry > ReadFasta(CNcbiIstream &in, CFastaReader::TFlags flags, int *counter, CFastaReader::TMasks *lcv, ILineErrorListener *pMessageListener)

A const-correct replacement for the deprecated ReadFasta function.

virtual void GenerateID(void)

virtual void PostWarning(ILineErrorListener *pMessageListener, EDiagSev _eSeverity, size_t _uLineNum, CTempString _MessageStrmOps, CObjReaderParseException::EErrCode _eErrCode, ILineError::EProblem _eProblem, CTempString _sFeature, CTempString _sQualName, CTempString _sQualValue) const

@ fNoParseID

Generate an ID (whole defline -> title)

@ fQuickIDCheck

Just check local IDs' first characters.

@ fDLOptional

Don't require a leading defline.

@ fLaxGuess

Use legacy heuristic for guessing seq. type.

@ fHyphensIgnoreAndWarn

When a hyphen is encountered in seq data, ignore it but warn.

@ fRequireID

Reject deflines that lack IDs.

@ fSkipCheck

Skip (rudimentary) body content check.

@ fDisableNoResidues

If no residues found do not raise an error.

@ fUniqueIDs

Forbid duplicate IDs.

@ fLetterGaps

Parse runs of Ns when splitting data.

@ fIgnoreMods

Ignore mods entirely. Incompatible with fAddMods.

@ fAddMods

Parse defline mods and add to SeqEntry.

@ fNoUserObjs

Don't save raw deflines in User-objects.

@ fForceType

Force specified type regardless of accession.

@ fParseRawID

Try to identify raw accessions.

@ fNoSplit

Don't split out ambiguous sequence regions.

@ fUseIupacaa

If Prot, use iupacaa instead of the default ncbieaa.

@ fAssumeNuc

Assume nucs unless accns indicate otherwise.

@ fParseGaps

Make a delta sequence if gaps found.

@ fValidate

Check (alphabetic) residue validity.

@ fOneSeq

Just read the first sequence found.

@ fLeaveAsText

Don't reencode at all, just parse.

@ fAssumeProt

Assume prots unless accns indicate otherwise.

@ fNoSeqData

Parse the deflines but skip the data.

@ fStrictGuess

Assume no typos when guessing sequence type.

@ fDisableParseRange

No ranges in seq-ids. Ranges part of seq-id instead.

const string AsFastaString(void) const

EAccessionInfo

For IdentifyAccession (below)

static bool IsValidLocalID(const CTempString &s)

Perform rudimentary validation on potential local IDs, whose contents should be pure ASCII and limite...

static CSeq_id_Handle GetHandle(const CSeq_id &id)

Normal way of getting a handle, works for any seq-id.

string AsString(void) const

static int BestRank(const CRef< CSeq_id > &id)

void SetPacked_int(TPacked_int &v)

void SetNull(void)

Override all setters to incorporate cache invalidation.

CRef< C > Ref(C *object)

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

void Reset(void)

Reset reference object.

void Reset(void)

Reset reference object.

bool NotEmpty(void) const THROWS_NONE

Check if CRef is not empty – pointing to an object and has a non-null value.

void Swap(TThisType &ref)

Swaps the pointer with another reference.

bool IsNull(void) const THROWS_NONE

Check if pointer is null – same effect as Empty().

bool Empty(void) const THROWS_NONE

Check if CRef is empty – not pointing to any object, which means having a null value.

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 END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

IO_PREFIX::istream CNcbiIstream

Portable alias for istream.

IO_PREFIX::ifstream CNcbiIfstream

Portable alias for ifstream.

IO_PREFIX::streampos CNcbiStreampos

Portable alias for streampos.

NCBI_NS_STD::string::size_type SIZE_TYPE

static string PrintableString(const CTempString str, TPrintableMode mode=fNewLine_Quote|fNonAscii_Passthru)

Get a printable version of the specified string.

static CTempString TruncateSpaces_Unsafe(const CTempString str, ETrunc where=eTrunc_Both)

Truncate whitespace in a string.

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 void TruncateSpacesInPlace(string &str, ETrunc where=eTrunc_Both)

Truncate whitespace in a string (in-place)

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.

size_type length(void) const

Return the length of the represented array.

static unsigned int StringToUInt(const CTempString str, TStringToNumFlags flags=0, int base=10)

Convert string to unsigned int.

CTempString substr(size_type pos) const

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

TErrCode GetErrCode(void) const

Get error code.

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...

size_type size(void) const

Return the length of the represented array.

static const size_type npos

@ fConvErr_NoThrow

Do not throw an exception on error.

@ fSplit_MergeDelimiters

Merge adjacent delimiters.

@ eTrunc_Begin

Truncate leading whitespace only.

C::value_type FindBestChoice(const C &container, F score_func)

Find the best choice (lowest score) for values in a container.

void SetType(TType &value)

Assign a value to Type data member.

TLens & SetLens(void)

Assign a value to Lens data member.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

const TLens & GetLens(void) const

Get the Lens member data.

void SetDim(TDim value)

Assign a value to Dim data member.

vector< TSignedSeqPos > TStarts

void SetDim(TDim value)

Assign a value to Dim data member.

void SetType(TType value)

Assign a value to Type data member.

TStarts & SetStarts(void)

Assign a value to Starts data member.

TStrands & SetStrands(void)

Assign a value to Strands data member.

void SetNumseg(TNumseg value)

Assign a value to Numseg data member.

TIds & SetIds(void)

Assign a value to Ids data member.

@ eType_partial

mapping pieces together

TSet & SetSet(void)

Select the variant.

TAnnot & SetAnnot(void)

Assign a value to Annot data member.

const TSet & GetSet(void) const

Get the variant data.

bool IsSeq(void) const

Check if variant Seq is selected.

bool IsSet(void) const

Check if variant Set is selected.

const TSeq_set & GetSeq_set(void) const

Get the Seq_set member data.

TSeq & SetSeq(void)

Select the variant.

TSeq_set & SetSeq_set(void)

Assign a value to Seq_set data member.

void SetData(TData &value)

Assign a value to Data data member.

const TInst & GetInst(void) const

Get the Inst member data.

void SetExt(TExt &value)

Assign a value to Ext data member.

bool IsSetMol(void) const

Check if a value has been assigned to Mol data member.

E_Choice

Choice variants.

list< CRef< CSeq_align > > TAlign

void SetType(TType value)

Assign a value to Type data member.

bool IsSetInst(void) const

the sequence data Check if a value has been assigned to Inst data member.

Tdata & Set(void)

Assign a value to data member.

TLength GetLength(void) const

Get the Length member data.

list< CRef< CSeq_id > > TId

void SetInst(TInst &value)

Assign a value to Inst data member.

EMol

molecule class in living organism

void SetDescr(TDescr &value)

Assign a value to Descr data member.

TUser & SetUser(void)

Select the variant.

void SetRepr(TRepr value)

Assign a value to Repr data member.

const Tdata & Get(void) const

Get the member data.

void SetLength(TLength value)

Assign a value to Length 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.

list< CRef< CLinkage_evidence > > TLinkage_evidence

@ eRepr_delta

sequence made by changes (delta) to others

@ eRepr_raw

continuous sequence

@ eRepr_virtual

no seq data

@ e_Ncbieaa

extended ASCII 1 letter aa codes

@ e_Iupacna

IUPAC 1 letter nuc acid code.

@ e_Iupacaa

IUPAC 1 letter amino acid code.

@ eMol_not_set

> cdna = rna

@ eMol_na

just a nucleic acid

The blob sat and sat key Both must be positive integers</td > n< td > Non empty string The interpretation of the blob id depends on a processor Cassandra n processor expects the following format

constexpr auto front(list< Head, As... >, T=T()) noexcept -> Head

string_type::value_type char_type

The character type used by the parser.

double value_type

The numeric datatype used by the parser.

Useful/utility classes and methods.

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

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

#define FIELD_CHAIN_OF_2_IS_SET(Var, Fld1, Fld2)

FIELD_CHAIN_OF_2_IS_SET.

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

static SLJIT_INLINE sljit_ins lr(sljit_gpr dst, sljit_gpr src)

void AddBadIndexMap(const TBadIndexMap &additionalBadIndexMap)

void ConvertBadIndexesToString(CNcbiOstream &out, unsigned int maxRanges=1000) const

CConstRef< CSeq_id > m_SeqId

TBadIndexMap m_BadIndexMap

Holds information about a given gap-type string.

CSeq_gap::EType m_eType

The underlying type that the string corresponds to.

ELinkEvid m_eLinkEvid

Indicates what linkage-evidences are compatible with this.

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