public static void ResetBit(ref uint[] array, int bitIndex)
{
BitPosition position = bitIndex;
GrowDynamically(ref array, bitIndex + 1);
uint mask = (uint)((1 << position.BitIndex) ^ 0xFF);
array[position.IntIndex] &= mask;
}
public override bool Equals(object obj)
{
BitPosition bitPos = obj as BitPosition;
if (bitPos == null)
{
return(false);
}
return(this == bitPos);
}
/// <inheritdoc />
protected TypedBitsPlcItem
(
PlcItemType type,
ushort dataBlock,
ushort position,
BitPosition bitPosition,
byte bitAmount,
bool isFlexible,
TValue initialValue,
string identifier = default
)
: base(type, dataBlock, position, bitPosition, bitAmount, isFlexible, initialValue, identifier)
{
}
/// <summary>
/// Shifts compelete entries of the array right.
/// </summary>
/// <param name="array"></param>
/// <param name="steps"></param>
private static void ShiftEntriesRight(ref uint[] array, int steps)
{
BitPosition position = FirstBitNotZeroIndex(array);
for (int i = 0; i <= position.IntIndex; i++)
{
if (i + steps <= position.IntIndex)
{
array[i] = array[i + steps];
}
else
{
array[i] = 0;
}
}
}
/// <summary>
/// Shifts compelete entries of the array left.
/// </summary>
/// <param name="array"></param>
/// <param name="steps"></param>
private static void ShiftEntriesLeft(ref uint[] array, int steps)
{
BitPosition position = GetBitLength(array);
GrowDynamically(ref array, position.RealBitIndex + (steps * IntegerBitCount) + 1);
for (int i = position.IntIndex; i >= 0; i--)
{
array[i + steps] = array[i];
if (i < steps)
{
array[i] = 0;
}
}
}
public string ToBinaryString(int fixedDigits)
{
if (FirstBitNotZeroIndex(m_internalArray) == -1)
{
if (fixedDigits == 0)
{
return(Zero);
}
else
{
return(ZeroPadding("", fixedDigits));
}
}
int spaceModulo = fixedDigits % ByteToBitMultiplier;
int spaceCount = fixedDigits / ByteToBitMultiplier - (fixedDigits % ByteToBitMultiplier == 0 ? 1 : 0);
string result = "";
for (int bitIndex = fixedDigits - 1; bitIndex >= 0; bitIndex--)
{
bool lastOrFirst = result.Length <= 0 || bitIndex <= 0;
if ((fixedDigits - (bitIndex + 1)) % ByteToBitMultiplier == spaceModulo && !lastOrFirst)
{
result += " ";
}
BitPosition bitPosition = new BitPosition(bitIndex);
if (bitPosition.IntIndex >= m_internalArray.Length)
{
result += Zero;
}
else if (bitIndex < 0)
{
break;
}
else
{
result += IsBitSet(bitIndex) ? One : Zero;
}
}
return(SetStringFixedSize(result, fixedDigits + spaceCount));
}
/// <summary>
/// Applies the <see cref="bool"/> array to the <paramref name="data"/>.
/// </summary>
/// <param name="data"> The extended <see cref="byte"/> array. </param>
/// <param name="bytePosition"> The starting position at where to apply <paramref name="value"/>. </param>
/// <param name="bitPosition"> A specific <see cref="BitPosition"/> at where to apply <paramref name="value"/>. </param>
/// <param name="value"> The value to apply. </param>
/// <returns> The same <paramref name="data"/> instance. </returns>
public static byte[] ApplyValue(this byte[] data, ushort bytePosition, BitPosition bitPosition, bool[] value)
{
var offset = bytePosition * 8 + (int)bitPosition;
if (offset + value.Length > data.Length * 8)
{
throw new ArgumentOutOfRangeException($"The combined length of byte position, bit position and the new values length with a total of {offset + value.Length} bits is outside of the data length of {data.Length * 8} bits.");
}
var currentBooleans = DataConverter.ToBooleans(data);
for (var index = 0; index < value.Length; index++)
{
currentBooleans[index + offset] = value[index];
}
return(data.ApplyValue(0, DataConverter.ToBytes(currentBooleans)));
}
public string ToCsvLineString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat(InternalID.ToString() + ",");
stringBuilder.AppendFormat(Number.ToString() + ",");
stringBuilder.AppendFormat(Name + ",");
stringBuilder.AppendFormat(Description + ",");
stringBuilder.AppendFormat(this.Value.ToString() + ",");
stringBuilder.AppendFormat(AddPrefixOfZerosIfNeeded(Convert.ToString(m_binaryValue, 2)) + ",");
stringBuilder.AppendFormat(BitPosition.ToString() + ",");
stringBuilder.AppendFormat(Key + ",");
if (ParentCircuitBreaker != null)
{
string substation = ParentCircuitBreaker.ParentSubstation.Name;
string device = ParentCircuitBreaker.Name;
stringBuilder.AppendFormat($"{substation}_{device}{Environment.NewLine}");
}
else
{
stringBuilder.AppendFormat($"Unclaimed{Environment.NewLine}");
}
return(stringBuilder.ToString());
}
public ILengthPlcItemBuilder <TPlcItem, TValue> AtPosition(ushort bytePosition, BitPosition bitPosition)
{
this.Position = bytePosition;
this.BitPosition = bitPosition;
return(this);
}
/// <inheritdoc />
/// <summary>
/// Constructor with initial value.
/// </summary>
public BitsPlcItem(PlcItemType type, ushort dataBlock, ushort position, BitPosition bitPosition, BitCollection initialValue, string identifier = default)
: base(type, dataBlock, position, bitPosition, initialValue, identifier)
{
}
/// <inheritdoc />
/// <summary>
/// Constructor with bit amount.
/// </summary>
public BitsPlcItem(PlcItemType type, ushort dataBlock, ushort position, BitPosition bitPosition, byte bitAmount, string identifier = default)
: base(type, dataBlock, position, bitPosition, bitAmount, isFlexible: false, identifier: identifier)
{
}
/// <summary>
/// Constructor
/// </summary>
public BitPlcItem(PlcItemType type, ushort dataBlock, ushort position, BitPosition bitPosition, bool initialValue = default, string identifier = default)
: base(type, dataBlock, position, bitPosition, bitAmount: 1, false, initialValue, identifier)
{
}
private bool GetBit(BitPosition bit)
{
return BinaryHelper.CheckBit(this.ISR, (byte)bit);
}
/// <summary>
/// Returns true if the bit with the zero based index "bitIndex" is set.
/// </summary>
/// <param name="bitIndex"></param>
/// <returns></returns>
public bool IsBitSet(int bitIndex)
{
return(IsBitSet(m_internalArray, BitPosition.GetBitIndex(bitIndex), BitPosition.GetIntIndex(bitIndex)));
}
public static bool IsBitInArraySet(uint[] array, int bitIndex)
{
return(IsBitSet(array, BitPosition.GetBitIndex(bitIndex), BitPosition.GetIntIndex(bitIndex)));
}
public new IBitsLengthPlcItemConstructor AtPosition(ushort bytePosition, BitPosition bitPosition) => (IBitsLengthPlcItemConstructor)base.AtPosition(bytePosition, bitPosition);
/// <inheritdoc />
/// <summary>
/// Constructor for <see cref="PlcItemType.Data"/> <see cref="BitsPlcItem"/>s with bit amount.
/// </summary>
public BitsPlcItem(ushort dataBlock, ushort position, BitPosition bitPosition, byte bitAmount, string identifier = default)
: this(PlcItemType.Data, dataBlock, position, bitPosition, bitAmount, identifier)
{
}
private bool GetBit(BitPosition bit)
{
return(BinaryHelper.CheckBit(this.IMR, (byte)bit));
}
/// <inheritdoc />
/// <summary>
/// Constructor for <see cref="PlcItemType.Data"/> <see cref="BitPlcItem"/>s with bit amount.
/// </summary>
public BitPlcItem(ushort dataBlock, ushort position, BitPosition bitPosition, bool initialValue = default, string identifier = default)
: this(PlcItemType.Data, dataBlock, position, bitPosition, initialValue, identifier)
{
}
