public Robot(IRobotConfiguration configuration, StartArgs startArgs, IPriceManagerBuilder priceManagerBuilder, IDiffer differ)
{
_configuration = configuration;
_startArgs = startArgs;
_priceManagerBuilder = priceManagerBuilder;
_differ = differ;
}
public InlineDiffBuilder(IDiffer differ)
{
if (differ == null)
throw new ArgumentNullException("differ");
this.differ = differ;
}
/// <summary>
/// Gets the side-by-side textual diffs.
/// </summary>
/// <param name="differ">The differ instance.</param>
/// <param name="oldText">The old text to diff.</param>
/// <param name="newText">The new text.</param>
/// <param name="ignoreWhiteSpace">true if ignore the white space; othewise, false.</param>
/// <param name="ignoreCase">true if case-insensitive; otherwise, false.</param>
/// <param name="lineChunker">The line chunker.</param>
/// <param name="wordChunker">The word chunker.</param>
/// <returns>The diffs result.</returns>
public static SideBySideDiffModel Diff(IDiffer differ, string oldText, string newText, bool ignoreWhiteSpace = true, bool ignoreCase = false, IChunker lineChunker = null, IChunker wordChunker = null)
{
if (oldText == null)
{
throw new ArgumentNullException(nameof(oldText));
}
if (newText == null)
{
throw new ArgumentNullException(nameof(newText));
}
if (differ == null)
{
return(Diff(oldText, newText, ignoreWhiteSpace, ignoreCase));
}
var model = new SideBySideDiffModel();
var diffResult = differ.CreateDiffs(oldText, newText, ignoreWhiteSpace, ignoreCase, lineChunker ?? LineChunker.Instance);
BuildDiffPieces(diffResult, model.OldText.Lines, model.NewText.Lines, (ot, nt, op, np, iw, ic) =>
{
var r = differ.CreateDiffs(ot, nt, iw, ic, wordChunker ?? WordChunker.Instance);
return(BuildDiffPieces(r, op, np, null, iw, ic));
}, ignoreWhiteSpace, ignoreCase);
return(model);
}
public void Update(IDiffer diff)
{
var diffToUpdate = _diffs.FirstOrDefault(d => d.Id == diff.Id);
diffToUpdate.Left = diff.Left;
diffToUpdate.Right = diff.Right;
}
public SideBySideDiffBuilder(IDiffer differ)
{
if (differ == null)
{
throw new ArgumentNullException("differ");
}
this.differ = differ;
}
public SideBySideDiffBuilder(IDiffer differ, char[] wordSeparators) : this(differ)
{
if (wordSeparators is null || wordSeparators.Length == 0)
{
throw new ArgumentException("wordSeparators cannot be null or empty.", nameof(wordSeparators));
}
WordSeparaters = wordSeparators;
}
public InlineDiffBuilder(IDiffer differ)
{
if (differ == null)
{
throw new ArgumentNullException(nameof(differ));
}
this.differ = differ;
}
public DiffPerfTester()
{
differ = new Differ();
Console.WriteLine("Max number of lines: {0}", MaxLines);
Console.WriteLine("Max length of lines: {0}", MaxLineLength);
Console.WriteLine("Max difference amount: {0}", DifferenceAmount);
Console.WriteLine();
sideBySideDiffer = new SideBySideDiffBuilder(differ);
}
public static DiffJson Clone(this IDiffer diffJson)
{
if (diffJson == null)
{
return(null);
}
return(new DiffJson(diffJson.Id)
{
Left = diffJson.Left, Right = diffJson.Right
});
}
/// <summary>
/// Initialize the data manager and the differ instances. This is called on each
/// action to ensure that if any error happens it gets caught by the global exception filter
/// </summary>
private void Initialize()
{
if (_dataManager == null)
{
_dataManager = new DataManager();
}
if (_differ == null)
{
_differ = new Differ();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GitHubDiffRetriever"/> class.
/// </summary>
/// <param name="differ">The <see cref="IDiffer"/> instance to use for loading diffs.</param>
/// <param name="diffFactory">
/// The <see cref="IGitDiffEntryFactory"/> instance to retrieve <see cref="GitDiffEntry"/> objects with.
/// </param>
public GitHubDiffRetriever(IDiffer differ, IGitDiffEntryFactory diffFactory)
{
if (differ == null)
{
throw new ArgumentNullException("differ");
}
if (diffFactory == null)
{
throw new ArgumentNullException("diffFactory");
}
this.differ = differ;
this.diffFactory = diffFactory;
}
/// <summary>
/// Gets the inline textual diffs.
/// </summary>
/// <param name="differ">The differ instance.</param>
/// <param name="oldText">The old text to diff.</param>
/// <param name="newText">The new text.</param>
/// <param name="ignoreWhiteSpace">true if ignore the white space; othewise, false.</param>
/// <param name="ignoreCase">true if case-insensitive; otherwise, false.</param>
/// <param name="chunker">The chunker.</param>
/// <returns>The diffs result.</returns>
public static DiffPaneModel Diff(IDiffer differ, string oldText, string newText, bool ignoreWhiteSpace = true, bool ignoreCase = false, IChunker chunker = null)
{
if (oldText == null)
{
throw new ArgumentNullException(nameof(oldText));
}
if (newText == null)
{
throw new ArgumentNullException(nameof(newText));
}
var model = new DiffPaneModel();
var diffResult = (differ ?? Differ.Instance).CreateDiffs(oldText, newText, ignoreWhiteSpace, ignoreCase, chunker ?? LineChunker.Instance);
BuildDiffPieces(diffResult, model.Lines);
return(model);
}
public static void MarkDifferenceForSection(Section minusSection, Section plusSection,
IMarkerRender markerRender, ITextSource doc,
IDiffer differ)
{
var minusText = doc.GetText(minusSection.Start, minusSection.LenWithEol);
var plusText = doc.GetText(plusSection.Start, plusSection.LenWithEol).Replace("\n+", "\n-");
if (plusText.StartsWith("+"))
{
plusText = "-" + plusText.Remove(0, 1);
}
var diffsForPlusSection = differ.GetDiffs(minusText, plusText);
var pos4Minus = minusSection.Start;
var pos4Plus = plusSection.Start;
foreach (var diff in diffsForPlusSection)
{
switch (diff.operation)
{
case Operation.EQUAL:
{
pos4Minus += diff.text.Length;
pos4Plus += diff.text.Length;
break;
}
case Operation.DELETE:
{
MarkRange(markerRender, pos4Minus, diff.text.Length, MinusLineMarkerColor);
pos4Minus += diff.text.Length;
break;
}
case Operation.INSERT:
{
MarkRange(markerRender, pos4Plus, diff.text.Length, PlusLineMarkerColor);
pos4Plus += diff.text.Length;
break;
}
}
}
}
public SideBySideDiffBuilder(IDiffer differ, IChunker lineChunker, IChunker wordChunker)
{
this.differ = differ ?? Differ.Instance;
this.lineChunker = lineChunker ?? throw new ArgumentNullException(nameof(lineChunker));
this.wordChunker = wordChunker ?? throw new ArgumentNullException(nameof(wordChunker));
}
public InlineDiffBuilder(IDiffer differ)
{
_differ = differ ?? throw new ArgumentNullException(nameof(differ));
}
public void Setup()
{
var kernel = new StandardKernel(new ObjectDifferModule());
_differ = kernel.Get<IDiffer>();
}
public SideBySideDiffBuilder(IDiffer differ)
{
this.differ = differ ?? throw new ArgumentNullException(nameof(differ));
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultTextMatcher"/> class.
/// </summary>
/// <param name="differ">The IDiffer implementation to use for determining which text replacements correspond with original text in ambiguous cases.</param>
/// <param name="chunker">The IChunker to be used with the differ.</param>
public DefaultTextMatcher(IDiffer differ, IChunker chunker)
{
_chunker = chunker ?? throw new ArgumentNullException(nameof(chunker));
_differ = differ ?? throw new ArgumentNullException(nameof(differ));
}
private static DiffPaneModel GetDiff(IDiffer differ, string oldText, string newText)
{
var inlineBuilder = new InlineDiffBuilder(differ);
return inlineBuilder.BuildDiffModel(oldText, newText);
}
public EventStoreApi(IEventStorage <TDiff> eventStorage, IDiffer <TData, TDiff> differ)
{
_eventStorage = eventStorage;
_differ = differ;
}
public SideBySideDiffBuilder(IDiffer differ = null) :
this(differ, new LineChunker(), new WordChunker())
{
}
public Client(
TRemoteState initialRemoteState,
IReadOnlyDictionary <int, TLocalState> localStatesByTick,
IDiffer <TLocalState> localStateDiffer,
IDiffer <TRemoteState> remoteStateDiffer,
EndPoint localEndPoint,
EndPoint remoteEndPoint,
TimeSpan sendInterval
)
{
if (!remoteStatesByTick.TryAdd(0, initialRemoteState))
{
throw new InvalidOperationException("Could not add initial tick.");
}
connection = new Connection(
localEndPoint,
remoteEndPoint,
(buffer, index, size) => {
using (var reader = new BinaryReader(new MemoryStream(buffer, index, size, writable: false))) {
totalBytesReceived += size;
AckedLocalTick = reader.ReadInt32();
int oldRemoteTick = reader.ReadInt32();
int newRemoteTick = reader.ReadInt32();
//Console.WriteLine($"Received: ackedLocalTick = {ackedLocalTick}, oldRemoteTick = {oldRemoteTick}, newRemoteTick = {newRemoteTick}, ackingRemoteTick = {ackingRemoteTick}");
// only patch remote state if newer
if (AckingRemoteTick < newRemoteTick)
{
var remoteState = remoteStatesByTick[oldRemoteTick];
remoteStateDiffer.Patch(ref remoteState, reader);
if (!remoteStatesByTick.TryAdd(newRemoteTick, remoteState))
{
throw new InvalidOperationException($"Could not add new tick {newRemoteTick}.");
}
AckingRemoteTick = newRemoteTick;
}
}
});
sendThread = new Thread(() => {
var memoryStream = new MemoryStream();
FixedTimer(_ => {
if (!Connected)
{
return;
}
using (var writer = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true)) {
writer.SetOffset(0);
writer.Write(AckingRemoteTick);
TLocalState ackedLocalState;
TLocalState localState;
bool ticked;
lock (localTickMutex) {
writer.Write(AckedLocalTick);
writer.Write(localTick);
//Console.WriteLine($"Sending: ackingRemoteTick = {ackingRemoteTick}, ackedLocalTick = {ackedLocalTick}, localTick = {localTick}");
ticked = AckedLocalTick < localTick;
ackedLocalState = localStatesByTick[AckedLocalTick];
localState = localStatesByTick[localTick];
}
if (ticked)
{
localStateDiffer.Diff(ackedLocalState, localState, writer);
}
if (memoryStream.Position > int.MaxValue)
{
throw new OverflowException();
}
connection.SendMessage(memoryStream.GetBuffer(), 0, writer.GetOffset());
totalBytesSent += writer.GetOffset();
}
}, sendInterval, cancellationTokenSource.Token);
});
sendThread.Start();
}
public void Add(IDiffer diff)
{
_diffs.Add(diff.Clone());
}
public InlineDiffBuilder(IDiffer differ = null)
{
this.differ = differ ?? Differ.Instance;
}
public SideBySideDiffBuilder(IDiffer differ, char[] wordSeparators)
: this(differ, new LineChunker(), new DelimiterChunker(wordSeparators))
{
}
public void Setup()
{
_differ = GetDiffer(false);
}
public void Setup()
{
var kernel = new StandardKernel(new ObjectDifferModule());
_differ = kernel.Get <IDiffer>();
}
/// <summary>
/// Constructor intended for unit test
/// </summary>
/// <param name="dataManager">Data manager to be injected</param>
/// <param name="differ">Class used to perform the actual diffs</param>
public DiffController(IDataManager dataManager, IDiffer differ)
{
_dataManager = dataManager;
_differ = differ;
}
public DiffController()
{
//configuring controller with repository and diff algorithm implementations
_diffObjectRepository = Container.DiffObjectRepository;
_differ = Container.Differ;
}
public Detector(MailConfiguration mailConfiguration)
{
_emailReporter = new EmailReporter(mailConfiguration);
_differ = new Differ();
_sideBySideDiffBuilder = new SideBySideDiffBuilder(_differ);
}
public SideBySideDiffBuilder2(IDiffer differ)
{
if (differ == null) throw new ArgumentNullException("differ");
this.differ = differ;
}
private static DiffPaneModel GetDiff(IDiffer differ, string oldText, string newText)
{
var inlineBuilder = new InlineDiffBuilder(differ);
return(inlineBuilder.BuildDiffModel(oldText, newText));
}
public DictionaryDiffer(IDiffer <TKey> keyDiffer, IDiffer <TValue> valueDiffer)
{
this.keyDiffer = keyDiffer;
this.valueDiffer = valueDiffer;
}
public void Setup()
{
_differ = GetDiffer(false);
}
