ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-29 23:45:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove unused TextDiff

Browse Source
This commit is contained in:
Vinnie Falco
2014-03-03 18:50:56 -08:00
parent b9d0bf8822
commit a690690b53
6 changed files with 0 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/beast_core/beast_core.cpp
View File

@@ -182,7 +182,6 @@ namespace beast
#include "text/StringArray.cpp"
#include "text/StringPairArray.cpp"
#include "text/StringPool.cpp"
#include "text/TextDiff.cpp"
#include "thread/impl/TrackedMutex.cpp"
#include "thread/DeadlineTimer.cpp"

1
modules/beast_core/beast_core.h
View File

@@ -194,7 +194,6 @@ class FileOutputStream;
#include "text/LocalisedStrings.h"
#include "diagnostic/SemanticVersion.h"
#include "text/StringPool.h"
#include "text/TextDiff.h"
#include "threads/ChildProcess.h"
#include "threads/DynamicLibrary.h"
#include "threads/HighResolutionTimer.h"

232
modules/beast_core/text/TextDiff.cpp
View File

@@ -1,232 +0,0 @@
//------------------------------------------------------------------------------
/*
This file is part of Beast: https://github.com/vinniefalco/Beast
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
Portions of this file are from JUCE.
Copyright (c) 2013 - Raw Material Software Ltd.
Please visit http://www.juce.com
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
struct TextDiffHelpers
{
enum { minLengthToMatch = 3 };
struct StringRegion
{
StringRegion (const String& s) noexcept
: text (s.getCharPointer()), start (0), length (s.length()) {}
StringRegion (const String::CharPointerType t, int s, int len) noexcept
: text (t), start (s), length (len) {}
String::CharPointerType text;
int start, length;
};
static void addInsertion (TextDiff& td, const String::CharPointerType text, int index, int length)
{
TextDiff::Change c;
c.insertedText = String (text, (size_t) length);
c.start = index;
c.length = length;
td.changes.add (c);
}
static void addDeletion (TextDiff& td, int index, int length)
{
TextDiff::Change c;
c.start = index;
c.length = length;
td.changes.add (c);
}
static void diffSkippingCommonStart (TextDiff& td, const StringRegion& a, const StringRegion& b)
{
String::CharPointerType sa (a.text);
String::CharPointerType sb (b.text);
const int maxLen = bmax (a.length, b.length);
for (int i = 0; i < maxLen; ++i, ++sa, ++sb)
{
if (*sa != *sb)
{
diffRecursively (td, StringRegion (sa, a.start + i, a.length - i),
StringRegion (sb, b.start + i, b.length - i));
break;
}
}
}
static void diffRecursively (TextDiff& td, const StringRegion& a, const StringRegion& b)
{
int indexA, indexB;
const int len = findLongestCommonSubstring (a.text, a.length,
b.text, b.length,
indexA, indexB);
if (len >= minLengthToMatch)
{
if (indexA > 0 && indexB > 0)
diffSkippingCommonStart (td, StringRegion (a.text, a.start, indexA),
StringRegion (b.text, b.start, indexB));
else if (indexA > 0)
addDeletion (td, b.start, indexA);
else if (indexB > 0)
addInsertion (td, b.text, b.start, indexB);
diffRecursively (td, StringRegion (a.text + indexA + len, a.start + indexA + len, a.length - indexA - len),
StringRegion (b.text + indexB + len, b.start + indexB + len, b.length - indexB - len));
}
else
{
if (a.length > 0) addDeletion (td, b.start, a.length);
if (b.length > 0) addInsertion (td, b.text, b.start, b.length);
}
}
static int findLongestCommonSubstring (String::CharPointerType a, const int lenA,
const String::CharPointerType b, const int lenB,
int& indexInA, int& indexInB)
{
if (lenA == 0 || lenB == 0)
return 0;
HeapBlock<int> lines;
lines.calloc (2 + 2 * (size_t) lenB);
int* l0 = lines;
int* l1 = l0 + lenB + 1;
int bestLength = 0;
indexInA = indexInB = 0;
for (int i = 0; i < lenA; ++i)
{
const beast_wchar ca = a.getAndAdvance();
String::CharPointerType b2 (b);
for (int j = 0; j < lenB; ++j)
{
if (ca != b2.getAndAdvance())
{
l1[j + 1] = 0;
}
else
{
const int len = l0[j] + 1;
l1[j + 1] = len;
if (len > bestLength)
{
bestLength = len;
indexInA = i;
indexInB = j;
}
}
}
std::swap (l0, l1);
}
indexInA -= bestLength - 1;
indexInB -= bestLength - 1;
return bestLength;
}
};
TextDiff::TextDiff (const String& original, const String& target)
{
TextDiffHelpers::diffSkippingCommonStart (*this, original, target);
}
String TextDiff::appliedTo (String text) const
{
for (int i = 0; i < changes.size(); ++i)
text = changes.getReference(i).appliedTo (text);
return text;
}
bool TextDiff::Change::isDeletion() const noexcept
{
return insertedText.isEmpty();
}
String TextDiff::Change::appliedTo (const String& text) const noexcept
{
return text.substring (0, start) + (isDeletion() ? text.substring (start + length)
: (insertedText + text.substring (start)));
}
//==============================================================================
class DiffTests : public UnitTest
{
public:
DiffTests() : UnitTest ("TextDiff", "beast") {}
static String createString()
{
beast_wchar buffer[50] = { 0 };
Random r;
for (int i = r.nextInt (49); --i >= 0;)
{
if (r.nextInt (10) == 0)
{
do
{
buffer[i] = (beast_wchar) (1 + r.nextInt (0x10ffff - 1));
}
while (! CharPointer_UTF16::canRepresent (buffer[i]));
}
else
buffer[i] = (beast_wchar) ('a' + r.nextInt (3));
}
return CharPointer_UTF32 (buffer);
}
void testDiff (const String& a, const String& b)
{
TextDiff diff (a, b);
const String result (diff.appliedTo (a));
expectEquals (result, b);
}
void runTest()
{
beginTestCase ("TextDiff");
testDiff (String::empty, String::empty);
testDiff ("x", String::empty);
testDiff (String::empty, "x");
testDiff ("x", "x");
testDiff ("x", "y");
testDiff ("xxx", "x");
testDiff ("x", "xxx");
for (int i = 5000; --i >= 0;)
{
String s (createString());
testDiff (s, createString());
testDiff (s + createString(), s + createString());
}
}
};
static DiffTests diffTests;

75
modules/beast_core/text/TextDiff.h
View File

@@ -1,75 +0,0 @@
//------------------------------------------------------------------------------
/*
This file is part of Beast: https://github.com/vinniefalco/Beast
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
Portions of this file are from JUCE.
Copyright (c) 2013 - Raw Material Software Ltd.
Please visit http://www.juce.com
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef BEAST_TEXTDIFF_H_INCLUDED
#define BEAST_TEXTDIFF_H_INCLUDED
/**
Calculates and applies a sequence of changes to convert one text string into
another.
Once created, the TextDiff object contains an array of change objects, where
each change can be either an insertion or a deletion. When applied in order
to the original string, these changes will convert it to the target string.
*/
class BEAST_API TextDiff
{
public:
/** Creates a set of diffs for converting the original string into the target. */
TextDiff (const String& original,
const String& target);
/** Applies this sequence of changes to the original string, producing the
target string that was specified when generating them.
Obviously it only makes sense to call this function with the string that
was originally passed to the constructor. Any other input will produce an
undefined result.
*/
String appliedTo (String text) const;
/** Describes a change, which can be either an insertion or deletion. */
struct Change
{
String insertedText; /**< If this change is a deletion, this string will be empty; otherwise,
it'll be the text that should be inserted at the index specified by start. */
int start; /**< Specifies the character index in a string at which text should be inserted or deleted. */
int length; /**< If this change is a deletion, this specifies the number of characters to delete. For an
insertion, this is the length of the new text being inserted. */
/** Returns true if this change is a deletion, or false for an insertion. */
bool isDeletion() const noexcept;
/** Returns the result of applying this change to a string. */
String appliedTo (const String& original) const noexcept;
};
/** The list of changes required to perform the transformation.
Applying each of these, in order, to the original string will produce the target.
*/
Array<Change> changes;
};
#endif // BEAST_TEXTDIFF_H_INCLUDED