public GeneratorDialog(My_Variable variable, GeneratorType genType)
{
InitializeComponent();
this.GenSettings = ModellingType.GetGeneratorSettings(variable.Signal.Type);
switch (genType)
{
case GeneratorType.Constant:
TabControlGenerator.SelectedItem = TabItemConstantGenerator;
break;
case GeneratorType.Clock:
TabControlGenerator.SelectedItem = TabItemClockGenerator;
break;
case GeneratorType.Counter:
TabControlGenerator.SelectedItem = TabItemCounterGenerator;
break;
case GeneratorType.DiscretteRandom:
TabControlGenerator.SelectedItem = TabItemRandomGeneratorDiscrette;
break;
case GeneratorType.ContinousRandom:
TabControlGenerator.SelectedItem = TabItemRandomGeneratorContinuous;
break;
default:
break;
}
}
/// <summary>
/// Функция, которая возвращает класс, отвечающий за отображение
/// </summary>
/// <param name="Variable"></param>
/// <param name="ScaleManager"></param>
/// <returns></returns>
public static SignalViewBase GetSignalViewer(My_Variable Variable, ScaleManager ScaleManager)
{
ModellingType type = Variable.Signal.Type;
if (type.Type is IntegerType)
{
return(new INTEGER_View(Variable.Signal.Dump as SimpleSignalDump, ScaleManager));
}
if (type.Type is RealType)
{
return(new Real_View(Variable.Signal.Dump as SimpleSignalDump, ScaleManager));
}
if (type.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC)
{
return(new STD_LOGIC_View(Variable.Signal.Dump as SimpleSignalDump, ScaleManager));
}
if (type.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC_VECTOR)
{
return(new STD_LOGIC_VECTOR_View(Variable.Signal.Dump as SignalScopeDump, ScaleManager));
}
if (type.Type == VHDL.builtin.StdLogic1164.STD_LOGIC_VECTOR)
{
return(new STD_LOGIC_VECTOR_View(Variable.Signal.Dump as SignalScopeDump, ScaleManager));
}
if (type.Type is RecordType)
{
return(new CompositeDataTypeView(Variable.Signal.Dump as SignalScopeDump, ScaleManager));
}
if (type.Type is ArrayType)
{
return(new CompositeDataTypeView(Variable.Signal.Dump as SignalScopeDump, ScaleManager));
}
return(null);
}
public Signal(ModellingType type, VHDL.Object.Signal parsedVariable)
{
this.parsedVariable = parsedVariable;
this.name = parsedVariable.Identifier;
this.type = type;
dump = new SimpleSignalDump(parsedVariable.Identifier, type);
InitChildrens();
InitValue();
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public RecordValue(ModellingType type, IList <AbstractValue> _value)
: base(type)
{
if (type.Type is VHDL.type.RecordType)
{
CreateRecordValue(type.Type as VHDL.type.RecordType, _value);
}
else
{
throw new Exception("Invalid type");
}
}
public Signal(ModellingType type, VHDL.Object.Signal parsedVariable, List <AbstractSignalDump> dumps)
{
this.parsedVariable = parsedVariable;
this.name = parsedVariable.Identifier;
this.type = type;
if ((type.Type is VHDL.type.RecordType) || (type.Type is VHDL.type.ArrayType))
{
dump = new SignalScopeDump(parsedVariable.Identifier, type, dumps);
}
InitChildrens();
InitValue();
}
public NewSortedDictionaryScopeIterator(SignalScopeDump dump)
{
this.Dump = dump;
this.Type = dump.Type;
iterators = new List <IValueIterator>();
foreach (AbstractSignalDump d in dump.Dumps)
{
IValueIterator i = d.Iterator;
i.Reset();
iterators.Add(i);
}
}
/// <summary>
/// Создание объекта составного типа с набора его элементов
/// </summary>
/// <param name="type"></param>
/// <param name="_values"></param>
/// <returns></returns>
public static CompositeValue CreateCompositeValue(ModellingType type, IList <AbstractValue> _values)
{
if (type.Type is VHDL.type.ArrayType)
{
if (type.Type == VHDL.builtin.StdLogic1164.STD_LOGIC_VECTOR)
{
return(new STD_LOGIC_VECTOR_VALUE(_values));
}
if (type.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC_VECTOR)
{
return(new STD_ULOGIC_VECTOR_VALUE(_values));
}
if (type.Type == VHDL.builtin.Standard.BIT_VECTOR)
{
return(new BIT_VECTOR_VALUE(_values));
}
return(new ArrayValue(type, _values));
}
if (type.Type is VHDL.type.RecordType)
{
return(new RecordValue(type, _values));
}
throw new ArgumentException("Invalid Argument", "type");
}
public static Signal CreateSignal(ModellingType type, string identifier)
{
return(new Signal(type, new VHDL.Object.Signal(identifier, type.Type)));
}
public SignalScopeDump(string name, ModellingType type, List <AbstractSignalDump> dumps)
: base(name, type)
{
this.dumps = dumps;
}
public AbstractSignalDump(string name, ModellingType type)
{
this.type = type;
this.name = name;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public CompositeValue(ModellingType type)
: base(type)
{
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public ArrayValue(VHDL.type.UnconstrainedArray type, ResolvedDiscreteRange range)
: base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { range }))
{
_values = CreateDictionary(range);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public ArrayValue(VHDL.type.UnconstrainedArray type, IList <AbstractValue> _value)
: base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { ResolvedDiscreteRange.FormIntegerIndexes(_value.Count) }))
{
_values = CreateDictionary(_value);
}
public RealAbstractValueConvertor(ModellingType modellingType)
: base(modellingType)
{
}
public IntegerAbstractValueConvertor(ModellingType modellingType)
: base(modellingType)
{
}
public AbstractValueConvertor(ModellingType modellingType)
{
this.modellingType = modellingType;
}
public STD_LOGIC_AbstractValueConvertor(ModellingType modellingType)
: base(modellingType)
{
}
public EnumerationAbstractValueConvertor(ModellingType modellingType)
: base(modellingType)
{
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="name"></param>
public SimpleSignalDump(string name, ModellingType type)
: base(name, type)
{
}
public static Signal CreateSignal(ModellingType type, string identifier, List <AbstractSignalDump> dumps)
{
return(new Signal(type, new VHDL.Object.Signal(identifier, type.Type), dumps));
}
private static SortedList <UInt64, TimeStampInfo> FormBIT_VECTORGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime, ModellingType modellingType)
{
SortedList <UInt64, TimeStampInfo> res = new SortedList <UInt64, TimeStampInfo>();
int size = modellingType.SizeOf;
if (generator is IGeneratorDataFill <Int64> )
{
SortedList <UInt64, Int64> valuesForInsert = (generator as IGeneratorDataFill <Int64>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(BIT_VECTOR_VALUE.CreateBIT_VECTOR_VALUE(el.Value, size));
res.Add(el.Key, inf);
}
return(res);
}
if (generator is IGeneratorDataFill <bool[]> )
{
SortedList <UInt64, bool[]> valuesForInsert = (generator as IGeneratorDataFill <bool[]>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(BIT_VECTOR_VALUE.CreateBIT_VECTOR_VALUE(el.Value));
res.Add(el.Key, inf);
}
return(res);
}
if (generator is IGeneratorDataFill <Double> )
{
SortedList <UInt64, Double> valuesForInsert = (generator as IGeneratorDataFill <Double>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(BIT_VECTOR_VALUE.CreateBIT_VECTOR_VALUE((Int64)el.Value, size));
res.Add(el.Key, inf);
}
return(res);
}
return(res);
}
public GeneratorDialog(My_Variable variable)
{
InitializeComponent();
this.GenSettings = ModellingType.GetGeneratorSettings(variable.Signal.Type);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public ArrayValue(ModellingType modellingType, IList <AbstractValue> _value)
: base(modellingType)
{
_values = CreateDictionary(_value, modellingType.Dimension);
}
public static SortedList <UInt64, TimeStampInfo> FormGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime, ModellingType modellingType)
{
SortedList <UInt64, TimeStampInfo> res = new SortedList <UInt64, TimeStampInfo>();
if (modellingType.Type is IntegerType)
{
return(FormIntegerGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type is RealType)
{
return(FormRealGeneratedData(generator, StartTime, EndTime, modellingType));
}
if ((modellingType.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC) && (modellingType.Constraints.Count != 0))
{
return(FormSTD_LOGICGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC)
{
return(FormSTD_ULOGICGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type == VHDL.builtin.Standard.BIT)
{
return(FormBitGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type is EnumerationType)
{
return(FormEnumerationGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type == VHDL.builtin.StdLogic1164.STD_LOGIC_VECTOR)
{
return(FormSTD_LOGIC_VECTORGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type == VHDL.builtin.StdLogic1164.STD_ULOGIC_VECTOR)
{
return(FormSTD_ULOGIC_VECTORGeneratedData(generator, StartTime, EndTime, modellingType));
}
if (modellingType.Type == VHDL.builtin.Standard.BIT_VECTOR)
{
return(FormBIT_VECTORGeneratedData(generator, StartTime, EndTime, modellingType));
}
return(res);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public ArrayValue(VHDL.type.UnconstrainedArray type, Dictionary <int[], AbstractValue> dictionary)
: base(ModellingType.CreateModellingType(type, new ResolvedDiscreteRange[] { ResolvedDiscreteRange.FormIntegerIndexes(dictionary.Count) }))
{
_values = dictionary;
}
private static SortedList <UInt64, TimeStampInfo> FormBitGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime, ModellingType modellingType)
{
SortedList <UInt64, TimeStampInfo> res = new SortedList <UInt64, TimeStampInfo>();
if (generator is IGeneratorDataFill <bool> )
{
SortedList <UInt64, bool> valuesForInsert = (generator as IGeneratorDataFill <bool>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(new BIT_VALUE(el.Value ? VHDL.builtin.Standard.BIT_1 : VHDL.builtin.Standard.BIT_0));
res.Add(el.Key, inf);
}
return(res);
}
if (generator is IGeneratorDataFill <object> )
{
SortedList <UInt64, object> valuesForInsert = (generator as IGeneratorDataFill <object>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
if (el.Value is string)
{
TimeStampInfo inf = new TimeStampInfo(new BIT_VALUE((el.Value as string == "1") ? VHDL.builtin.Standard.BIT_1 : VHDL.builtin.Standard.BIT_0));
res.Add(el.Key, inf);
}
if (el.Value is EnumerationLiteral)
{
TimeStampInfo inf = new TimeStampInfo(new BIT_VALUE(el.Value as EnumerationLiteral));
res.Add(el.Key, inf);
}
}
return(res);
}
return(res);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="type"></param>
public ArrayValue(ModellingType modellingType)
: base(modellingType)
{
_values = CreateDictionary(modellingType.Dimension);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="name"></param>
public AbstractSimpleSignalDump(string name, ModellingType type)
: base(name, type)
{
dump = new NewSortedDictionary <AbstractTimeStampInfo <T> >();
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="name"></param>
public AbstractSimpleSignalDump(string name, ModellingType type, AbstractValueConvertor <T> valueCovertor)
: base(name, type)
{
this.valueCovertor = valueCovertor;
dump = new NewSortedDictionary <AbstractTimeStampInfo <T> >();
}
private static SortedList <UInt64, TimeStampInfo> FormRealGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime, ModellingType modellingType)
{
SortedList <UInt64, TimeStampInfo> res = new SortedList <UInt64, TimeStampInfo>();
if (generator is IGeneratorDataFill <Int64> )
{
SortedList <UInt64, Int64> valuesForInsert = (generator as IGeneratorDataFill <Int64>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(new RealValue(VHDL.builtin.Standard.REAL, Convert.ToDouble(el.Value)));
res.Add(el.Key, inf);
}
return(res);
}
if (generator is IGeneratorDataFill <bool[]> )
{
SortedList <UInt64, bool[]> valuesForInsert = (generator as IGeneratorDataFill <bool[]>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(new RealValue(VHDL.builtin.Standard.REAL, DataContainer.ValueDump.DataConvertorUtils.ToInt(el.Value)));
res.Add(el.Key, inf);
}
return(res);
}
if (generator is IGeneratorDataFill <Double> )
{
SortedList <UInt64, Double> valuesForInsert = (generator as IGeneratorDataFill <Double>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(new RealValue(VHDL.builtin.Standard.REAL, Convert.ToDouble(el.Value)));
res.Add(el.Key, inf);
}
return(res);
}
return(res);
}
