public IEnumerable <IField> ToFields(ModuleJson module, ModuleOffset offset)
{
AssertNotNull(ResolvedName);
AssertNotNull(ResolvedDescription);
if (Repeat is null)
{
yield return(ToField(module, ResolvedName, ResolvedDescription, offset));
}
else
{
Preconditions.AssertNotNull(Repeat.Items);
var variables = SchemaVariables.Empty;
int?gap = Repeat.Gap?.Value;
foreach (var tuple in module.GetRepeatSequence(Repeat.Items, variables))
{
var itemVariables = variables.WithVariable(Repeat.IndexVariable, tuple.index);
var formattedDescription = tuple.variables.Replace(ResolvedDescription);
var formattedName = Invariant($"{ResolvedName}[{tuple.index}]");
var field = ToField(module, formattedName, formattedDescription, offset);
yield return(field);
offset += gap ?? field.Size;
}
}
}
internal IEnumerable <IContainer> ToContainers(ModuleSchema schema, ModuleJson module, ModuleAddress parentAddress, string?parentPath, SchemaVariables variables)
{
variables = variables.WithVariables(ExtraVariables);
ModuleOffset offset = ModuleOffset.FromDisplayValue(Offset.Value);
if (Repeat is null)
{
yield return(resolvedContainer.ToContainer(schema, module, ResolvedName, ResolvedDescription,
parentAddress + offset, parentPath, variables));
}
else
{
int gap = ModuleOffset.FromDisplayValue(Repeat.Gap.Value).LogicalValue;
foreach (var tuple in module.GetRepeatSequence(Repeat.Items, variables))
{
var itemVariables = variables.WithVariable(Repeat.IndexVariable, tuple.index, Repeat.IndexTemplate);
var formattedDescription = tuple.variables.Replace(ResolvedDescription);
var formattedName = Invariant($"{ResolvedName}[{tuple.index}]");
yield return(resolvedContainer.ToContainer(schema, module, formattedName, formattedDescription,
parentAddress + offset, parentPath, itemVariables));
offset += gap;
}
}
}
private IReadOnlyList <FieldBase> ResolveFields(ModuleJson module)
{
var resolved = new List <FieldBase>();
foreach (var field in Fields)
{
resolved.AddRange(field.ToFields(module, CurrentSize()));
}
var actualSize = CurrentSize().LogicalValue;
var expectedSize = ModuleOffset.FromDisplayValue(Size.Value).LogicalValue;
if (actualSize != expectedSize)
{
throw new InvalidOperationException(
$"Incorrect size in container {NameInModuleDictionary}: expected {expectedSize}; was {actualSize}");
}
// Skip placeholder fields so they're never exposed.
return(resolved.Where(field => !(field is PlaceholderField)).ToReadOnlyList());
ModuleOffset CurrentSize()
{
var field = resolved.LastOrDefault();
return(field?.Offset + field?.Size ?? ModuleOffset.Zero);
}
}
public ModuleInfoViewModel(ModuleInfo mode, ModuleOffset offset, EcalVar ecalData, double[] egain, double[] mlpegain, ModulePMTOrderInfo pmtOrder, string csvFileLUT, int moduleNumber = 0)
{
Offset = offset;
this.ModuleNum = moduleNumber;
EcalInfos = new ObservableCollection <EcalInfo>();
EcalInfos.Add(new EcalInfo(60, 60, "Am-241"));
EcalInfos.Add(new EcalInfo(662, 662, "Cs-137"));
EcalInfos.Add(new EcalInfo(511, 511, "Na-22"));
EcalInfos.Add(new EcalInfo(1275, 1275, "Na-22"));
EcalInfos.Add(new EcalInfo(1173, 1173, "Co-60"));
EcalInfos.Add(new EcalInfo(1332, 1332, "Co-60"));
EcalEquationInfoA = ecalData.a;
EcalEquationInfoB = ecalData.b;
EcalEquationInfoC = ecalData.c;
LUTCSVFileLink = csvFileLUT;
EnergyGain = new ObservableCollection <double>(egain);
MLPEGain = new ObservableCollection <double>(mlpegain);
try
{
Module = new LACC_Module(mode,
offset,
ecalData,
egain,
mlpegain,
pmtOrder,
csvFileLUT,
moduleNum);
IsModuleSet = true;
}
catch
{
IsModuleSet = false;
}
}
internal FieldBase ToField(ModuleJson module, string name, string description, ModuleOffset offset)
{
return(Type switch
{
"boolean" => new BooleanField(null, BuildCommon(1), NumericCodec.Range8, GetDefaultValue()),
"boolean32" => new BooleanField(null, BuildCommon(4), NumericCodec.Range32, GetDefaultValue()),
string ph when ph.StartsWith("placeholder") => new PlaceholderField(null, BuildCommon(int.Parse(ph.Substring("placeholder".Length)) / 8)),
"enum" => BuildEnumField(NumericCodec.Range8),
"enum16" => BuildEnumField(NumericCodec.Range16),
"enum24" => BuildEnumField(NumericCodec.Full24),
"enum32" => BuildEnumField(NumericCodec.Range32),
"instrument" => new InstrumentField(null, BuildCommon(4), ModuleOffset.FromDisplayValue(ValidateNotNull(BankOffset, nameof(BankOffset)).Value)),
"midi32" => new NumericField(null, BuildCommon(4), 0, 128, Default ?? 0, NumericCodec.Range32, null, null, null, null, (128, "Off")),
"overlay" => BuildOverlay(),
"range8" => BuildNumericField(NumericCodec.Range8),
"range16" => BuildNumericField(NumericCodec.Range16),
"urange16" => BuildNumericField(NumericCodec.URange16),
"range32" => BuildNumericField(NumericCodec.Range32),
"string" => BuildStringField(1),
"string16" => BuildStringField(2),
"tempo" => BuildTempoField(),
"volume32" => new NumericField(null, BuildCommon(4), -601, 60, 0, NumericCodec.Range32, 10, null, 0, "dB", (-601, "-INF")),
"fixme_enum32" => BuildEnumField(NumericCodec.Fixme32),
"fixme_range32" => BuildNumericField(NumericCodec.Fixme32),
"fixme_boolean32" => new BooleanField(null, BuildCommon(4), NumericCodec.Fixme32, GetDefaultValue()),
_ => throw new InvalidOperationException($"Invalid field type: '{Type}'")
});
public IContainer ToContainer(ModuleSchema schema, ModuleJson module, string name, string description, ModuleAddress address, string?parentPath, SchemaVariables variables)
{
string path = PathUtilities.AppendPath(parentPath, name);
if (Fields is object)
{
var fieldList = requiresOverlayResolution ? resolvedFields.Select(FinalizeField) : resolvedFields;
var realSize = ModuleOffset.FromDisplayValue(Size.Value).LogicalValue;
return(new FieldContainer(schema, name, description, address, path, realSize, fieldList));
FieldBase FinalizeField(FieldBase field) =>
field is OverlayField overlay?overlay.WithPath(variables.Replace(overlay.SwitchPath)) : field;
}
else
{
var containers = new List <IContainer>();
foreach (var container in Containers)
{
containers.AddRange(container.ToContainers(schema, module, address, path, variables));
}
return(new ContainerContainer(schema, name, description, address, path, containers));
}
}
private IField ToField(ModuleJson module, string name, string description, ModuleOffset offset)
{
return(Type switch
{
"boolean" => new BooleanField(BuildCommon(1)),
"boolean32" => new BooleanField(BuildCommon(4)),
"placeholder8" => new PlaceholderField(BuildCommon(1)),
"placeholder16" => new PlaceholderField(BuildCommon(2)),
"placeholder32" => new PlaceholderField(BuildCommon(4)),
"enum" => BuildEnumField(1),
"enum16" => BuildEnumField(2),
"enum32" => BuildEnumField(4),
"instrument" => new InstrumentField(BuildCommon(4), ModuleOffset.FromDisplayValue(ValidateNotNull(BankOffset, nameof(BankOffset)).Value)),
"midi32" => new NumericField(BuildCommon(4), 0, 128, 0, null, null, null, null, (128, "Off")),
"overlay" => BuildOverlay(),
"range8" => BuildNumericField(1),
"range16" => BuildNumericField(2),
"range32" => BuildNumericField(4),
"string" => BuildStringField(1),
"string16" => BuildStringField(2),
"tempo" => BuildTempoField(),
"volume32" => new NumericField(BuildCommon(4), -601, 60, 0, 10, null, 0, "dB", (-601, "-INF")),
_ => throw new InvalidOperationException($"Invalid field type: '{Type}'")
});
internal IField ToFieldForOverlay(ModuleJson module, ModuleOffset offset)
{
AssertNotNull(ResolvedName);
Validate(Repeat is null, "Repeated fields are not valid in overlays");
return(ToField(module, AssertNotNull(ResolvedName), AssertNotNull(ResolvedDescription), offset));
}
internal InstrumentField(FieldContainer?parent, FieldParameters common, ModuleOffset bankOffset) : base(parent, common) =>
public FieldParameters(string name, string description, ModuleOffset offset, int size) => (Name, Description, Offset, Size) = (name, description, offset, size);
internal InstrumentField(Parameters common, ModuleOffset bankOffset) : base(common) =>
