public static Generic.IEnumerable <byte> Encode(this Generic.IEnumerable <char> me, Encoding encoding)
{
Generic.IEnumerator <byte> enumerator = me.GetEnumerator().Encode(encoding);
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
public static string Join(this Generic.IEnumerable <string> me)
{
System.Text.StringBuilder result = new System.Text.StringBuilder();
Generic.IEnumerator <string> enumerator = me.GetEnumerator();
while (enumerator.MoveNext())
{
result.Append(enumerator.Current);
}
return(result.ToString());
}
public static Generic.IEnumerable <T> Read <T>(this Generic.IEnumerable <T> me, int count)
{
if (count > 0)
{
var enumerator = me.GetEnumerator();
do
{
yield return(enumerator.Current);
}while (--count > 0 && enumerator.MoveNext());
}
}
public static Generic.IEnumerable <T> Skip <T>(this Generic.IEnumerable <T> me, int count)
{
var enumerator = me.GetEnumerator();
while (count > 0 && enumerator.MoveNext())
{
count--;
}
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
public static T First <T>(this Generic.IEnumerable <T> me)
{
T result;
if (me.NotNull())
{
using (Generic.IEnumerator <T> enumerator = me.GetEnumerator())
result = enumerator.MoveNext() ? enumerator.Current : default(T);
}
else
{
result = default(T);
}
return(result);
}
public static T?FirstOrNull <T>(this Generic.IEnumerable <T> me)
where T : struct
{
T?result;
if (me.NotNull())
{
using (Generic.IEnumerator <T> enumerator = me.GetEnumerator())
result = enumerator.MoveNext() ? enumerator.Current : default(T);
}
else
{
result = null;
}
return(result);
}
public static bool All <T>(this Generic.IEnumerable <T> me, Func <T, bool, bool> function)
{
bool result = true;
Generic.IEnumerator <T> enumerator = me.GetEnumerator();
bool notLast = enumerator.MoveNext();
while (notLast)
{
T current = enumerator.Current;
if (!function(current, !(notLast = enumerator.MoveNext())))
{
result = false;
break;
}
}
return(result);
}
public static Generic.IEnumerable <char> Decode(this Generic.IEnumerable <byte> me, System.Text.Encoding encoding)
{
//if (encoding == System.Text.Encoding.UTF8)
{
byte[] buffer = new byte[6];
int length = 0;
Generic.IEnumerator <byte> enumerator = me.GetEnumerator();
while (enumerator.MoveNext())
{
buffer[0] = enumerator.Current;
length =
buffer[0] < 0x80 ? 1 :
buffer[0] < 0xc0 ? 0 :
buffer[0] < 0xe0 ? 2 :
buffer[0] < 0xf0 ? 3 :
buffer[0] < 0xf8 ? 4 :
buffer[0] < 0xfc ? 5 :
6;
if (length > 0)
{
int i = 1;
for (; i < length && enumerator.MoveNext(); i++)
{
buffer[i] = enumerator.Current;
}
if (length == 3 && buffer[0] == 0xef && buffer[1] == 0xbb && buffer[2] == 0xbf)
{
length = 0; // Skip "zero width no break space" (0xefbbbf)
//yield return ;
}
if (i == length)
{
foreach (char c in encoding.GetChars(buffer, 0, length))
{
yield return(c);
}
}
}
}
}
}
public static Generic.IEnumerable <T> Skip <T>(this Generic.IEnumerable <T> me, params T[] separator)
where T : IEquatable <T>
{
int position = 0;
var enumerator = me.GetEnumerator();
while (enumerator.MoveNext())
{
if (!separator[position++].Equals(enumerator.Current))
{
position = 0;
}
else if (separator.Length == position)
{
break;
}
}
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
public static bool SameOrEquals <T>(this Generic.IEnumerable <T> me, Generic.IEnumerable <T> other) => me.IsNull() && other.IsNull() || me.GetEnumerator().SameOrEquals(other.GetEnumerator());
/// <summary>
/// Copies data of <paramref>me</paramref> into a new array.
/// </summary>
/// <param name="me">Block to copy data from.</param>
/// <returns>A new array containing the data from <paramref>me</paramref>.</returns>
public static T[] ToArray <T>(this Generic.IEnumerable <T> me)
{
return(me.NotNull() ? me.GetEnumerator().ToArray(0) : null);
}
public static IAsyncEnumerator <T> Create <T>(Generic.IEnumerable <T> enumerable) => AsyncEnumerator.Create(enumerable?.GetEnumerator());
public static Tasks.Task <bool> WriteLine(this ITextWriter me, Generic.IEnumerable <char> value)
{
return(me.WriteLine(value.GetEnumerator()));
}
public static Tasks.Task <bool> Write(this ITextWriter me, Generic.IEnumerable <char> buffer)
{
return(me.Write(buffer?.GetEnumerator()));
}
public static Tasks.Task <bool> Join(this ITextWriter me, Generic.IEnumerable <string> items, string separator = null)
{
return(me.Join(items?.GetEnumerator(), separator));
}
internal static ICharacterInDevice Open(Generic.IEnumerable <char> content)
{
return(CharacterInDevice.Open(content?.GetEnumerator()));
}
public void EnumeratorNotEqual(Generic.IEnumerable <string> left, Generic.IEnumerable <string> right)
{
Assert.False((left?.GetEnumerator()).SameOrEquals(right?.GetEnumerator()));
}
public void ArrayNotEqual(Generic.IEnumerable <string> left, Generic.IEnumerable <string> right)
{
Assert.NotEqual(left?.GetEnumerator().ToArray(), right?.GetEnumerator().ToArray());
}
public static int Hash <T>(this object me, Generic.IEnumerable <T> others)
{
return(me.Hash(others.GetEnumerator()));
}
public static T Get <T>(this Generic.IEnumerable <T> me, int index)
{
return(me.GetEnumerator().Skip(index).Next());
}
public static Generic.IEnumerable <TResult> Zip <TLeft, TRight, TResult>(this Generic.IEnumerable <TLeft> me, Generic.IEnumerable <TRight> other, Func <TLeft, TRight, TResult> combine)
{
return(me.NotNull() && other.NotNull() && combine.NotNull() ?
new Enumerable <TResult>(() => me.GetEnumerator().Zip(other.GetEnumerator(), combine)) :
Enumerable.Empty <TResult>());
}
public static int Count <T>(this Generic.IEnumerable <T> me)
{
return(me.NotNull() ? me.GetEnumerator().Count() : 0);
}