public void RegisterInstance <T>(T instance, RegisterMode mode = RegisterMode.Self, string name = "") where T : class
{
var builder = new ContainerBuilder();
builder.RegisterInstance <T>(instance, mode, name);
builder.Update(_container);
}
public RegisterProperty(
PropertyType propertyType,
RegisterMode registerMode,
string propertyName,
string paramName,
string type,
string defaultValue,
string description,
Action <CodeWriter, string> appendPropertyAssigmentValidation,
Action <CodeWriter, string[]> appendPropertyAssigmentFromBytes,
Func <string[]> getByteIndexAsByteStrings,
int byteIndex)
{
PropertyType = propertyType;
RegisterMode = registerMode;
PropertyName = propertyName;
ParamName = paramName;
Type = type;
DefaultValue = defaultValue;
Description = description;
AppendPropertyAssigmentValidation = appendPropertyAssigmentValidation;
AppendPropertyAssigmentFromBytes = appendPropertyAssigmentFromBytes;
GetByteIndexAsByteStrings = getByteIndexAsByteStrings;
ByteIndex = byteIndex;
}
public Registration(Type serviceType, RegistrationAttribute attr = null)
{
this.ServiceType = serviceType;
if (attr != null)
{
this.Order = attr.Order;
this.Name = attr.Name;
this.LifeCycle = attr.LifeCycle;
this.RegisterMode = attr.RegisterMode;
}
}
private void SendBytes(int data, RegisterMode mode)
{
RegisterSelectPin.Write((GpioPinValue)mode);
// In 4-bit mode, we'll write the high bits to data pins 4-7,
// then toggle the enable pin, then write the low bits to 4-7
ClearDataPins();
WriteHighIfData(data, 0x10, DataBusPin4);
WriteHighIfData(data, 0x20, DataBusPin5);
WriteHighIfData(data, 0x40, DataBusPin6);
WriteHighIfData(data, 0x80, DataBusPin7);
ToggleEnablePin();
ClearDataPins();
WriteHighIfData(data, 0x01, DataBusPin4);
WriteHighIfData(data, 0x02, DataBusPin5);
WriteHighIfData(data, 0x04, DataBusPin6);
WriteHighIfData(data, 0x08, DataBusPin7);
ToggleEnablePin();
}
public RegisterLoad() : base(null, null, null)
{
mode = RegisterMode.Singleton;
}
public void RegisterType(Type type, LifeCycle lifeCycle = LifeCycle.Transient, RegisterMode mode = RegisterMode.Self, string name = "")
{
var builder = new ContainerBuilder();
builder.RegisterType(type, mode, name).UseLifeCycle(lifeCycle);
builder.Update(_container);
}
private void GenerateEnum(
CodeWriter code,
RegisterMode registerMode,
int registerLength,
List <RegisterProperty> properties,
XElement element,
bool isFlags)
{
string name = GetName(element);
string enumName = name + "Enum";
int byteIndex;
var bitsRange = GetBitsRange(element, registerLength, null, out byteIndex);
EnumValue[] enumValues = element.Elements("Value")
.Select(GetEnumValue)
.OrderBy(x => x.Value)
.ToArray();
switch (registerMode)
{
case RegisterMode.ReadWrite:
if (enumValues.Count(x => x.IsDefault) != 1)
{
throw new Exception("Exactly one default enum value expected: " + name);
}
break;
case RegisterMode.ReadClear:
case RegisterMode.ReadOnly:
if (enumValues.Count(x => x.IsDefault) != 0)
{
throw new Exception("No default enum value expected: " + name);
}
break;
}
GenerateDescription(code, GetDescription(element));
//code.AppendLine(bitsRange.FromBits == bitsRange.ToBits
// ? $"[BitMask({bitsRange.FromBits})]"
// : $"[BitMask({bitsRange.FromBits}, {bitsRange.ToBits})]");
string integerType = GetIntegerType(bitsRange);
if (isFlags)
{
code.AppendLine("[Flags]");
}
code.AppendLine($"public enum {enumName} : {integerType}");
code.AppendLine("{");
code.Indent++; // Enum values
bool isFirst = true;
Iterate(enumValues, (enumValue, isLast) =>
{
if (isFirst)
{
isFirst = false;
}
else if (!string.IsNullOrEmpty(enumValue.Description))
{
code.AppendLine();
}
byte value = enumValue.Value;
//byte value = (byte)(enumValue.Value << bitsRange.FromBits);
GenerateDescription(code, enumValue.Description);
code.AppendLine($"{enumValue.Name} = {ToHex(value, 2)}{(isLast ? string.Empty : ",")}");
});
code.Indent--; // Enum values
code.AppendLine("}");
code.AppendLine();
string defaultValue;
if (registerMode == RegisterMode.ReadWrite)
{
defaultValue = enumName + "." + enumValues.Single(x => x.IsDefault).Name;
}
else
{
defaultValue = null;
}
Action <CodeWriter, string[]> appendPropertyAssigmentFromBytes = (codeWriter, byteParameterNames) =>
{
var composedValue = GetComposedValue(bitsRange, registerLength, byteIndex, byteParameterNames);
codeWriter.AppendLine($"{name} = ({enumName})Enum.ToObject(typeof({enumName}), {composedValue});");
};
Func <string[]> getByteIndexAsByteStrings = () =>
GetDecomposedValues(name, bitsRange, registerLength, byteIndex, false);
properties.Add(new RegisterProperty(
PropertyType.Enum,
registerMode,
name,
GetLocalName(name),
enumName,
defaultValue,
GetDescription(element),
(codeWriter, paramName) => { },
appendPropertyAssigmentFromBytes,
getByteIndexAsByteStrings,
byteIndex));
}
private void GenerateRegister(CodeWriter code, string prefix, XElement registerElement)
{
string name = GetName(registerElement);
string className = GetRegisterName(prefix, name);
string registerAddressEnumName = GetRegisterAddressEnumName(prefix);
int registerLength = GetRegisterLength(registerElement);
RegisterMode registerMode = GetRegisterMode(registerElement);
string baseClassName = GetRegisterName(prefix, string.Empty);
var properties = new List <RegisterProperty>();
// ------------------------------
// Class declaration
GenerateDescription(code, GetDescription(registerElement));
code.AppendLine($"[Register((byte){registerAddressEnumName}.{name}, {registerLength})]");
code.AppendLine($"public class {className} : {baseClassName}");
code.AppendLine("{");
code.Indent++; // Class
// ------------------------------
// Enum declarations
foreach (XElement element in registerElement.Elements())
{
switch (element.Name.LocalName)
{
case "Enum":
GenerateEnum(code, registerMode, registerLength, properties, element, false);
break;
case "Flags":
GenerateEnum(code, registerMode, registerLength, properties, element, true);
break;
case "Number":
GenerateNumber(code, registerMode, registerLength, properties, element);
break;
}
}
bool oneByteRegister = (properties.Count == 1) && (properties[0].Type == "byte");
const string oneByteRegisterParamName = "value";
// ------------------------------
// Constructor taking bytes as parameters
var byteParameterNames = new List <string>();
if (registerLength == 1)
{
byteParameterNames.Add(oneByteRegister ? oneByteRegisterParamName : "registerValue");
}
else
{
for (int i = 0; i < registerLength; i++)
{
byteParameterNames.Add($"registerValue{i + 1}");
}
}
Action <CodeWriter> appendConstructorBody1 = codeWriter =>
{
foreach (RegisterProperty property in properties)
{
property.AppendPropertyAssigmentValidation(codeWriter, oneByteRegister ? oneByteRegisterParamName : property.ParamName);
}
AppendVerboseComment(codeWriter, "Assigning properties.");
foreach (RegisterProperty property in properties)
{
codeWriter.AppendLine($"{property.PropertyName} = {(oneByteRegister ? oneByteRegisterParamName : property.ParamName)};");
}
};
Action <CodeWriter> appendConstructorBody2 = codeWriter =>
{
foreach (RegisterProperty property in properties)
{
property.AppendPropertyAssigmentFromBytes(codeWriter, byteParameterNames.ToArray());
}
};
bool oneByteRegisterOneConstructorBody = false;
if (oneByteRegister)
{
// Special case -- both constructor take just one byte as input.
var cw1 = new CodeWriter(this, true);
var cw2 = new CodeWriter(this, true);
appendConstructorBody1(cw1);
appendConstructorBody2(cw2);
oneByteRegisterOneConstructorBody = cw1.GetAllCode() == cw2.GetAllCode();
if (oneByteRegisterOneConstructorBody)
{
// Both one-byte constructors have the exact same body.
// No need to separate them by type of call.
// ------------------------------
// Constructor taking the enums as parameters
code.AppendLine($"public {className}(byte {oneByteRegisterParamName})");
code.Indent++; // Constructor base
code.AppendLine($": base({registerAddressEnumName}.{name}, {registerLength})");
code.Indent--; // Constructor base
code.AppendLine("{");
code.Indent++; // Constructor body
appendConstructorBody1(code);
code.Indent--; // Constructor body
code.AppendLine("}");
}
else
{
// ------------------------------
// Constructor taking the enums as parameters
code.AppendLine($"public {className}(byte {oneByteRegisterParamName}, bool isRegisterValue)");
code.Indent++; // Constructor base
code.AppendLine($": base({registerAddressEnumName}.{name}, {registerLength})");
code.Indent--; // Constructor base
code.AppendLine("{");
code.Indent++; // Constructor body
code.AppendLine("if (isRegisterValue)");
code.AppendLine("{");
code.Indent++;
appendConstructorBody2(code);
code.Indent--;
code.AppendLine("}");
code.AppendLine("else");
code.AppendLine("{");
code.Indent++;
appendConstructorBody1(code);
code.Indent--;
code.AppendLine("}");
code.Indent--; // Constructor body
code.AppendLine("}");
}
}
else
{
// ------------------------------
// Constructor taking the enums as parameters
code.AppendLine($"public {className}(");
code.Indent++; // Constructor parameters
Iterate(properties, (prop, isLast) =>
{
code.AppendLine($"{prop.Type} {prop.ParamName}{(isLast ? ")" : ",")}");
});
code.AppendLine($": base({registerAddressEnumName}.{name}, {registerLength})");
code.Indent--; // Constructor parameters
code.AppendLine("{");
code.Indent++; // Constructor body
appendConstructorBody1(code);
//foreach (RegisterProperty property in properties)
//{
// property.AppendPropertyAssigmentValidation();
//}
//AppendVerboseComment(code, "Assigning properties.");
//foreach (RegisterProperty property in properties)
//{
// code.AppendLine($"{property.PropertyName} = {property.ParamName};");
//}
code.Indent--; // Constructor body
code.AppendLine("}");
code.AppendLine();
code.AppendLine($"public {className}({string.Join(", ", byteParameterNames.Select(x => "byte " + x))})");
code.Indent++; // Constructor base call
code.AppendLine($": base({registerAddressEnumName}.{name}, {registerLength})");
code.Indent--; // Constructor base call
code.AppendLine("{");
code.Indent++; // Constructor body
appendConstructorBody2(code);
//foreach (RegisterProperty property in properties)
//{
// property.AppendPropertyAssigmentFromBytes(byteParameterNames.ToArray());
//}
code.Indent--; // Constructor body
code.AppendLine("}");
}
// ------------------------------
// Constructor from byte-array
List <string> createFromBytesArguments = byteParameterNames.Select((x, i) => $"registerValues[{i}]").ToList();
if (oneByteRegister && !oneByteRegisterOneConstructorBody)
{
createFromBytesArguments.Add("true");
}
code.AppendLine();
code.AppendLine($"internal {className}(byte[] registerValues)");
code.Indent++; // Constrctor this-call
code.AppendLine($": this({string.Join(", ", createFromBytesArguments)})");
code.Indent--; // Constrctor this-call
code.AppendLine("{");
code.AppendLine("}");
if (registerMode == RegisterMode.ReadWrite)
{
code.AppendLine();
// ------------------------------
// Default register value
GenerateDescription(code, "Reset values.");
List <string> defaultArguments = properties.Select(prop => prop.DefaultValue).ToList();
if (oneByteRegister && !oneByteRegisterOneConstructorBody)
{
defaultArguments.Add("false");
}
if (defaultArguments.Count == 1)
{
code.AppendLine($"public static readonly {className} Default = new {className}({defaultArguments[0]});");
}
else
{
code.AppendLine($"public static readonly {className} Default = new {className}(");
code.Indent++; // Constructor arguments
Iterate(defaultArguments, (defaultArgument, isLast) =>
{
code.AppendLine($"{defaultArgument}{(isLast ? ");" : ",")}");
});
code.Indent--; // Constructor arguments
}
}
// ------------------------------
// Property declarations
foreach (RegisterProperty prop in properties)
{
code.AppendLine();
GenerateDescription(code, prop.Description);
code.AppendLine($"public {prop.Type} {prop.PropertyName} {{ get; }}");
}
// ------------------------------
// Abstract method: GetAsBytes
code.AppendLine();
code.AppendLine("internal override byte[] GetAsBytes()");
code.AppendLine("{");
code.Indent++; // Method body
string[][] getAsBytesMap = properties.Select(p => p.GetByteIndexAsByteStrings()).ToArray();
var getAsBytesList = new List <string>();
for (int i = 0; i < registerLength; i++)
{
//string[] getAsBytes = getAsBytesMap[i];
string[] getAsBytes = getAsBytesMap.Select(x => x[i]).Where(x => !string.IsNullOrEmpty(x)).ToArray();
//string[] getAsBytes = properties.Select(p => p.GetByteIndexAsByteString(i)).Where(x => !string.IsNullOrEmpty(x)).ToArray();
string getByte;
if (getAsBytes.Length == 0)
{
getByte = "(byte)0";
}
else if (getAsBytes.Length == 1)
{
getByte = getAsBytes[0];
}
else
{
getByte = $"(byte)({string.Join(" | ", getAsBytes)})";
}
getAsBytesList.Add(getByte);
}
if (getAsBytesList.Count == 1)
{
code.AppendLine($"return new[] {{ {getAsBytesList[0]} }};");
}
else
{
code.AppendLine("return new[]");
code.AppendLine("{");
code.Indent++; // Array content
Iterate(getAsBytesList, (codeLine, isLast) => code.AppendLine(codeLine + (isLast ? string.Empty : ",")));
code.Indent--; // Array content
code.AppendLine("};");
}
//code.AppendLine("throw new NotImplementedException();");
code.Indent--; // Method body
code.AppendLine("}");
// ------------------------------
code.Indent--; // Class
code.AppendLine("}");
}
/// <summary>
/// Creates an instance of the attribute
/// </summary>
/// <param name="mode">register call condition</param>
public RegisterFunctionAttribute(RegisterMode mode)
{
Value = mode;
}
[TestCase(0xCC, 0xFF, 0x00, RegisterMode.YRegister)] //CPY Absolute
public void Absolute_Modes_Compare_Operation_Has_Correct_Result(byte operation, byte accumulatorValue, byte memoryValue, RegisterMode mode)
{
var processor = new Processor();
byte loadOperation;
switch (mode)
{
case RegisterMode.Accumulator:
loadOperation = 0xA9;
break;
case RegisterMode.XRegister:
loadOperation = 0xA2;
break;
default:
loadOperation = 0xA0;
break;
}
processor.LoadProgram(0, new byte[] { loadOperation, accumulatorValue, operation, 0x05, 0x00, memoryValue }, 0x00);
processor.NextStep();
processor.NextStep();
Assert.That(processor.ZeroFlag, Is.EqualTo(false));
Assert.That(processor.NegativeFlag, Is.EqualTo(true));
Assert.That(processor.CarryFlag, Is.EqualTo(true));
}
public void Transfer_Zero_Value_Set(byte operation, byte value, RegisterMode transferFrom, bool expectedResult)
{
var processor = new Processor();
byte loadOperation;
switch (transferFrom)
{
case RegisterMode.Accumulator:
loadOperation = 0xA9;
break;
case RegisterMode.XRegister:
loadOperation = 0xA2;
break;
default:
loadOperation = 0xA0;
break;
}
processor.LoadProgram(0, new[] { loadOperation, value, operation }, 0x00);
processor.NextStep();
processor.NextStep();
Assert.That(processor.ZeroFlag, Is.EqualTo(expectedResult));
}
public void Transfer_Correct_Value_Set(byte operation, RegisterMode transferFrom, RegisterMode transferTo)
{
var processor = new Processor();
byte loadOperation;
switch (transferFrom)
{
case RegisterMode.Accumulator:
loadOperation = 0xA9;
break;
case RegisterMode.XRegister:
loadOperation = 0xA2;
break;
default:
loadOperation = 0xA0;
break;
}
processor.LoadProgram(0, new[] { loadOperation, (byte)0x03, operation }, 0x00);
processor.NextStep();
processor.NextStep();
switch (transferTo)
{
case RegisterMode.Accumulator:
Assert.That(processor.Accumulator, Is.EqualTo(0x03));
break;
case RegisterMode.XRegister:
Assert.That(processor.XRegister, Is.EqualTo(0x03));
break;
default:
Assert.That(processor.YRegister, Is.EqualTo(0x03));
break;
}
}
public static IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle> RegisterInstance <T>(this ContainerBuilder builder, T instance, RegisterMode mode, string name) where T : class
{
var rb = builder.RegisterInstance <T>(instance);
if ((RegisterMode.Self & mode) == RegisterMode.Self)
{
if (!string.IsNullOrEmpty(name))
{
rb.Named(name, instance.GetType());
}
else
{
rb.AsSelf();
}
}
if ((RegisterMode.DefaultInterface & mode) == RegisterMode.DefaultInterface)
{
rb.AsImplementedInterfaces();
}
else if ((RegisterMode.Interface & mode) == RegisterMode.Interface)
{
rb.AsImplementedInterfaces().PreserveExistingDefaults();
}
return(rb);
}
public static IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> RegisterType(this ContainerBuilder builder, Type type, RegisterMode mode, string name)
{
var rb = builder.RegisterType(type);
if ((RegisterMode.Self & mode) == RegisterMode.Self)
{
if (!string.IsNullOrEmpty(name))
{
rb.Named(name, type);
}
else
{
rb.AsSelf();
}
}
if ((RegisterMode.DefaultInterface & mode) == RegisterMode.DefaultInterface)
{
rb.AsImplementedInterfaces();
}
else if ((RegisterMode.Interface & mode) == RegisterMode.Interface)
{
rb.AsImplementedInterfaces().PreserveExistingDefaults();
}
return(rb);
}
public void RegisterType <T>(LifeCycle lifeCycle = LifeCycle.Transient, RegisterMode mode = RegisterMode.Self, string name = "")
{
this.RegisterType(typeof(T), lifeCycle, mode, name);
}
private void SendBytes(int data, RegisterMode mode)
{
RegisterSelectPin.Write((GpioPinValue)mode);
// In 4-bit mode, we'll write the high bits to data pins 4-7,
// then toggle the enable pin, then write the low bits to 4-7
ClearDataPins();
WriteHighIfData(data, 0x10, DataBusPin4);
WriteHighIfData(data, 0x20, DataBusPin5);
WriteHighIfData(data, 0x40, DataBusPin6);
WriteHighIfData(data, 0x80, DataBusPin7);
ToggleEnablePin();
ClearDataPins();
WriteHighIfData(data, 0x01, DataBusPin4);
WriteHighIfData(data, 0x02, DataBusPin5);
WriteHighIfData(data, 0x04, DataBusPin6);
WriteHighIfData(data, 0x08, DataBusPin7);
ToggleEnablePin();
}
//* Executa o iRPC na instância específicada.
#pragma warning disable IDE1006
protected void iRPCHandler(byte rpcId, short viewId, byte instanceId, byte[] parameters, NeutronPlayer player, RegisterMode registerMode)
#pragma warning restore IDE1006
{
void Run((int, int, RegisterMode) key) //* a key do objeto, o primeiro parâmetro é o ID do jogador ou do Objeto de Rede ou 0(se for objeto de cena), e o segundo é o ID do objeto, e o terceiro é o tipo de objeto.
{
if (MatchmakingHelper.Server.GetNetworkObject(key, This.LocalPlayer, out NeutronView neutronView)) //* Obtém a instância que enviou o RPC para a rede.
{
if (neutronView.iRPCs.TryGetValue((rpcId, instanceId), out RPCInvoker remoteProceduralCall)) //* Obtém o RPC com o ID enviado para a rede.
{
try
{
//* Executa o RPC, observe que isto não usa reflexão, reflexão é lento irmão, eu uso delegados, e a reflexão para criar os delegados em runtime no Awake do objeto, bem rápido, e funciona no IL2CPP.
ReflectionHelper.iRPC(parameters, remoteProceduralCall, player);
}
catch (Exception ex)
{
LogHelper.Stacktrace(ex);
}
}
else
{
LogHelper.Warn("Ignore this: iRpc with this Id not found.");
}
}
[TestCase(0x8C, 0x03, RegisterMode.YRegister)] // STY Zero Page
public void Absolute_Mode_Memory_Has_Correct_Result(byte operation, byte valueToLoad, RegisterMode mode)
{
var processor = new Processor();
byte loadOperation;
switch (mode)
{
case RegisterMode.Accumulator:
loadOperation = 0xA9;
break;
case RegisterMode.XRegister:
loadOperation = 0xA2;
break;
default:
loadOperation = 0xA0;
break;
}
processor.LoadProgram(0, new byte[] { loadOperation, valueToLoad, operation, 0x04 }, 0x00);
processor.NextStep();
processor.NextStep();
Assert.That(processor.Memory.ReadValue(0x04), Is.EqualTo(valueToLoad));
}
/// <summary>
/// Creates an instance of the attribute
/// </summary>
/// <param name="mode">register call condition</param>
public RegisterFunctionAttribute(RegisterMode mode)
{
Value = mode;
}
#pragma warning disable IDE1006
protected void iRPCHandler(NeutronPlayer owner, NeutronPlayer sender, short viewId, byte rpcId, byte instanceId, byte[] buffer, RegisterMode registerType, TargetTo targetTo, CacheMode cache, Protocol protocol)
#pragma warning restore IDE1006
{
void Run((int, int, RegisterMode) key)
{
bool Send()
{
MatchmakingTo matchmakingTo = MatchmakingTo.Auto;
if (targetTo == TargetTo.Me)
{
matchmakingTo = MatchmakingTo.Me;
}
using (NeutronStream stream = Neutron.PooledNetworkStreams.Pull())
{
NeutronStream.IWriter writer = stream.Writer;
writer.WritePacket((byte)Packet.iRPC);
writer.WritePacket((byte)registerType);
writer.Write(viewId);
writer.Write(rpcId);
writer.Write(instanceId);
writer.WriteNext(buffer);
MatchmakingHelper.Internal.AddCache(rpcId, viewId, writer, owner, cache, CachedPacket.iRPC);
owner.Write(sender, writer, targetTo, matchmakingTo, protocol);
}
return(true);
}
if (MatchmakingHelper.Server.GetNetworkObject(key, owner, out NeutronView neutronView))
{
if (neutronView.iRPCs.TryGetValue((rpcId, instanceId), out RPCInvoker remoteProceduralCall))
{
try
{
iRPCAttribute iRPCAttribute = remoteProceduralCall.iRPC;
if (ReflectionHelper.iRPC(buffer, remoteProceduralCall, owner))
{
Send();
}
}
catch (Exception ex)
{
LogHelper.Stacktrace(ex);
}
}
else
{
Send();
}
}
public RegisterViewModel(RegisterMode mode)
{
Mode = mode;
}
public RegisterLoad(RegisterMode _mode, string _priority_key, Type _contract_type, Type _concrete_type, object _concrete_instance, TransientCreationLevel _transient_level = TransientCreationLevel.None) : base(_priority_key, _contract_type, _concrete_type, _transient_level)
{
concrete_instance = _concrete_instance;
mode = _mode;
}
private void GenerateNumber(
CodeWriter code,
RegisterMode registerMode,
int registerLength,
List <RegisterProperty> properties,
XElement element)
{
string name = GetName(element) ?? "Value";
string paramName = GetLocalName(name);
int byteIndex;
BitsRange bitsRange = GetBitsRange(element, registerLength, null, out byteIndex);
uint defaultValue;
if (registerMode == RegisterMode.ReadWrite)
{
defaultValue = ConvertToInteger(element.Attribute("default")?.Value) << bitsRange.FromBits;
}
else
{
defaultValue = 0;
}
string integerType = GetIntegerType(bitsRange);
Action <CodeWriter, string> appendPropertyAssigmentValidation = (codeWriter, actualParamName) =>
{
uint integerTypeMaxValue = GetIntegerTypeMaxValue(bitsRange);
if (integerTypeMaxValue != bitsRange.MaxValue)
{
AppendVerboseComment(codeWriter, "Validating the numerical range.");
codeWriter.AppendLine($"if ({actualParamName} > {ToHex(bitsRange.MaxValue, bitsRange.NibbleCount)})");
codeWriter.AppendLine("{");
codeWriter.Indent++;
codeWriter.AppendLine($"throw new ArgumentException($\"{{nameof({actualParamName})}} must be in the range of [{ToHex(0, bitsRange.NibbleCount)} - {ToHex(bitsRange.MaxValue, bitsRange.NibbleCount)}].\");");
codeWriter.Indent--;
codeWriter.AppendLine("}");
codeWriter.AppendLine();
}
};
Action <CodeWriter, string[]> appendPropertyAssigmentFromBytes = (codeWriter, byteParameterNames) =>
{
AppendVerboseComment(codeWriter, "Assigning the composed numerical value.");
string composedValue = GetComposedValue(bitsRange, registerLength, byteIndex, byteParameterNames);
codeWriter.AppendLine($"{name} = {composedValue};");
};
Func <string[]> getByteIndexAsByteStrings = () =>
GetDecomposedValues(name, bitsRange, registerLength, byteIndex, true);
properties.Add(new RegisterProperty(
PropertyType.Numeric,
registerMode,
name,
paramName,
integerType,
ToHex(defaultValue, bitsRange.NibbleCount),
GetDescription(element),
appendPropertyAssigmentValidation,
appendPropertyAssigmentFromBytes,
getByteIndexAsByteStrings,
byteIndex));
}
public void Register <T>(Func <T> creator, LifeCycle lifeCycle = LifeCycle.Transient, RegisterMode mode = RegisterMode.Self, string name = "") where T : class
{
var builder = new ContainerBuilder();
builder.Register <T>(creator, mode, name).UseLifeCycle(lifeCycle);
builder.Update(_container);
}
