public void Iterators_Filter_ReturnsEmpty_IfPredicateIsFalse()
{
using (var input = new ConstantIterator())
using (var iterator = new FilterIterator(input, () => false))
{
AssertEmpty(iterator);
}
}
static void Main(string[] args)
{
ICustomCollection <Hero> zone1List = generateZone1();
ICustomCollection <Hero> zone2List = generateZone2();
ICustomCollection <Hero> zone3List = generateZone3();
Console.WriteLine("------------------------- 1 --------------------");
IIterator zone1ListIterator = zone1List.GetIterator();
while (zone1ListIterator.hasNext())
{
Console.WriteLine("{0}", zone1ListIterator.next());
}
Console.WriteLine("\n-------------------------\n");
IIterator zone2ListIterator = zone2List.GetIterator();
while (zone2ListIterator.hasNext())
{
Console.WriteLine("{0}", zone2ListIterator.next());
}
Console.WriteLine("\n-------------------------\n");
IIterator zone3ListIterator = zone3List.GetIterator();
while (zone3ListIterator.hasNext())
{
Console.WriteLine("{0}", zone3ListIterator.next());
}
Console.WriteLine("------------------------- 2 --------------------");
IIterator tournamentIterator = new TournamtneIterator(zone1List.GetIterator(),
zone2List.GetIterator(),
zone3List.GetIterator());
while (tournamentIterator.hasNext())
{
Console.WriteLine("{0}", tournamentIterator.next());
}
Console.WriteLine("------------------------- 3 --------------------");
Console.WriteLine("zone1 : Shaman");
IIterator filterIterator1 = new FilterIterator(HeroClass.Shaman, zone1List.GetIterator());
while (filterIterator1.hasNext())
{
Console.WriteLine("{0}", filterIterator1.next());
}
Console.WriteLine("zone2 : Warrior");
IIterator filterIterator2 = new FilterIterator(HeroClass.Warrior, zone2List.GetIterator());
while (filterIterator2.hasNext())
{
Console.WriteLine("{0}", filterIterator2.next());
}
}
public void Iterators_Filter_ReturnsEmpty_IfInputIsEmpty()
{
var rows = new object[0];
using (var input = new MockedIterator(rows))
using (var iterator = new FilterIterator(input, () => true))
{
AssertEmpty(iterator);
}
}
public mIterate(Bitmap SourceBitmap, mFilters Filter, int Iterations)
{
ModifiedBitmap = (Bitmap)SourceBitmap.Clone();
ModifiedBitmap = new mSetFormat(ModifiedBitmap, Filter.BitmapType).ModifiedBitmap;
FilterIterator Iterator = new FilterIterator(Filter.Sequence, Iterations);
ModifiedBitmap = Iterator.Apply(ModifiedBitmap);
ModifiedBitmap = new mSetFormat(ModifiedBitmap, Filter.BitmapType).ModifiedBitmap;
ModifiedBitmap.SetResolution(SourceBitmap.HorizontalResolution, SourceBitmap.VerticalResolution);
}
public void Iterators_Filter_Filters()
{
var rows = new object[] { 1, 2, 3, 4 };
var expected = new object[] { 2, 4 };
using (var input = new MockedIterator(rows))
using (var iterator = new FilterIterator(input, () => (int)input.RowBuffer[0] % 2 == 0))
{
AssertProduces(iterator, expected);
}
}
public override void Parse(IMessage message, string @string, ParserOptions parserOptions)
{
if (parserOptions is null)
{
throw new ArgumentNullException(nameof(parserOptions));
}
var messageIter = new Util.MessageIterator(message, "MSH", true);
FilterIterator.IPredicate segmentsOnly = new AnonymousClassPredicate(this);
var segmentIter = new FilterIterator(messageIter, segmentsOnly);
var segments = Split(@string, SegDelim);
var encodingChars = GetEncodingChars(@string);
var delimiter = '|';
for (var i = 0; i < segments.Length; i++)
{
// get rid of any leading whitespace characters ...
if (segments[i] != null && segments[i].Length > 0 && char.IsWhiteSpace(segments[i][0]))
{
segments[i] = StripLeadingWhitespace(segments[i]);
}
// sometimes people put extra segment delimiters at end of msg ...
if (segments[i] != null && segments[i].Length >= 3)
{
var name = segments[i].Substring(0, 3 - 0);
if (i == 0)
{
name = segments[i].Substring(0, 3);
delimiter = segments[i][3];
}
else
{
name = segments[i].IndexOf(delimiter) >= 0
? segments[i].Substring(0, segments[i].IndexOf(delimiter))
: segments[i];
}
Log.Debug("Parsing segment " + name);
messageIter.Direction = name;
FilterIterator.IPredicate byDirection = new AnonymousClassPredicate1(name, this);
var dirIter = new FilterIterator(segmentIter, byDirection);
if (dirIter.MoveNext())
{
Parse((ISegment)dirIter.Current, segments[i], encodingChars, parserOptions);
}
}
}
}
/// <inheritdoc />
public IEnumerator <TElement> GetEnumerator()
{
lock (_originSet) {
if (_elementCache != null)
{
return(_elementCache.GetEnumerator());
}
// Copy all matching items into the cache
_elementCache = new LinearList <TElement>();
using (FilterIterator itr = new FilterIterator(_originSet.GetEnumerator(), _wherePredicate)) {
while (itr.MoveNext())
{
_elementCache.Add(itr.Current);
}
}
return(_elementCache.GetEnumerator());
}
}
public void Iterators_Filter_ForwardsProperly()
{
var rows = new object[] { 1, 2 };
var expected = rows;
using (var input = new MockedIterator(rows))
{
using (var iterator = new FilterIterator(input, () => true))
{
for (var i = 0; i < 2; i++)
{
AssertProduces(iterator, expected);
}
}
Assert.Equal(2, input.TotalOpenCount);
Assert.Equal(4, input.TotalReadCount);
Assert.Equal(1, input.DisposalCount);
}
}
/// <summary> Parses a message string and returns the corresponding Message
/// object. Unexpected segments added at the end of their group.
///
/// </summary>
/// <throws> HL7Exception if the message is not correctly formatted. </throws>
/// <throws> EncodingNotSupportedException if the message encoded </throws>
/// <summary> is not supported by this parser.
/// </summary>
protected internal override IMessage DoParse(System.String message, System.String version)
{
//try to instantiate a message object of the right class
MessageStructure structure = GetStructure(message);
IMessage m = InstantiateMessage(structure.messageStructure, version, structure.explicitlyDefined);
//MessagePointer ptr = new MessagePointer(this, m, getEncodingChars(message));
MessageIterator messageIter = new MessageIterator(m, "MSH", true);
FilterIterator.IPredicate segmentsOnly = new AnonymousClassPredicate(this);
FilterIterator segmentIter = new FilterIterator(messageIter, segmentsOnly);
System.String[] segments = Split(message, segDelim);
EncodingCharacters encodingChars = GetEncodingChars(message);
for (int i = 0; i < segments.Length; i++)
{
//get rid of any leading whitespace characters ...
if (segments[i] != null && segments[i].Length > 0 && System.Char.IsWhiteSpace(segments[i][0]))
{
segments[i] = StripLeadingWhitespace(segments[i]);
}
//sometimes people put extra segment delimiters at end of msg ...
if (segments[i] != null && segments[i].Length >= 3)
{
System.String name = segments[i].Substring(0, (3) - (0));
log.Debug("Parsing segment " + name);
messageIter.Direction = name;
FilterIterator.IPredicate byDirection = new AnonymousClassPredicate1(name, this);
FilterIterator dirIter = new FilterIterator(segmentIter, byDirection);
if (dirIter.MoveNext())
{
Parse((ISegment)dirIter.Current, segments[i], encodingChars);
}
}
}
return(m);
}
static void Main(string[] args)
{
ICustomCollection <Hero> zone1List = generateZone1();
ICustomCollection <Hero> zone2List = generateZone2();
ICustomCollection <Hero> zone3List = generateZone3();
var zone1Iterator = new SimpleIterator <Hero>(zone1List);
var zone2Iterator = new SimpleIterator <Hero>(zone2List);
var zone3Iterator = new SimpleIterator <Hero>(zone3List);
//displayCollection<Hero>(zone1Iterator, 1);
//displayCollection<Hero>(zone2Iterator, 2);
//displayCollection<Hero>(zone3Iterator, 3);
//displayPvPPairs<Hero>(zone1Iterator, 1);
//displayPvPPairs<Hero>(zone2Iterator, 2);
//displayPvPPairs<Hero>(zone3Iterator, 3);
var filterZone1Iterator = new FilterIterator <Hero>(zone1List, 'S');
displayCollection <Hero>(filterZone1Iterator, 1);
}
public Bitmap Adelgazar()
{
Invert ivert = new Invert();
imagen = ivert.Apply(imagen);
FiltersSequence filterSequence = new FiltersSequence();
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ 0, 0, 0 },
{ -1, 1, -1 },
{ 1, 1, 1 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ -1, 0, 0 },
{ 1, 1, 0 },
{ -1, 1, -1 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ 1, -1, 0 },
{ 1, 1, 0 },
{ 1, -1, 0 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ -1, 1, -1 },
{ 1, 1, 0 },
{ -1, 0, 0 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ 1, 1, 1 },
{ -1, 1, -1 },
{ 0, 0, 0 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ -1, 1, -1 },
{ 0, 1, 1 },
{ 0, 0, -1 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ 0, -1, 1 },
{ 0, 1, 1 },
{ 0, -1, 1 }
},
HitAndMiss.Modes.Thinning));
filterSequence.Add(new HitAndMiss(
new short[, ] {
{ 0, 0, -1 },
{ 0, 1, 1 },
{ -1, 1, -1 }
},
HitAndMiss.Modes.Thinning));
FilterIterator filterIterator = new FilterIterator(filterSequence, 15);
imagen = filterIterator.Apply(imagen);
imagen = ivert.Apply(imagen);
return(imagen);
}
