/// <summary>
/// Remove any entries in 'bitFieldDefinitions' identified by 'bitFieldType' and 'index'.
/// This must be called before <see cref="ConstructRegisters"/>
/// </summary>
/// <param name="registerDefinitions">The registers definitions, used to determine bit field type if bitFieldDefinition[j] specifies a register instead of a type</param>
/// <param name="bitFieldDefinitions">The bit field definitions to filter</param>
/// <param name="bitFieldType">The Type of the bit fields to remove, e.g. typeof( EventBF )</param>
/// <param name="index">The specific bit field to remove, e.g. EventBF.ABusComplete</param>
/// <remarks>
/// This is normally used to remove bit fields defined by a common/shared definition (e.g.
/// CommonRegisterSet) that should not be used for a specific module. For example:
///
/// RemoveBitField( registerDefs, bitFieldDefs, typeof( SlugCarrierEventBF ), (int)SlugCarrierEventBF.CascadeEvent );
///
/// NOTE: any type replacement has been done by the default constructor, so bitFieldType
/// should refer to the module specific type
/// </remarks>
public static void RemoveBitField(IList <RegDef> registerDefinitions,
IList <BitFieldDef> bitFieldDefinitions,
Type bitFieldType,
int index)
{
// Cache of register to bit field Type
Dictionary <int, Type> registerToBitFieldType = null;
// Index backwards so deletions don't affect where we need to check next
for (int j = bitFieldDefinitions.Count - 1; j >= 0; j--)
{
BitFieldDef def = bitFieldDefinitions[j];
Type defBitFieldType = def.BFType;
if (defBitFieldType == null)
{
// The definition does not include a bit field Type ...
// Lazily construct the cache of register to bit field Type
if (registerToBitFieldType == null)
{
registerToBitFieldType = new Dictionary <int, Type>();
foreach (var register in registerDefinitions)
{
registerToBitFieldType[register.nameEnum] = register.BFenum;
}
}
// Now determine the bit field type from the register definition
if (registerToBitFieldType.ContainsKey(def.RegEnum))
{
defBitFieldType = registerToBitFieldType[def.RegEnum];
}
}
if (ReferenceEquals(bitFieldType, defBitFieldType) && def.nameEnum == index)
{
bitFieldDefinitions.RemoveAt(j);
// Continue searching ... there may be multiple definitions that match
}
}
}
/// <summary>
/// Replace the BitField type defined in supplied the register and bit field definitions.
/// This allows a derived class to customize a RegisterSet (e.g. use SlugCarrierEventBF
/// instead of EventBF).
/// </summary>
/// <param name="registerDefinitions">The register definitions to filter</param>
/// <param name="bitFieldDefinitions">The bit field definitions to filter</param>
/// <param name="oldType">the old/original Type of the bit field</param>
/// <param name="newType">the new Type of the bit field</param>
protected static void ReplaceType(IList <RegDef> registerDefinitions,
IList <BitFieldDef> bitFieldDefinitions,
Type oldType,
Type newType)
{
// Replace the bit field type for any register definitions using 'oldType'
for (int j = registerDefinitions.Count - 1; j >= 0; j--)
{
RegDef definition = registerDefinitions[j];
if (ReferenceEquals(oldType, definition.BFenum))
{
definition.BFenum = newType;
}
}
// Replace the bit field type for and bit field definitions using 'oldType'
for (int j = bitFieldDefinitions.Count - 1; j >= 0; j--)
{
BitFieldDef definition = bitFieldDefinitions[j];
if (ReferenceEquals(oldType, definition.BFType))
{
definition.BFType = newType;
}
}
}