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

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

NCBI C++ ToolKit: src/util/diff/diff.cpp Source File

m_Length(

.length())

(it->GetOperation()) {

len_insert += it->GetString().length();

len_delete += it->GetString().length();

edit_distance +=

(len_insert, len_delete);

edit_distance +=

(len_insert, len_delete);

TList::const_iterator max_pos = diffs.end();

(

> max_len) {

(!max_len || max_pos == diffs.end()) {

max_pos->GetString();

(it->GetString().length() != it->GetLength()) {

);

(it->GetOperation()) {

off_second += it->GetLength();

off_first += it->GetLength();

off_first += it->GetLength();

off_second += it->GetLength();

count_delete = 0;

count_insert = 0;

CDiffList::TList::iterator this_diff =

.begin();

CDiffList::TList::iterator ins_diff =

.end();

CDiffList::TList::iterator del_diff =

.end();

CDiffList::TList::iterator equal_diff =

.end();

(this_diff !=

.end()) {

& current = this_diff->GetString();

(this_diff->GetOperation()) {

this_diff =

.erase(this_diff);

ins_diff = this_diff++;

this_diff =

.erase(this_diff);

del_diff = this_diff++;

(count_delete + count_insert >= 1) {

(count_delete != 0 && count_insert != 0) {

(common_prefix_len) {

(equal_diff ==

.end()) {

ins_str = ins_str.

(common_prefix_len);

del_str = del_str.

(common_prefix_len);

(common_suffix_len) {

this_diff->SetString(

ins_str = ins_str.

(0, ins_str.

() - common_suffix_len);

del_str = del_str.

(0, del_str.

() - common_suffix_len);

(common_prefix_len || common_suffix_len) {

ins_diff->SetString(ins_str);

del_diff->SetString(del_str);

equal_diff = this_diff++;

(equal_diff ==

.end()) {

equal_diff = this_diff++;

this_diff =

.erase(this_diff);

(

.size() < 3) {

CDiffList::TList::iterator next_diff =

.begin();

CDiffList::TList::iterator prev_diff = next_diff++;

CDiffList::TList::iterator this_diff = next_diff++;

changes =

;

(next_diff !=

.end()) {

(prev_diff->GetOperation() ==

&&

prev_diff->SetString(

this_diff->SetString(

next_diff =

.erase(next_diff);

(next_diff ==

.end()) {

next_diff = this_diff;

next_diff->SetString(

this_diff->SetString(

prev_diff = this_diff;

this_diff = next_diff;

unique_ptr<CDeadline> real_deadline;

(common_prefix_len) {

common_prefix = s1.

(0, common_prefix_len);

s1 = s1.

(common_prefix_len);

s2 = s2.

(common_prefix_len);

(common_suffix_len) {

common_suffix = s1.

(s1.

() - common_suffix_len);

(common_prefix_len) {

(common_suffix_len) {

(!hm1_res && !hm2_res) {

}

(!hm1_res) {

}

(!hm2_res) {

hm = hm1[4].length() > hm2[4].length() ? hm1 : hm2;

((j = short_str.

(

, j + 1)) !=

) {

(best_common.

() < suffix_len + prefix_len) {

best_common = short_str.

(j - suffix_len, suffix_len + prefix_len);

best_longtext_a = long_str.

(0,

- suffix_len);

best_longtext_b = long_str.

(

+ prefix_len);

best_shorttext_a = short_str.

(0, j - suffix_len);

best_shorttext_b = short_str.

(j + prefix_len);

(best_common.

() * 2 >= long_str.

()) {

hm[0] = best_longtext_a;

hm[1] = best_longtext_b;

hm[2] = best_shorttext_a;

hm[3] = best_shorttext_b;

max_d = (s1_len + s2_len + 1) / 2;

v_offset = max_d;

v_length = 2 * max_d;

*v1 =

[v_length];

*

=

[v_length];

(

x = 0; x < v_length; x++) {

v1[v_offset + 1] = 0;

[v_offset + 1] = 0;

= s1_len - s2_len;

(

d = 0; d < max_d; d++)

(

k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {

k1_offset = v_offset + k1;

(k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {

x1 = v1[k1_offset + 1];

x1 = v1[k1_offset - 1] + 1;

(x1 < s1_len && y1 < s2_len && s1[x1] == s2[y1]) {

}

(y1 > s2_len) {

}

(

) {

k2_offset = v_offset +

- k1;

(k2_offset >= 0 && k2_offset < v_length &&

[k2_offset] != -1) {

x2 = s1_len -

[k2_offset];

(

k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {

k2_offset = v_offset + k2;

(k2 == -d || (k2 != d &&

[k2_offset - 1] <

[k2_offset + 1])) {

x2 =

[k2_offset + 1];

x2 =

[k2_offset - 1] + 1;

(x2 < s1_len && y2 < s2_len &&

s1[s1_len - x2 - 1] == s2[s2_len - y2 - 1]) {

}

(y2 > s2_len) {

}

(!

) {

k1_offset = v_offset +

- k2;

(k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {

x1 = v1[k1_offset];

y1 = v_offset + x1 - k1_offset;

(short_str.

() == 1) {

(hm[0], hm[2], diffs_a);

(hm[1], hm[3], diffs_b);

unique_ptr<CDeadline> real_deadline;

vector<CTempString> lines;

s1_num_lines = lines.size();

s2_num_lines = lines.size() - s1_num_lines;

s = lines[

];

(

!= s1_num_lines-1 &&

!= lines.size()-1) {

vector<size_type> TSequence;

TSequence idx1(s1_num_lines);

TSequence idx2(s2_num_lines);

TStringToLineNumMap::const_iterator it;

s = lines[

];

(

< s1_num_lines-1) {

idx1[

] = it->second;

TStringToLineNumMap::const_iterator it;

s = lines[pos];

(

< s2_num_lines-1) {

idx2[

] = it->second;

(s1_num_lines > 10000 && s2_num_lines > 10000) {

vector< pair<size_type, dtl::elemInfo> > ses_seq = d.

().getSequence();

vector< pair<size_type, dtl::elemInfo> >::iterator it;

(it = ses_seq.begin(); it != ses_seq.end(); it++)

is_last_line =

;

= pos2 - s1_num_lines + 1;

is_last_line = (

>= s2_num_lines);

is_last_line = (

>= s1_num_lines);

= pos2 - s1_num_lines + 1;

is_last_line = (

>= s2_num_lines);

(s[

-1] ==

) {

insertions.push_back(op);

deletions.push_back(op);

(!deletions.empty()) {

(!insertions.empty()) {

(!deletions.empty()) {

(!insertions.empty()) {

(pos1 == s1_num_lines);

(pos2 == lines.size());

CDiffList::TList::const_iterator start_iter,

CDiffList::TList::const_iterator end_iter,

eol =

;

n1 = 0;

n2 = 0;

CDiffList::TList::const_iterator it = start_iter;

(it != end_iter)

(it->GetOperation()) {

<<

<< (

long)hunk_s1 <<

<< n1 <<

<< (

)hunk_s2 <<

<< n2 <<

<< eol;

(it != end_iter)

(it->GetOperation()) {

<< op << it->GetString() << eol;

num_common_lines)

(!

.good()) {

(diffs.empty()) {

CDiffList::TList::const_iterator it = diffs.begin();

CDiffList::TList::const_iterator hunk_start = diffs.end();

CDiffList::TList::const_iterator hunk_end = diffs.end();

is_hunk =

;

num_equal = 0;

(it != diffs.end()) {

(it->GetOperation()) {

(!num_common_lines || !num_equal) {

(num_common_lines == 0) {

}

(!num_equal) {

}

(num_equal <= num_common_lines) {

}

(num_equal < num_common_lines) {

:

;

@ eEmpty

no filtering at all.

CDiffList – the list of diff operations.

CDiffOperation – The storage class for one diff operation.

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

diff class template sequence must support random_access_iterator.

void compose()

compose Longest Common Subsequence and Shortest Edit Script.

Ses< elem > getSes() const

unordered_map< string, CDiffList::size_type > TStringToLineNumMap

CNcbiOstream & s_PrintUnifiedHunk(CNcbiOstream &out, CDiffList::TList::const_iterator start_iter, CDiffList::TList::const_iterator end_iter, CDiffList::size_type hunk_s1, CDiffList::size_type hunk_s2)

API to diff strings/texts and to find the differences.

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

main entry point for tests

static char line1[1024 *16]

static char line2[1024 *16]

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

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void CalculateOffsets(void)

Calculate offsets for all substrings in the difference list and find its position from the start of t...

CDeadline * m_Deadline

Deadline for processing (NULL if not set)

void x_DiffBisect(CTempString s1, CTempString s2, CDiffList &diffs) const

Find the 'middle snake' of a diff, split the problem in two and return the recursively constructed di...

void Prepend(CDiffOperation::EType operation, CTempString str)

Add element to the front of the list.

bool x_DiffHalfMatch(CTempString s1, CTempString s2, TDiffHalfMatchList &hm) const

Do the two texts share a substring which is at least half the length of the longer text?...

unsigned int TFlags

Bitwise OR of "Flags".

void CleanupAndMerge(void)

Reorder and merge like edit sections, merge equalities.

CDiffList & Diff(CTempString text1, CTempString text2, TFlags flags=0)

Find the differences between two texts (line mode).

virtual const char * GetErrCodeString(void) const override

Get error code interpreted as text.

unsigned int TFlags

Bitwise OR of "EFlags".

bool x_CleanupAndMerge_SingleEdits(void)

Look for single edits surrounded on both sides by equalities which can be shifted sideways to elimina...

CTempString GetLongestCommonSubstring(void) const

Find the longest common substring for current difference list.

void x_CleanupAndMerge_Equities(void)

Merge adjacent parts with the same operation.

void Reset(void)

Reset internal state and prepare to next Diff()

bool x_DiffHalfMatchI(CTempString long_str, CTempString short_str, size_type i, TDiffHalfMatchList &hm) const

Does a substring of short string exist within long string such that the substring is at least half th...

void x_DiffBisectSplit(CTempString s1, CTempString s2, int x, int y, CDiffList &diffs) const

Given the location of the 'middle snake', split the diff in two parts and recurse.

void Append(CDiffOperation::EType operation, CTempString str)

Add element to the end of the list.

vector< CTempString > TDiffHalfMatchList

Five element array for the list of strings, returned by x_DiffHalfMatch()

bool IsTimeoutExpired() const

Check if timeout is expired.

CDiffList m_Diffs

The list of differences from the last diff.

list< CDiffOperation > TList

Storage class type for the list of diff operations.

CDiffList & Diff(CTempString s1, CTempString s2, TFlags flags=0)

Find the differences between two texts (character mode).

void x_Diff(CTempString s1, CTempString s2, CDiffList &diffs) const

Find the differences between two texts.

CDiffOperation::size_type size_type

Size type definition.

size_type GetEditDistance(void) const

Compute the edit distance (Levenshtein distance).

TList m_List

List of the differences.

CDiffOperation::size_type size_type

Type definition.

EType

Type of the current diff operation.

CDiffOperation(EType operation, CTempString str)

Constructor.

CTimeout m_Timeout

Relative timeout for processing.

const TList & GetList(void) const

Get list of the diff operations as list<>.

void SetLength(size_type length)

CNcbiOstream & PrintUnifiedDiff(CNcbiOstream &out, CTempString text1, CTempString text2, unsigned int num_common_lines=3)

Find the differences between two texts and print result into output stream in unified-like format.

@ fCalculateOffsets

Automatically call CalculateOffests() for the generated list of differences.

@ fNoCleanup

By default Diff() automatically call CleanupAndMerge() for the generated list of differences to have ...

@ fCleanup

Automatically call CleanupAndMerge() for the generated list of differences after Diff() to have a sho...

@ fCalculateOffsets

Automatically call CalculateOffests() for the generated list of differences.

@ fIgnoreEOL

Ignore differences in end-of-line types on string comparison.

@ fRemoveEOL

Remove end-of-line symbols from each string added to the list, which can be obtained using CDiffOpera...

TErrCode GetErrCode(void) const

Get error code.

#define NCBI_THROW(exception_class, err_code, message)

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

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ostream CNcbiOstream

Portable alias for ostream.

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 bool EndsWith(const CTempString str, const CTempString end, ECase use_case=eCase)

Check if a string ends with a specified suffix value.

static SIZE_TYPE CommonSuffixSize(const CTempString s1, const CTempString s2)

Determine the common suffix of two strings.

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.

size_type length(void) const

Return the length of the represented array.

CTempString substr(size_type pos) const

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

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 SIZE_TYPE CommonPrefixSize(const CTempString s1, const CTempString s2)

Determine the common prefix of two strings.

operation

Bit operations.

virtual void Reset(void)

Reset the whole object.

unsigned int

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

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

int edit_t

type of edit for SES

double value_type

The numeric datatype used by the parser.

The NCBI C++/STL use hints.

Int4 delta(size_t dimension_, const Int4 *score_)

Structure to save offset/length in the compared strings.

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