Guitar
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | List of all members
dtl::Diff< elem, sequence, comparator > Class Template Reference

#include <Diff.hpp>

Collaboration diagram for dtl::Diff< elem, sequence, comparator >:
Collaboration graph
[legend]

Public Member Functions

 Diff ()
 
 Diff (const sequence &a, const sequence &b)
 
 Diff (const sequence &a, const sequence &b, bool deletesFirst)
 
 Diff (const sequence &a, const sequence &b, const comparator &comp)
 
 Diff (const sequence &a, const sequence &b, bool deleteFirst, const comparator &comp)
 
 ~Diff ()
 
long long getEditDistance () const
 
Lcs< elem > getLcs () const
 
elemVec getLcsVec () const
 
Ses< elem > getSes () const
 
uniHunkVec getUniHunks () const
 
bool isHuge () const
 
void onHuge ()
 
void offHuge ()
 
bool isUnserious () const
 
void onUnserious ()
 
void offUnserious ()
 
void onOnlyEditDistance ()
 
bool hugeEnabled () const
 
void enableHuge ()
 
void disableHuge ()
 
bool trivialEnabled () const
 
void enableTrivial () const
 
void disableTrivial ()
 
void editDistanceOnlyEnabled ()
 
sequence uniPatch (const sequence &seq)
 
sequence patch (const sequence &seq) const
 
void compose ()
 
template<typename stream >
void printSES (stream &out) const
 
void printSES (ostream &out=cout) const
 
template<typename stream , template< typename SEET, typename STRT > class PT>
void printSES (stream &out) const
 
template<typename storedData , template< typename SEET, typename STRT > class ST>
void storeSES (storedData &sd) const
 
template<typename stream >
void printUnifiedFormat (stream &out) const
 
void printUnifiedFormat (ostream &out=cout) const
 
void composeUnifiedHunks ()
 

Static Public Member Functions

template<typename stream >
static void printSES (const Ses< elem > &s, stream &out)
 
static void printSES (const Ses< elem > &s, ostream &out=cout)
 
template<typename stream >
static void printUnifiedFormat (const uniHunkVec &hunks, stream &out)
 
static void printUnifiedFormat (const uniHunkVec &hunks, ostream &out=cout)
 
template<typename stream >
static Ses< elem > composeSesFromStream (stream &st)
 

Private Member Functions

 dtl_typedefs (elem, sequence) sequence A
 
void init ()
 
long long snake (const long long &k, const long long &above, const long long &below)
 
bool recordSequence (const editPathCordinates &v)
 
void recordOddSequence (long long idx, long long length, sequence_const_iter it, const edit_t et)
 
void joinSesVec (sesElemVec &s1, sesElemVec &s2) const
 
bool wasSwapped () const
 

Private Attributes

sequence B
 
size_t M
 
size_t N
 
size_t delta
 
size_t offset
 
long long * fp
 
long long editDistance
 
Lcs< elem > lcs
 
Ses< elem > ses
 
editPath path
 
editPathCordinates pathCordinates
 
bool swapped
 
bool huge
 
bool trivial
 
bool editDistanceOnly
 
uniHunkVec uniHunks
 
comparator cmp
 
long long ox
 
long long oy
 

Detailed Description

template<typename elem, typename sequence = vector< elem >, typename comparator = Compare< elem >>
class dtl::Diff< elem, sequence, comparator >

diff class template sequence must support random_access_iterator.

Constructor & Destructor Documentation

◆ Diff() [1/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::Diff ( )
inline

◆ Diff() [2/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::Diff ( const sequence &  a,
const sequence &  b 
)
inline

◆ Diff() [3/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::Diff ( const sequence &  a,
const sequence &  b,
bool  deletesFirst 
)
inline

◆ Diff() [4/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::Diff ( const sequence &  a,
const sequence &  b,
const comparator &  comp 
)
inline

◆ Diff() [5/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::Diff ( const sequence &  a,
const sequence &  b,
bool  deleteFirst,
const comparator &  comp 
)
inline

◆ ~Diff()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::~Diff ( )
inline

Member Function Documentation

◆ compose()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::compose ( )
inline

compose Longest Common Subsequence and Shortest Edit Script. The algorithm implemented here is based on "An O(NP) Sequence Comparison Algorithm" described by Sun Wu, Udi Manber and Gene Myers

◆ composeSesFromStream()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream >
static Ses< elem > dtl::Diff< elem, sequence, comparator >::composeSesFromStream ( stream &  st)
inlinestatic

compose ses from stream

◆ composeUnifiedHunks()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::composeUnifiedHunks ( )
inline

compose Unified Format Hunks from Shortest Edit Script

◆ disableHuge()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::disableHuge ( )
inline

◆ disableTrivial()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::disableTrivial ( )
inline

◆ dtl_typedefs()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
dtl::Diff< elem, sequence, comparator >::dtl_typedefs ( elem  ,
sequence   
)
private

◆ editDistanceOnlyEnabled()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::editDistanceOnlyEnabled ( )
inline

◆ enableHuge()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::enableHuge ( )
inline

◆ enableTrivial()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::enableTrivial ( ) const
inline

◆ getEditDistance()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long dtl::Diff< elem, sequence, comparator >::getEditDistance ( ) const
inline

◆ getLcs()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
Lcs< elem > dtl::Diff< elem, sequence, comparator >::getLcs ( ) const
inline

◆ getLcsVec()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
elemVec dtl::Diff< elem, sequence, comparator >::getLcsVec ( ) const
inline

◆ getSes()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
Ses< elem > dtl::Diff< elem, sequence, comparator >::getSes ( ) const
inline

◆ getUniHunks()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
uniHunkVec dtl::Diff< elem, sequence, comparator >::getUniHunks ( ) const
inline

◆ hugeEnabled()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::hugeEnabled ( ) const
inline

◆ init()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::init ( )
inlineprivate

initialize

◆ isHuge()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::isHuge ( ) const
inline

◆ isUnserious()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::isUnserious ( ) const
inline

◆ joinSesVec()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::joinSesVec ( sesElemVec &  s1,
sesElemVec &  s2 
) const
inlineprivate

join SES vectors

◆ offHuge()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::offHuge ( )
inline

◆ offUnserious()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::offUnserious ( )
inline

◆ onHuge()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::onHuge ( )
inline

◆ onOnlyEditDistance()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::onOnlyEditDistance ( )
inline

◆ onUnserious()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::onUnserious ( )
inline

◆ patch()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
sequence dtl::Diff< elem, sequence, comparator >::patch ( const sequence &  seq) const
inline

patching with Shortest Edit Script (SES)

◆ printSES() [1/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
static void dtl::Diff< elem, sequence, comparator >::printSES ( const Ses< elem > &  s,
ostream &  out = cout 
)
inlinestatic

◆ printSES() [2/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream >
static void dtl::Diff< elem, sequence, comparator >::printSES ( const Ses< elem > &  s,
stream &  out 
)
inlinestatic

print differences given an SES

◆ printSES() [3/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::printSES ( ostream &  out = cout) const
inline

◆ printSES() [4/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream >
void dtl::Diff< elem, sequence, comparator >::printSES ( stream &  out) const
inline

print difference between A and B as an SES

◆ printSES() [5/5]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream , template< typename SEET, typename STRT > class PT>
void dtl::Diff< elem, sequence, comparator >::printSES ( stream &  out) const
inline

print difference between A and B as an SES with custom printer

◆ printUnifiedFormat() [1/4]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
static void dtl::Diff< elem, sequence, comparator >::printUnifiedFormat ( const uniHunkVec &  hunks,
ostream &  out = cout 
)
inlinestatic

◆ printUnifiedFormat() [2/4]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream >
static void dtl::Diff< elem, sequence, comparator >::printUnifiedFormat ( const uniHunkVec &  hunks,
stream &  out 
)
inlinestatic

print unified format difference with given unified format hunks

◆ printUnifiedFormat() [3/4]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::printUnifiedFormat ( ostream &  out = cout) const
inline

◆ printUnifiedFormat() [4/4]

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename stream >
void dtl::Diff< elem, sequence, comparator >::printUnifiedFormat ( stream &  out) const
inline

print difference between A and B in the Unified Format

◆ recordOddSequence()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
void dtl::Diff< elem, sequence, comparator >::recordOddSequence ( long long  idx,
long long  length,
sequence_const_iter  it,
const edit_t  et 
)
inlineprivate

record odd sequence in SES

◆ recordSequence()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::recordSequence ( const editPathCordinates &  v)
inlineprivate

record SES and LCS

◆ snake()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long dtl::Diff< elem, sequence, comparator >::snake ( const long long &  k,
const long long &  above,
const long long &  below 
)
inlineprivate

search shortest path and record the path

◆ storeSES()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
template<typename storedData , template< typename SEET, typename STRT > class ST>
void dtl::Diff< elem, sequence, comparator >::storeSES ( storedData &  sd) const
inline

store difference between A and B as an SES with custom storage

◆ trivialEnabled()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::trivialEnabled ( ) const
inline

◆ uniPatch()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
sequence dtl::Diff< elem, sequence, comparator >::uniPatch ( const sequence &  seq)
inline

patching with Unified Format Hunks

◆ wasSwapped()

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::wasSwapped ( ) const
inlineprivate

check if the sequences have been swapped

Member Data Documentation

◆ B

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
sequence dtl::Diff< elem, sequence, comparator >::B
private

◆ cmp

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
comparator dtl::Diff< elem, sequence, comparator >::cmp
private

◆ delta

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
size_t dtl::Diff< elem, sequence, comparator >::delta
private

◆ editDistance

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long dtl::Diff< elem, sequence, comparator >::editDistance
private

◆ editDistanceOnly

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::editDistanceOnly
private

◆ fp

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long* dtl::Diff< elem, sequence, comparator >::fp
private

◆ huge

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::huge
private

◆ lcs

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
Lcs< elem > dtl::Diff< elem, sequence, comparator >::lcs
private

◆ M

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
size_t dtl::Diff< elem, sequence, comparator >::M
private

◆ N

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
size_t dtl::Diff< elem, sequence, comparator >::N
private

◆ offset

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
size_t dtl::Diff< elem, sequence, comparator >::offset
private

◆ ox

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long dtl::Diff< elem, sequence, comparator >::ox
private

◆ oy

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
long long dtl::Diff< elem, sequence, comparator >::oy
private

◆ path

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
editPath dtl::Diff< elem, sequence, comparator >::path
private

◆ pathCordinates

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
editPathCordinates dtl::Diff< elem, sequence, comparator >::pathCordinates
private

◆ ses

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
Ses< elem > dtl::Diff< elem, sequence, comparator >::ses
private

◆ swapped

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::swapped
private

◆ trivial

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
bool dtl::Diff< elem, sequence, comparator >::trivial
private

◆ uniHunks

template<typename elem , typename sequence = vector< elem >, typename comparator = Compare< elem >>
uniHunkVec dtl::Diff< elem, sequence, comparator >::uniHunks
private
The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.17