public async Task Batch_pipeline_one_input_accumulate_to_one_output()
{
var result = new List <string>();
var head = new HeadBlock <string>();
head.Process((ct, str, md) => Task.FromResult(str + "A"))
.Batch(3)
.Process((ct, str, md) => Task.FromResult(string.Join(",", str)))
.Action((ct, str, md) =>
{
result.Add(str);
return(Task.CompletedTask);
});
var cts = new CancellationTokenSource();
await head.PushAsync(cts.Token, "C", new PipelineMetadata()).ConfigureAwait(false);
await head.PushAsync(cts.Token, "C", new PipelineMetadata()).ConfigureAwait(false);
await head.PushAsync(cts.Token, "C", new PipelineMetadata()).ConfigureAwait(false);
// this one will be lost because of the batching
await head.PushAsync(cts.Token, "C", new PipelineMetadata()).ConfigureAwait(false);
await head.FlushAsync(cts.Token).ConfigureAwait(false);
result.Count.Should().Be(2);
result[0].Should().Be("CA,CA,CA");
result[1].Should().Be("CA");
}
public async Task Decision_pipeline_one_input_different_outputs()
{
var result = string.Empty;
var head = new HeadBlock <string>();
var positive = new HeadBlock <string>();
var negative = new HeadBlock <string>();
head.Process((ct, str, md) => Task.FromResult(str + "A"))
.Decision((ct, str, md) =>
Task.FromResult(str == "AA"), positive, negative);
positive
.Process((ct, str, md) => Task.FromResult(str + "B"))
.Action((ct, str, md) => Task.FromResult(result = str));
negative
.Process((ct, str, md) => Task.FromResult(str + "C"))
.Action((ct, str, md) => Task.FromResult(result = str));
var cts = new CancellationTokenSource();
await head.PushAsync(cts.Token, "A", new PipelineMetadata()).ConfigureAwait(false);
result.Should().Be("AAB");
await head.PushAsync(cts.Token, "B", new PipelineMetadata()).ConfigureAwait(false);
result.Should().Be("BAC");
}
public async Task Distribute_pipeline_one_input_two_outputs()
{
var result1 = string.Empty;
var result2 = string.Empty;
var head = new HeadBlock <string>();
var branch1 = new HeadBlock <string>();
var branch2 = new HeadBlock <string>();
head.Process((ct, str, md) => Task.FromResult(str + "A"))
.Process((ct, str, md) => Task.FromResult(str + "-"))
.Distribute(branch1, branch2);
branch1
.Process((ct, str, md) => Task.FromResult(str + "B"))
.Action((ct, str, md) => Task.FromResult(result1 = str));
branch2
.Process((ct, str, md) => Task.FromResult(str + "C"))
.Action((ct, str, md) => Task.FromResult(result2 = str));
var cts = new CancellationTokenSource();
await head.PushAsync(cts.Token, string.Empty, new PipelineMetadata()).ConfigureAwait(false);
result1.Should().Be("A-B");
result2.Should().Be("A-C");
}
public void VerifyChain()
{
if(HeadBlock == null)
{
throw new InvalidOperationException("Genesis block not set");
}
bool isValid = HeadBlock.IsValidChain(null, true);
}
public void VerifyChain()
{
if (HeadBlock == null)
{
throw new InvalidOperationException("Genesis block not set.");
}
var isValid = HeadBlock.IsValidChain(null, true);
Console.WriteLine(isValid ? "Blockchain integrity intact." : "Blockchain integrity NOT intact.");
}
public void VerifyChain()
{
if (HeadBlock == null)
throw new InvalidOperationException("Genesis block not set");
bool isValid = HeadBlock.IsValidChain(null, true);
if (isValid)
Console.WriteLine("Blockchain integrity intact.");
else
Console.WriteLine("Blockchainintegrity NOT intact");
}
private void ExplodeContent()
{
this.Order.Root = Element.Root();
var Exploder = new ElementExploder(this.Order);
foreach (Element HeadBlock in this.Order.Content)
{
HeadBlock.Explode(Exploder);
this.Order.Root.Content.Add(HeadBlock);
HeadBlock.Parent = this.Order.Root;
}
}
/// <summary>
/// Right-align a range of headword blocks.
/// </summary>
/// <param name="blocks">The full headword blocks list.</param>
/// <param name="start">Index of the first character to right-align.</param>
/// <param name="length">Lengt of range to right-align.</param>
/// <param name="right">The right edge.</param>
private static void doRightAlign(List <HeadBlock> blocks,
int start, int length, float right)
{
float x = right;
for (int i = start + length - 1; i >= start; --i)
{
HeadBlock block = blocks[i];
block.Loc = new PointF(x - block.Size.Width, block.Loc.Y);
x -= block.Size.Width;
}
}
public async Task Head_with_only_pipeline_should_execute_all_blocks()
{
var result = string.Empty;
var head = new HeadBlock <string>();
head.Process((ct, str, md) => Task.FromResult(str + "A"))
.Process((ct, str, md) => Task.FromResult(str + "B"))
.Process((ct, str, md) => Task.FromResult(str + "C"))
.Action((ct, str, md) => Task.FromResult(result = str));
var cts = new CancellationTokenSource().Token;
await head.PushAsync(cts, string.Empty, new PipelineMetadata()).ConfigureAwait(false);
result.Should().Be("ABC");
}
private void ChooseFolderButton_Click(object sender, RoutedEventArgs e)
{
// Create a FolderBrowserDialog object to enable the user to
// select a folder.
FolderBrowserDialog dlg = new FolderBrowserDialog
{
ShowNewFolderButton = false
};
// Set the selected path to the common Sample Pictures folder
// if it exists.
string initialDirectory = System.IO.Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonPictures),
"Sample Pictures");
if (Directory.Exists(initialDirectory))
{
dlg.SelectedPath = initialDirectory;
}
// Show the dialog and process the dataflow network.
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
// Create a new CancellationTokenSource object to enable
// cancellation.
CancellationTokenSource = new CancellationTokenSource();
// Create the image processing network if needed.
if (HeadBlock == null)
{
HeadBlock = ImageProcessingNetwork.CreateImageProcessingNetwork(CancellationTokenSource);
}
// Post the selected path to the network.
HeadBlock.Post(dlg.SelectedPath);
// Enable the Cancel button and disable the Choose Folder button.
ChooseFolderButton.IsEnabled = false;
CancelButton.IsEnabled = true;
// Show a wait cursor.
Cursor = Cursors.Wait;
}
}
/// <summary>
/// Calculates right-aligned layout in headword area.
/// </summary>
private static bool doAnalyzeHanzi(Graphics g, string str, bool isSimp, StringFormat sf,
List <HeadBlock> blocks, ref PointF loc, float right)
{
byte fntZhoHead = isSimp ? fntZhoHeadSimp : fntZhoHeadTrad;
float left = loc.X;
bool lineBreak = false;
int firstCharOfLine = 0;
int charsOnLine = 0;
// Measure and position each character
for (int i = 0; i != str.Length; ++i)
{
++charsOnLine;
// Measure each character. They may not all be hanzi: there are latin letters in some HWS
HeadBlock hb = new HeadBlock
{
Char = str[i],
Size = HanziRenderer.MeasureChar(g, Magic.ZhoContentFontFamily, str[i], Magic.ZhoResultFontSize),
//Size = g.MeasureString(cstr, getFont(fntZhoHead), 65535, sf),
Loc = loc,
Faded = false,
};
blocks.Add(hb);
// Location moves right
loc.X += hb.Size.Width;
// If location is beyond headword's right edge, break line now.
// This involves
// - moving last added block to next line
// - right-aligning blocks added so far
if (loc.X > right)
{
lineBreak = true;
loc.X = left;
loc.Y += ideoLineHeight;
doRightAlign(blocks, firstCharOfLine, charsOnLine - 1, right);
charsOnLine = 1;
firstCharOfLine = blocks.Count - 1;
hb.Loc = loc;
loc.X += hb.Size.Width;
}
}
// Right-align the final bit
doRightAlign(blocks, firstCharOfLine, charsOnLine, right);
// Done - tell call if we had line break or not
return(lineBreak);
}
public bool VerifyChain()
{
if (HeadBlock == null)
{
return(false);
}
bool isValid = HeadBlock.IsValidChain(null, true);
if (isValid)
{
return(true);
}
else
{
return(false);
}
}
public void VerifyChain()
{
if (HeadBlock == null)
{
throw new InvalidOperationException();
}
bool isValid = HeadBlock.IsValidChain(null, true);
if (isValid)
{
Console.WriteLine("Blockchain integrity intack.");
}
else
{
Console.WriteLine("Blockchain integrity NOT intack. ");
}
}
public async Task Head_without_pipeline_should_await_start()
{
var result = 0;
var head = new HeadBlock <int>(async(token, func) =>
{
for (var i = 0; i < 4; i++)
{
await func(token, i, new PipelineMetadata());
result += i;
}
});
var cts = new CancellationTokenSource().Token;
await head.Start(cts).ConfigureAwait(false);
result.Should().Be(6);
}
public void VerifyChain()
{
if (HeadBlock == null)
{
throw new InvalidOperationException("Genesis block is not set");
}
bool isValid = HeadBlock.IsValidChain(null, true);
if (isValid)
{
Console.WriteLine("Block chain integrity intact");
}
else
{
Console.WriteLine("Blockchain is not valid. Data has been tampered");
}
}
public async Task Decision_pipeline_has_only_negative_branch()
{
var result = string.Empty;
var head = new HeadBlock <string>();
var negative = new HeadBlock <string>();
head.Process((ct, str, md) => Task.FromResult(str + "A"))
.Decision((ct, str, md) => Task.FromResult(str == "A-"), null, negative);
negative
.Process((ct, str, md) => Task.FromResult(str + "B"))
.Action((ct, str, md) => Task.FromResult(result = str));
var cts = new CancellationTokenSource();
await head.PushAsync(cts.Token, "A", new PipelineMetadata());
result.Should().Be("AAB");
}
public async Task Head_with_generator_should_await_blocks_when_have_one()
{
var result = 0;
var head = new HeadBlock <int>(async(token, func) =>
{
for (var i = 0; i < 4; i++)
{
await func(token, i, new PipelineMetadata());
}
});
head.Action((ct, i, md) => Task.FromResult(result += i));
var cts = new CancellationTokenSource().Token;
await head.Start(cts);
result.Should().Be(6);
}
/// <summary>
/// Calculates right-aligned layout in headword area.
/// </summary>
private static bool doAnalyzeHanzi(Graphics g, string str, bool isSimp, StringFormat sf,
List<HeadBlock> blocks, ref PointF loc, float right)
{
byte fntZhoHead = isSimp ? fntZhoHeadSimp : fntZhoHeadTrad;
float left = loc.X;
bool lineBreak = false;
int firstCharOfLine = 0;
int charsOnLine = 0;
// Measure and position each character
for (int i = 0; i != str.Length; ++i)
{
++charsOnLine;
// Measure each character. They may not all be hanzi: there are latin letters in some HWS
HeadBlock hb = new HeadBlock
{
Char = str[i],
Size = HanziRenderer.MeasureChar(g, Magic.ZhoContentFontFamily, str[i], Magic.ZhoResultFontSize),
//Size = g.MeasureString(cstr, getFont(fntZhoHead), 65535, sf),
Loc = loc,
Faded = false,
};
blocks.Add(hb);
// Location moves right
loc.X += hb.Size.Width;
// If location is beyond headword's right edge, break line now.
// This involves
// - moving last added block to next line
// - right-aligning blocks added so far
if (loc.X > right)
{
lineBreak = true;
loc.X = left;
loc.Y += ideoLineHeight;
doRightAlign(blocks, firstCharOfLine, charsOnLine - 1, right);
charsOnLine = 1;
firstCharOfLine = blocks.Count - 1;
hb.Loc = loc;
loc.X += hb.Size.Width;
}
}
// Right-align the final bit
doRightAlign(blocks, firstCharOfLine, charsOnLine, right);
// Done - tell call if we had line break or not
return lineBreak;
}
