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

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

NCBI C++ ToolKit: src/algo/sequence/restriction.cpp Source File

stable_sort(enzymes.begin(), enzymes.end(),

());

(enzyme != enzymes.begin() &&

enzyme->GetSpecs() ==

.back().GetSpecs()) {

.back().SetName() +=

;

.back().SetName() += enzyme->GetName();

.push_back(*enzyme);

.back().SetPrototype();

os <<

<<

.GetStart() <<

<<

.GetEnd() << endl;

os <<

;

os <<

;

plus_cut, minus_cut;

string::size_type idx = s.find_first_of(

);

(idx == std::string::npos) {

runtime_error(

(

)

(s[s.length() - 1] ==

) {

string::size_type idx = s.find_last_of(

);

(idx == std::string::npos) {

runtime_error(

(

)

(

= 0;

< s.length();

++) {

(s[

] ==

) {

string::size_type idx = s.find_first_not_of(

);

(idx == string::npos) {

idx = s.find_last_not_of(

);

vector<string> site_vec;

(vector<string>, iter, site_vec) {

TRebaseData::GetDefault();

(

.size() != 2) {

runtime_error(

(

)

TEnzymes::size_type prototype_idx(0);

(getline(

, line)) {

vector<string> fields;

(fields.size() < 2) {

is_prototype(

);

is_prototype =

;

sites = fields[3];

enzymes.push_back(enzyme);

prototype_idx = enzymes.size();

}

(prototype_idx) {

& prototype = enzymes[prototype_idx - 1];

(

pattern,

enzyme_index,

spec_index,

lhs->GetEnzymeName() < rhs->GetEnzymeName();

lhs.GetName() < rhs.GetName();

lhs->GetDefiniteSites().size() < rhs->GetDefiniteSites().size();

(pos == s.size()) {

orig_ch = s[pos];

(

x = 1; x <= 8; x <<= 1) {

(! refile.empty()) {

ifstream istr(refile.c_str());

converter.

(scope);

definite =

)

feat->

().SetRsite().SetDb().SetDb(

);

feat->

().SetRsite().SetDb()

.SetTag().SetStr(

);

vector< CRef<CSeq_loc> > locs;

recog_site->

().SetFrom(

->GetStart());

recog_site->

().SetTo (

->GetEnd());

recog_site->

().SetStrand(

->GetStrand());

recog_site->

(

);

locs.push_back(recog_site);

negative_cut_locs = 0;

cut_site->

().SetPoint(*cut);

cut_site->

().SetStrand(cut_strand);

cut_site->

(

);

locs.push_back(cut_site);

(vector<int>, cut,

->GetMinusCuts()) {

cut_site->

().SetPoint(*cut);

cut_site->

(

);

locs.push_back(cut_site);

(negative_cut_locs > 0) {

+

;

(locs.begin(), locs.end(),

back_inserter(feat->

().SetMix().Set()));

annot.

().SetFtable().push_back(feat);

vector<CRef<CREnzResult> > TResults;

vector<CRSite>& definite_sites =

(*result)->GetDefiniteSites();

vector<CRSite>& possible_sites =

(*result)->GetPossibleSites();

count_definite_sites = definite_sites.size();

count_possible_sites = possible_sites.size();

(count_definite_sites || count_possible_sites) {

total_definite_sites += count_definite_sites;

total_possible_sites += count_possible_sites;

title(

);

new_annot->

().Set().push_back(region);

annot.push_back(new_annot);

**

, curr_annot, scope, loc);

**

, curr_annot, scope, loc,

);

(

<< total_definite_sites <<

<< total_possible_sites <<

);

ambig_table[16] = {

0, 0, 0, 1, 0, 1, 1, 1,

0, 1, 1, 1, 1, 1, 1, 1

ambig_table[(size_t)

];

<

Seq>

.reserve(enzymes.size());

enzyme->IsPrototype())) {

vector<CRSpec>& specs = enzyme->GetSpecs();

(vector<CRSpec>, spec, specs) {

fsm_pat_size = pat.find_first_of(0x0f);

pos = pat.find_first_of(0x0f, fsm_pat_size + 1);

|| pat.find_first_of(0x0f, pos + 1) ==

) {

fsm_pat_size = pat.size();

spec - specs.begin(),

fsm_pat_size = comp.find_first_of(0x0f);

pos = comp.find_first_of(0x0f, fsm_pat_size + 1);

|| comp.find_first_of(0x0f, pos + 1) ==

) {

fsm_pat_size = comp.size();

spec - specs.begin(),

vector<TSeqPos> ambig_nucs;

ambig_nucs.push_back(

);

(end_pos >= seq.size()) {

(

= begin_pos;

<= end_pos;

vector<int>& plus_cuts = spec.

();

(vector<int>, cut, plus_cuts) {

.SetPlusCuts().push_back(begin_pos + *cut);

(vector<int>, cut, minus_cuts) {

.SetMinusCuts().push_back(begin_pos + *cut);

(!ambig_nucs.empty()) {

& pat = pattern->GetPattern();

pat_size = pattern->GetPatternSize();

ds_pos =

[pattern->GetEnzymeIndex()]

->GetDefiniteSites().size();

ps_pos =

[pattern->GetEnzymeIndex()]

->GetPossibleSites().size();

(vector<TSeqPos>, pos, ambig_nucs) {

begin_check =

(begin_check, 0);

begin_check =

(begin_check, next_pos);

end_check =

(*pos, (

) (seq.size() - pat_size));

(

= begin_check;

<= end_check;

++) {

.SetStrand(pattern->GetStrand());

vector<int>& plus_cuts

= enzymes[pattern->GetEnzymeIndex()]

.GetSpecs()[pattern->GetSpecIndex()].GetPlusCuts();

(vector<int>, cut, plus_cuts) {

.push_back(

+ pattern->GetPatternSize()

.SetPlusCuts().push_back(

+ *cut);

vector<int>& minus_cuts

= enzymes[pattern->GetEnzymeIndex()]

.GetSpecs()[pattern->GetSpecIndex()]

(vector<int>, cut, minus_cuts) {

.push_back(

+ pattern->GetPatternSize()

.SetMinusCuts().push_back(

+ *cut);

[pattern->GetEnzymeIndex()]

->SetDefiniteSites().push_back(

);

[pattern->GetEnzymeIndex()]

->SetPossibleSites().push_back(

);

vector<CRSite>& def_sites =

[pattern->GetEnzymeIndex()]

->SetDefiniteSites();

inplace_merge(def_sites.begin(),

def_sites.begin() + ds_pos,

vector<CRSite>& pos_sites =

[pattern->GetEnzymeIndex()]

->SetPossibleSites();

inplace_merge(pos_sites.begin(),

pos_sites.begin() + ps_pos,

User-defined methods of the data storage class.

User-defined methods of the data storage class.

bool IsReverse(ENa_strand s)

ENa_strand Reverse(ENa_strand s)

User-defined methods of the data storage class.

static void x_AddPattern(const string &pat, CTextFsm< size_t > &fsm, size_t match_value)

static bool x_IsAmbig(char nuc)

friend void x_FindRSite(const Seq &seq, const TEnzymes &enzymes, vector< CRef< CREnzResult > > &results, CFindRSites::TFlags)

Find all definite and possible sites in a sequence for a vector of enzymes, using a finite state mach...

const TEnzymes & GetEnzymes()

void x_LoadREnzymeData(const string &refile, CRebase::EEnzymesToLoad which_enzymes)

CREnzyme::TEnzymes TEnzymes

CFindRSites(const string &refile=kEmptyStr, CRebase::EEnzymesToLoad which_enzymes=CRebase::eAll, TFlags flags=fDefault)

@ fFindIsoschizomers

Lump together all enzymes with identical specificities.

static void Find(const string &seq, const TEnzymes &enzymes, vector< CRef< CREnzResult > > &results, TFlags flags=0)

static void x_ExpandRecursion(string &s, unsigned int pos, CTextFsm< size_t > &fsm, size_t match_value)

TAnnot GetAnnot(CScope &scope, const CSeq_loc &loc) const

TSeqPos GetFsmPatSize(void) const

size_t GetSpecIndex(void) const

size_t GetEnzymeIndex(void) const

TSeqPos GetPatternSize(void) const

const string & GetPattern(void) const

CPatternRec(string pattern, size_t enzyme_index, size_t spec_index, ENa_strand strand, TSeqPos fsm_pat_size)

ENa_strand GetStrand(void) const

This class represents the results of a search for sites of a particular enzyme.

const vector< CRSite > & GetPossibleSites(void) const

const vector< CRSite > & GetDefiniteSites(void) const

const string & GetEnzymeName(void) const

This class represents a restriction enzyme (an enzyme name and a vector of cleavage specificities)

void SetName(const string &s)

const string & GetName(void) const

static void CombineIsoschizomers(TEnzymes &enzymes)

vector< string > & SetIsoschizomers(void)

vector< CREnzyme > TEnzymes

vector< CRSpec > & SetSpecs(void)

const vector< CRSpec > & GetSpecs(void) const

void SetPrototype(const string &s=kEmptyStr)

This class represents a particular occurrence of a restriction site on a sequence (not to be confused...

This class represents a restriction enzyme specificity, i.e., a sequence recognition pattern and vect...

bool operator<(const CRSpec &rhs) const

const string & GetSeq(void) const

void SetSeq(const string &s)

vector< int > m_MinusCuts

const vector< int > & GetPlusCuts(void) const

const vector< int > & GetMinusCuts(void) const

vector< int > & SetPlusCuts(void)

vector< int > & SetMinusCuts(void)

static CRSpec MakeRSpec(const string &site)

CREnzyme::TEnzymes TEnzymes

static string GetDefaultDataPath()

static void x_ParseCutPair(const string &s, int &plus_cut, int &minus_cut)

static CREnzyme MakeREnzyme(const string &name, const string &sites)

static void ReadNARFormat(istream &input, TEnzymes &enzymes, enum EEnzymesToLoad which)

static char IupacToNcbi8na(char in)

stuff for dealing with ncbi8na.

static EMatch MatchNcbi8na(const Seq &seq, const Pat &pat, TSeqPos pos)

static void CompNcbi8na(string &seq8na)

complement an ncbi8na sequence in place

void SetNameDesc(const string &name)

void SetCreateDate(const CTime &dt)

void SetTitleDesc(const string &title)

namespace ncbi::objects::

Include a standard set of the NCBI C++ Toolkit most basic headers.

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

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.

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

CConstRef< CSeq_id > GetSeqId(void) const

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Override Assign() to incorporate cache invalidation.

void SetId(CSeq_id &id)

set the 'id' field in all parts of this location

const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)

If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...

CConstRef< CSeq_loc > m_ParentLoc

CRef< CSeq_loc > Resolve(CScope *scope=0, TFlags flags=0) const

@ fNoMerge

don't merge adjacent intervals

CScope & GetScope(void) const

Get scope this handle belongs to.

@ eCoding_Ncbi

Set coding to binary coding (Ncbi4na or Ncbistdaa)

void GetSeqData(TSeqPos start, TSeqPos stop, string &buffer) const

Fill the buffer string with the sequence data for the interval [start, stop).

void SetNcbiCoding(void)

Set coding to either Ncbi8aa or Ncbi8na depending on molecule type.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

void AddWord(const string &word, const MatchType &match)

int GetNextState(int state, char letter) const

const vector< MatchType > & GetMatches(int state) const

bool IsMatchFound(int state) const

int GetInitialState(void) const

NCBI_NS_STD::string::size_type SIZE_TYPE

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

Convert string to int.

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 string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

@ fSplit_Tokenize

All delimiters are merged and trimmed, to get non-empty tokens only.

@ eCurrent

Use current time. See also CCurrentTime.

@ eLim_tl

space to left of position

void SetLocation(TLocation &value)

Assign a value to Location data member.

void SetComment(const TComment &value)

Assign a value to Comment data member.

const TLocation & GetLocation(void) const

Get the Location member data.

void SetData(TData &value)

Assign a value to Data data member.

ENa_strand

strand of nucleic acid

@ eNa_strand_both

in forward orientation

void SetData(TData &value)

Assign a value to Data data member.

void SetDesc(TDesc &value)

Assign a value to Desc data member.

TRegion & SetRegion(void)

Select the variant.

constexpr auto sort(_Init &&init)

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

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)

NCBI_PARAM_DECL(string, RESTRICTION_SITES, REBASE)

ostream & operator<<(ostream &os, const CRSite &site)

typedef NCBI_PARAM_TYPE(RESTRICTION_SITES, REBASE) TRebaseData

NCBI_PARAM_DEF(string, RESTRICTION_SITES, REBASE, "")

void x_FindRSite(const Seq &seq, const CFindRSites::TEnzymes &enzymes, vector< CRef< CREnzResult > > &results, CFindRSites::TFlags flags)

Find all definite and possible sites in a sequence for a vector of enzymes, using a finite state mach...

static CRef< CSeq_loc > s_RemapChildToParent(const CSeq_loc &parent, const CSeq_loc &child, CScope *scope)

static void s_AddSitesToAnnot(const vector< CRSite > &sites, const CREnzResult &result, CSeq_annot &annot, CScope &scope, const CSeq_loc &parent_loc, bool definite=true)

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

bool operator()(const CRSite &lhs, const CRSite &rhs) const

bool operator()(const CREnzyme &lhs, const CREnzyme &rhs)

Location relative to a base Seq-loc: one (usually) or more ranges of offsets.

static bool ambig(char c)

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