/// <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; } } }