// ReverseRangeEnumerable
public bool SequenceEqual(
PlaceholderEnumerable <int> first,
ReverseRangeEnumerable second
)
{
return
(CommonImplementation.SequenceEqual <
int,
PlaceholderEnumerable <int>,
PlaceholderEnumerator <int>,
ReverseRangeEnumerable,
ReverseRangeEnumerator
>(RefParam(first), ref second, null));
}
public bool SequenceEqual <TGenKey, TGenElement>(
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> > first,
LookupSpecificEnumerable <TGenKey, TGenElement> second
)
{
return
(CommonImplementation.SequenceEqual <
GroupingEnumerable <TGenKey, TGenElement>,
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> >,
PlaceholderEnumerator <GroupingEnumerable <TGenKey, TGenElement> >,
LookupSpecificEnumerable <TGenKey, TGenElement>,
LookupSpecificEnumerator <TGenKey, TGenElement>
>(RefParam(first), ref second, null));
}
public bool SequenceEqual <TGenKey, TGenElement>(
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> > first,
LookupDefaultEnumerable <TGenKey, TGenElement> second,
IEqualityComparer <GroupingEnumerable <TGenKey, TGenElement> > comparer
)
{
return
(CommonImplementation.SequenceEqual <
GroupingEnumerable <TGenKey, TGenElement>,
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> >,
PlaceholderEnumerator <GroupingEnumerable <TGenKey, TGenElement> >,
LookupDefaultEnumerable <TGenKey, TGenElement>,
LookupDefaultEnumerator <TGenKey, TGenElement>
>(RefParam(first), ref second, comparer));
}
public bool SequenceEqual(
PlaceholderEnumerable <int> first,
RangeEnumerable second,
IEqualityComparer <int> comparer
)
{
return
(CommonImplementation.SequenceEqual <
int,
PlaceholderEnumerable <int>,
PlaceholderEnumerator <int>,
RangeEnumerable,
RangeEnumerator
>(RefParam(first), ref second, comparer));
}
public bool SequenceEqual <TGenInItem, TGenKey, TGenElement, TGenEnumerable, TGenEnumerator>(
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> > first,
GroupBySpecificEnumerable <TGenInItem, TGenKey, TGenElement, TGenEnumerable, TGenEnumerator> second
)
where TGenEnumerable : struct, IStructEnumerable <TGenInItem, TGenEnumerator>
where TGenEnumerator : struct, IStructEnumerator <TGenInItem>
{
return
(CommonImplementation.SequenceEqual <
GroupingEnumerable <TGenKey, TGenElement>,
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> >,
PlaceholderEnumerator <GroupingEnumerable <TGenKey, TGenElement> >,
GroupBySpecificEnumerable <TGenInItem, TGenKey, TGenElement, TGenEnumerable, TGenEnumerator>,
GroupBySpecificEnumerator <TGenInItem, TGenKey, TGenElement, TGenEnumerator>
>(RefParam(first), ref second, null));
}
> Concat <TGenLookupKey, TGenLookupElement>(
PlaceholderEnumerable <GroupingEnumerable <TGenLookupKey, TGenLookupElement> > first,
LookupSpecificEnumerable <TGenLookupKey, TGenLookupElement> second
)
{
return
(CommonImplementation.Concat <
GroupingEnumerable <TGenLookupKey, TGenLookupElement>,
PlaceholderEnumerable <GroupingEnumerable <TGenLookupKey, TGenLookupElement> >,
PlaceholderEnumerator <GroupingEnumerable <TGenLookupKey, TGenLookupElement> >,
LookupSpecificEnumerable <TGenLookupKey, TGenLookupElement>,
LookupSpecificEnumerator <TGenLookupKey, TGenLookupElement>
>(
RefParam(first),
ref second
));
}
// ReverseRangeEnumerable
public ConcatEnumerable <int, PlaceholderEnumerable <int>, PlaceholderEnumerator <int>, ReverseRangeEnumerable, ReverseRangeEnumerator> Concat(
PlaceholderEnumerable <int> first,
ReverseRangeEnumerable second
)
{
return
(CommonImplementation.Concat <
int,
PlaceholderEnumerable <int>,
PlaceholderEnumerator <int>,
ReverseRangeEnumerable,
ReverseRangeEnumerator
>(
RefParam(first),
ref second
));
}
public bool SequenceEqual <TItem>(BuiltInEnumerable <TItem> first, PlaceholderEnumerable <TItem> second, IEqualityComparer <TItem> comparer)
{
var firstBridge = Bridge(first, nameof(second));
if (second.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(second));
}
return
(CommonImplementation.SequenceEqualImpl <
TItem,
BuiltInEnumerable <TItem>,
BuiltInEnumerator <TItem>,
PlaceholderEnumerable <TItem>,
PlaceholderEnumerator <TItem>
>(RefLocal(firstBridge), RefParam(second), comparer));
}
> Concat <TGenGroupByInItem, TGenKey, TGenElement, TGenGroupByEnumerable, TGenGroupByEnumerator>(
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> > first,
GroupBySpecificEnumerable <TGenGroupByInItem, TGenKey, TGenElement, TGenGroupByEnumerable, TGenGroupByEnumerator> second
)
where TGenGroupByEnumerable : struct, IStructEnumerable <TGenGroupByInItem, TGenGroupByEnumerator>
where TGenGroupByEnumerator : struct, IStructEnumerator <TGenGroupByInItem>
{
return
(CommonImplementation.Concat <
GroupingEnumerable <TGenKey, TGenElement>,
PlaceholderEnumerable <GroupingEnumerable <TGenKey, TGenElement> >,
PlaceholderEnumerator <GroupingEnumerable <TGenKey, TGenElement> >,
GroupBySpecificEnumerable <TGenGroupByInItem, TGenKey, TGenElement, TGenGroupByEnumerable, TGenGroupByEnumerator>,
GroupBySpecificEnumerator <TGenGroupByInItem, TGenKey, TGenElement, TGenGroupByEnumerator>
>(
RefParam(first),
ref second
));
}
> Join <TOutItem, TJoinKeyItem, TJoinLeftItem, TJoinRightItem>(
BuiltInEnumerable <TJoinLeftItem> outer,
PlaceholderEnumerable <TJoinRightItem> inner,
Func <TJoinLeftItem, TJoinKeyItem> outerKeySelector,
Func <TJoinRightItem, TJoinKeyItem> innerKeySelector,
Func <TJoinLeftItem, TJoinRightItem, TOutItem> resultSelector,
IEqualityComparer <TJoinKeyItem> comparer
)
{
var outerBridge = Bridge(outer, nameof(outer));
if (inner.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(inner));
}
if (outerKeySelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(outerKeySelector));
}
if (innerKeySelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(innerKeySelector));
}
if (resultSelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(resultSelector));
}
return
(CommonImplementation.JoinImpl <
TOutItem,
TJoinKeyItem,
TJoinLeftItem,
BuiltInEnumerable <TJoinLeftItem>,
BuiltInEnumerator <TJoinLeftItem>,
TJoinRightItem,
PlaceholderEnumerable <TJoinRightItem>,
PlaceholderEnumerator <TJoinRightItem>
>(RefLocal(outerBridge), RefParam(inner), outerKeySelector, innerKeySelector, resultSelector, comparer));
}
> GroupJoin <TResult, TGroupJoinKey, TOuter, TInner>(
BuiltInEnumerable <TOuter> outer,
PlaceholderEnumerable <TInner> inner,
Func <TOuter, TGroupJoinKey> outerKeySelector,
Func <TInner, TGroupJoinKey> innerKeySelector,
Func <TOuter, GroupedEnumerable <TGroupJoinKey, TInner>, TResult> resultSelector,
IEqualityComparer <TGroupJoinKey> comparer
)
{
var outerBridge = Bridge(outer, nameof(outer));
if (inner.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(inner));
}
if (outerKeySelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(outerKeySelector));
}
if (innerKeySelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(innerKeySelector));
}
if (resultSelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(resultSelector));
}
return
(CommonImplementation.GroupJoinImpl <
TResult,
TGroupJoinKey,
TOuter,
BuiltInEnumerable <TOuter>,
BuiltInEnumerator <TOuter>,
TInner,
PlaceholderEnumerable <TInner>,
PlaceholderEnumerator <TInner>
>(RefLocal(outerBridge), RefParam(inner), outerKeySelector, innerKeySelector, resultSelector, comparer));
}
public float?Max(PlaceholderEnumerable <float?> source) => CommonImplementation.MaxNullableFloat <PlaceholderEnumerable <float?>, PlaceholderEnumerator <float?> >(RefParam(source));
public float Max(PlaceholderEnumerable <float> source) => CommonImplementation.MaxFloat <PlaceholderEnumerable <float>, PlaceholderEnumerator <float> >(RefParam(source));
public long?Max(PlaceholderEnumerable <long?> source) => CommonImplementation.MaxNullableLong <PlaceholderEnumerable <long?>, PlaceholderEnumerator <long?> >(RefParam(source));
public long Max(PlaceholderEnumerable <long> source) => CommonImplementation.MaxLong <PlaceholderEnumerable <long>, PlaceholderEnumerator <long> >(RefParam(source));
public int?Max(PlaceholderEnumerable <int?> source) => CommonImplementation.MaxNullableInt <PlaceholderEnumerable <int?>, PlaceholderEnumerator <int?> >(RefParam(source));
public double Average(PlaceholderEnumerable <int> source) => CommonImplementation.AverageInt <PlaceholderEnumerable <int>, PlaceholderEnumerator <int> >(RefParam(source));
// HACK: the "Gen" part of each generic parameter is necessary to avoid some name collisions in code gen
public ZipEnumerable <TGenOutItem, TGenFirstItem, TGenSecondItem, BuiltInEnumerable <TGenFirstItem>, BuiltInEnumerator <TGenFirstItem>, PlaceholderEnumerable <TGenSecondItem>, PlaceholderEnumerator <TGenSecondItem> > Zip <TGenOutItem, TGenFirstItem, TGenSecondItem>(BuiltInEnumerable <TGenFirstItem> first, PlaceholderEnumerable <TGenSecondItem> second, Func <TGenFirstItem, TGenSecondItem, TGenOutItem> resultSelector)
{
var firstBridged = Bridge(first, nameof(first));
if (second.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(second));
}
if (resultSelector == null)
{
throw CommonImplementation.ArgumentNull(nameof(resultSelector));
}
return
(CommonImplementation.ZipImpl <
TGenOutItem,
TGenFirstItem,
TGenSecondItem,
BuiltInEnumerable <TGenFirstItem>,
BuiltInEnumerator <TGenFirstItem>,
PlaceholderEnumerable <TGenSecondItem>,
PlaceholderEnumerator <TGenSecondItem>
>(RefLocal(firstBridged), RefParam(second), resultSelector));
}
public decimal?Max(PlaceholderEnumerable <decimal?> source) => CommonImplementation.MaxNullableDecimal <PlaceholderEnumerable <decimal?>, PlaceholderEnumerator <decimal?> >(RefParam(source));
public double Max(PlaceholderEnumerable <double> source) => CommonImplementation.MaxDouble <PlaceholderEnumerable <double>, PlaceholderEnumerator <double> >(RefParam(source));
public double?Max(PlaceholderEnumerable <double?> source) => CommonImplementation.MaxNullableDouble <PlaceholderEnumerable <double?>, PlaceholderEnumerator <double?> >(RefParam(source));
public double?Average(PlaceholderEnumerable <long?> source) => CommonImplementation.AverageNullableLong <PlaceholderEnumerable <long?>, PlaceholderEnumerator <long?> >(RefParam(source));
public int Max(PlaceholderEnumerable <int> source) => CommonImplementation.MaxInt <PlaceholderEnumerable <int>, PlaceholderEnumerator <int> >(RefParam(source));
public decimal Average(PlaceholderEnumerable <decimal> source) => CommonImplementation.AverageDecimal <PlaceholderEnumerable <decimal>, PlaceholderEnumerator <decimal> >(RefParam(source));
public ExceptDefaultEnumerable <TItem, BuiltInEnumerable <TItem>, BuiltInEnumerator <TItem>, PlaceholderEnumerable <TItem>, PlaceholderEnumerator <TItem> > Except <TItem>(BuiltInEnumerable <TItem> first, PlaceholderEnumerable <TItem> second)
{
var firstBridge = Bridge(first, nameof(first));
if (second.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(second));
}
return(CommonImplementation.ExceptImpl <
TItem,
BuiltInEnumerable <TItem>,
BuiltInEnumerator <TItem>,
PlaceholderEnumerable <TItem>,
PlaceholderEnumerator <TItem>
>(RefLocal(firstBridge), RefParam(second)));
}
protected abstract dynamic RefParam <TItem>(PlaceholderEnumerable <TItem> source);
