SabreTools/SabreTools.IO
1
0
Fork 0
mirror of https://github.com/SabreTools/SabreTools.IO.git synced 2026-02-04 05:36:05 +00:00
Code Issues 1 Packages Projects Releases 20 Wiki Activity

Add bitwise AND and OR operations to both-endian

Browse Source
This commit is contained in:
Matt Nadareski
2025-10-27 15:34:32 -04:00
parent 12341ba6aa
commit abdf50c9e0
16 changed files with 192 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
SabreTools.IO.Test/Numerics/BothInt16Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (short)2 & (short)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (short)2 | (short)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothInt32Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (int)2 & (int)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (int)2 | (int)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothInt64Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (long)2 & (long)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (long)2 | (long)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothInt8Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (sbyte)2 & (sbyte)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (sbyte)2 | (sbyte)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothUInt16Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (ushort)2 & (ushort)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (ushort)2 | (ushort)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothUInt32Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (uint)2 & (uint)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (uint)2 | (uint)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothUInt64Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (ulong)2 & (ulong)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (ulong)2 | (ulong)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

10
SabreTools.IO.Test/Numerics/BothUInt8Tests.cs
View File

@@ -163,6 +163,16 @@ namespace SabreTools.IO.Test.Numerics
actual = valA ^ valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (byte)2 & (byte)1;
actual = valA & valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
expected = (byte)2 | (byte)1;
actual = valA | valB;
Assert.Equal(expected, actual.LittleEndian);
Assert.Equal(expected, actual.BigEndian);
}
}
}

14
SabreTools.IO/Numerics/BothInt16.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothInt16(le, be);
}
public static BothInt16 operator |(BothInt16 a, BothInt16 b)
{
short le = (short)(a.LittleEndian | b.LittleEndian);
short be = (short)(a.BigEndian | b.BigEndian);
return new BothInt16(le, be);
}
public static BothInt16 operator &(BothInt16 a, BothInt16 b)
{
short le = (short)(a.LittleEndian & b.LittleEndian);
short be = (short)(a.BigEndian & b.BigEndian);
return new BothInt16(le, be);
}
public static implicit operator BothInt16(short val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothInt32.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothInt32(le, be);
}
public static BothInt32 operator |(BothInt32 a, BothInt32 b)
{
int le = (int)(a.LittleEndian | b.LittleEndian);
int be = (int)(a.BigEndian | b.BigEndian);
return new BothInt32(le, be);
}
public static BothInt32 operator &(BothInt32 a, BothInt32 b)
{
int le = (int)(a.LittleEndian & b.LittleEndian);
int be = (int)(a.BigEndian & b.BigEndian);
return new BothInt32(le, be);
}
public static implicit operator BothInt32(int val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothInt64.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothInt64(le, be);
}
public static BothInt64 operator |(BothInt64 a, BothInt64 b)
{
long le = (long)(a.LittleEndian | b.LittleEndian);
long be = (long)(a.BigEndian | b.BigEndian);
return new BothInt64(le, be);
}
public static BothInt64 operator &(BothInt64 a, BothInt64 b)
{
long le = (long)(a.LittleEndian & b.LittleEndian);
long be = (long)(a.BigEndian & b.BigEndian);
return new BothInt64(le, be);
}
public static implicit operator BothInt64(long val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothInt8.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothInt8(le, be);
}
public static BothInt8 operator |(BothInt8 a, BothInt8 b)
{
sbyte le = (sbyte)(a.LittleEndian | b.LittleEndian);
sbyte be = (sbyte)(a.BigEndian | b.BigEndian);
return new BothInt8(le, be);
}
public static BothInt8 operator &(BothInt8 a, BothInt8 b)
{
sbyte le = (sbyte)(a.LittleEndian & b.LittleEndian);
sbyte be = (sbyte)(a.BigEndian & b.BigEndian);
return new BothInt8(le, be);
}
public static implicit operator BothInt8(sbyte val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothUInt16.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothUInt16(le, be);
}
public static BothUInt16 operator |(BothUInt16 a, BothUInt16 b)
{
ushort le = (ushort)(a.LittleEndian | b.LittleEndian);
ushort be = (ushort)(a.BigEndian | b.BigEndian);
return new BothUInt16(le, be);
}
public static BothUInt16 operator &(BothUInt16 a, BothUInt16 b)
{
ushort le = (ushort)(a.LittleEndian & b.LittleEndian);
ushort be = (ushort)(a.BigEndian & b.BigEndian);
return new BothUInt16(le, be);
}
public static implicit operator BothUInt16(ushort val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothUInt32.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothUInt32(le, be);
}
public static BothUInt32 operator |(BothUInt32 a, BothUInt32 b)
{
uint le = (uint)(a.LittleEndian | b.LittleEndian);
uint be = (uint)(a.BigEndian | b.BigEndian);
return new BothUInt32(le, be);
}
public static BothUInt32 operator &(BothUInt32 a, BothUInt32 b)
{
uint le = (uint)(a.LittleEndian & b.LittleEndian);
uint be = (uint)(a.BigEndian & b.BigEndian);
return new BothUInt32(le, be);
}
public static implicit operator BothUInt32(uint val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothUInt64.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothUInt64(le, be);
}
public static BothUInt64 operator |(BothUInt64 a, BothUInt64 b)
{
ulong le = (ulong)(a.LittleEndian | b.LittleEndian);
ulong be = (ulong)(a.BigEndian | b.BigEndian);
return new BothUInt64(le, be);
}
public static BothUInt64 operator &(BothUInt64 a, BothUInt64 b)
{
ulong le = (ulong)(a.LittleEndian & b.LittleEndian);
ulong be = (ulong)(a.BigEndian & b.BigEndian);
return new BothUInt64(le, be);
}
public static implicit operator BothUInt64(ulong val)
=> new(val, val);

14
SabreTools.IO/Numerics/BothUInt8.cs
View File

@@ -42,6 +42,20 @@ namespace SabreTools.Numerics
return new BothUInt8(le, be);
}
public static BothUInt8 operator |(BothUInt8 a, BothUInt8 b)
{
byte le = (byte)(a.LittleEndian | b.LittleEndian);
byte be = (byte)(a.BigEndian | b.BigEndian);
return new BothUInt8(le, be);
}
public static BothUInt8 operator &(BothUInt8 a, BothUInt8 b)
{
byte le = (byte)(a.LittleEndian & b.LittleEndian);
byte be = (byte)(a.BigEndian & b.BigEndian);
return new BothUInt8(le, be);
}
public static implicit operator BothUInt8(byte val)
=> new(val, val);