Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-14 14:24:10 +02:00
Code Activity

Range<T> now supports non-int ranges

Browse source
This commit is contained in:
Brian Fiete 2024-02-27 10:55:02 -05:00
parent 47c9305253
commit 3ea36817ff
1 changed files with 83 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

163
BeefLibs/corlib/src/Range.bf
View file

@ -225,7 +225,7 @@ namespace System
} }
} }
struct Range<T> where T : operator T + int where int : operator T - T where bool : operator T >= T struct Range<T> where T : operator T + T where T : operator T - T where bool : operator T >= T
{ {
protected T mStart; protected T mStart;
protected T mEnd; protected T mEnd;
@ -244,7 +244,7 @@ namespace System
mEnd = end; mEnd = end;
} }
public int Length public T Length
{ {
[Inline] [Inline]
get get
@ -297,15 +297,6 @@ namespace System
} }
} }
public ReverseEnumerator Reversed
{
[Inline]
get
{
return ReverseEnumerator(mEnd + -1, mStart);
}
}
public bool Contains(T idx) public bool Contains(T idx)
{ {
return (idx >= mStart) && !(idx >= mEnd); return (idx >= mStart) && !(idx >= mEnd);
@ -322,90 +313,102 @@ namespace System
mEnd = default; mEnd = default;
} }
[Inline]
public Enumerator GetEnumerator()
{
return Enumerator(this);
}
public override void ToString(String strBuffer) public override void ToString(String strBuffer)
{ {
strBuffer.AppendF($"{mStart}..<{mEnd}"); strBuffer.AppendF($"{mStart}..<{mEnd}");
} }
}
public struct Enumerator : IEnumerator<T> extension Range<T> where T : operator T + T where T : operator T - T where T : operator implicit int8 where bool : operator T >= T
{
[Inline]
public RangeEnumerator<T> GetEnumerator()
{ {
private T mEnd; return RangeEnumerator<T>(this);
private T mIndex;
[Inline]
public this(Range<T> range)
{
mIndex = range.mStart + -1;
mEnd = range.mEnd;
}
public void Dispose()
{
}
public ref T Index
{
get mut
{
return ref mIndex;
}
}
public T End => mEnd;
[Inline]
public Result<T> GetNext() mut
{
if (mIndex + 1 >= mEnd)
return .Err;
mIndex += 1;
return mIndex;
}
} }
public struct ReverseEnumerator : IEnumerator<T> public ReverseRangeEnumerator<T> Reversed
{ {
private T mEnd;
private T mIndex;
[Inline] [Inline]
public this(T start, T end) get
{
mIndex = start + 1;
mEnd = end;
}
public void Dispose()
{
}
public ref T Index
{
get mut
{
return ref mIndex;
}
}
public T End => mEnd;
[Inline]
public Result<T> GetNext() mut
{ {
if (mIndex <= mEnd) return ReverseRangeEnumerator<T>(mEnd + -1, mStart);
return .Err;
mIndex += -1;
return mIndex;
} }
} }
} }
public struct RangeEnumerator<T> : IEnumerator<T> where T : operator T + T where T : operator T - T where T : operator implicit int8 where bool : operator T >= T
{
private T mEnd;
private T mIndex;
[Inline]
public this(Range<T> range)
{
mIndex = range.[Friend]mStart + -1;
mEnd = range.[Friend]mEnd;
}
public void Dispose()
{
}
public ref T Index
{
get mut
{
return ref mIndex;
}
}
public T End => mEnd;
[Inline]
public Result<T> GetNext() mut
{
if (mIndex + (int8)1 >= mEnd)
return .Err;
mIndex = mIndex + (int8)1;
return mIndex;
}
}
public struct ReverseRangeEnumerator<T> : IEnumerator<T> where T : operator T + T where T : operator T - T where T : operator implicit int8 where bool : operator T >= T
{
private T mEnd;
private T mIndex;
[Inline]
public this(T start, T end)
{
mIndex = start + (int8)1;
mEnd = end;
}
public void Dispose()
{
}
public ref T Index
{
get mut
{
return ref mIndex;
}
}
public T End => mEnd;
[Inline]
public Result<T> GetNext() mut
{
if (mIndex <= mEnd)
return .Err;
mIndex = mIndex + (int8)(-1);
return mIndex;
}
}
struct IndexRange : RangeExpression struct IndexRange : RangeExpression
{ {
protected Index mStart; protected Index mStart;