/// <summary>
/// Добавлене данных в конец дампа
/// </summary>
/// <param name="CurrentTime"></param>
/// <param name="value"></param>
public void AppendValue(UInt64 CurrentTime, AbstractValue value)
{
using (TimeStampInfo ts = new TimeStampInfo(value))
{
AppendValue(CurrentTime, ts);
}
}
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);
}
public void Reset()
{
foreach (var i in iterators)
{
i.Reset();
}
UInt64 Current = default(UInt64);
bool IsSet = false;
foreach (var iter in iterators)
{
if (
(iter.IsEndOfIteration == false) && (((Current > iter.LastEvent) || (IsSet == false)))
)
{
IsSet = true;
Current = iter.LastEvent;
}
}
//Заполнение данных
lastEvent = Current;
currentValue = CreateTimeStampInfo();
}
/// <summary>
/// Формирование информации о текущем моменте времени
/// </summary>
/// <returns></returns>
private TimeStampInfo CreateTimeStampInfo()
{
List <TimeStampInfo> components = new List <TimeStampInfo>();
foreach (var i in iterators)
{
components.Add(i.CurrentValue);
}
return(TimeStampInfo.CombineTimestamps(Type, components));
}
/// <summary>
/// Получение данных о моменте времени
/// </summary>
/// <param name="Time"></param>
/// <returns></returns>
public override TimeStampInfo GetValue(UInt64 Time)
{
List <TimeStampInfo> res = new List <TimeStampInfo>();
foreach (AbstractSignalDump d in dumps)
{
res.Add(d.GetValue(Time));
}
return(TimeStampInfo.CombineTimestamps(Type, res));
}
public virtual AbstractTimeStampInfo <T> GetAbstractTimeStampInfo(TimeStampInfo value)
{
Dictionary <int, T> info = new Dictionary <int, T>();
foreach (KeyValuePair <int, AbstractValue> i in value)
{
info.Add(i.Key, GetValue(i.Value));
}
return(new AbstractTimeStampInfo <T>(info));
}
public void SetCurrentIndexByKey(ulong Time)
{
foreach (var i in iterators)
{
i.SetCurrentIndexByKey(Time);
i.MoveNext();
}
lastEvent = Time;
currentValue = CreateTimeStampInfo();
}
/// <summary>
/// Добавление данных в конец дампа
/// </summary>
/// <param name="CurrentTime"></param>
/// <param name="value"></param>
public override void AppendValue(ulong CurrentTime, TimeStampInfo value)
{
List <TimeStampInfo> info = TimeStampInfo.SplitTimestamps(Type, value);
for (int i = 0; i < dumps.Count; i++)
{
dumps[i].AppendValue(CurrentTime, info[i]);
}
foreach (TimeStampInfo i in info)
{
i.Dispose();
}
}
private static SortedList <UInt64, TimeStampInfo> FormEnumerationGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime, ModellingType modellingType)
{
SortedList <UInt64, TimeStampInfo> res = new SortedList <UInt64, TimeStampInfo>();
if (generator is IGeneratorDataFill <object> )
{
SortedList <UInt64, object> valuesForInsert = (generator as IGeneratorDataFill <object>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo inf = new TimeStampInfo(new EnumerationValue(modellingType.Type as VHDL.type.EnumerationType, el.Value as EnumerationLiteral));
res.Add(el.Key, inf);
}
return(res);
}
return(res);
}
void CursorViewer_CursorPositionChangedEvent()
{
UInt64 time = CursorViewer.Time;
if (time < ScaleManager.EndTime)
{
TimeStampInfo inf = Variable.Signal.Dump.GetValue(time);
string value = "<NULL>";
if (inf != null)
{
value = DataContainer.ValueDump.DataConvertorUtils.ToString(inf.LastValue, Variable.DataRepresentation);
}
Variable.CursorValue = value;
}
else
{
Variable.CursorValue = "?";
}
UpdateSelection();
}
/// <summary>
/// Сформировать текущее значение, исходя из значений итераторов
/// </summary>
protected void FormCurrentValue(ulong CurrentTime)
{
SortedDictionary <int, List <AbstractValue> > data = TimeStampInfo.CombineTimestamps(iterators);
//Заполнение данных
CurrentValue.Clear();
foreach (KeyValuePair <int, List <AbstractValue> > v in data)
{
string[] values = new string[iterators.Count + 3];
values[0] = (CurrentIndex + 1).ToString();
values[1] = TimeInterval.ToString(CurrentTime);
values[2] = v.Key.ToString();
for (int i = 0; i < v.Value.Count; i++)
{
values[i + 3] = DataContainer.ValueDump.DataConvertorUtils.ToString(v.Value[i], iterators[i].DataRepresentation);
}
CurrentValue.Add(values);
}
}
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 override void InsertValues(SortedList <UInt64, TimeStampInfo> data, UInt64 StartTime, UInt64 EndTime)
{
Dictionary <AbstractSignalDump, SortedList <UInt64, TimeStampInfo> > insData = new Dictionary <AbstractSignalDump, SortedList <UInt64, TimeStampInfo> >();
foreach (AbstractSignalDump d in dumps)
{
insData.Add(d, new SortedList <ulong, TimeStampInfo>());
}
foreach (var el in data)
{
List <TimeStampInfo> elements = TimeStampInfo.SplitTimestamps(base.Type, el.Value);
for (int i = 0; i < elements.Count; i++)
{
insData.ElementAt(i).Value.Add(el.Key, elements[i]);
}
}
foreach (var el in insData)
{
el.Key.InsertValues(el.Value, StartTime, EndTime);
}
}
private static SortedList <UInt64, TimeStampInfo <VHDLBaseValue> > FormIntegerGeneratedData(BaseGenerator generator, UInt64 StartTime, UInt64 EndTime)
{
SortedList <UInt64, TimeStampInfo <VHDLBaseValue> > res = new SortedList <UInt64, TimeStampInfo <VHDLBaseValue> >();
if (generator is IGeneratorDataFill <Int64> )
{
SortedList <UInt64, Int64> valuesForInsert = (generator as IGeneratorDataFill <Int64>).InsertValues(StartTime, EndTime);
foreach (var el in valuesForInsert)
{
TimeStampInfo <VHDLBaseValue> inf = new TimeStampInfo <VHDLBaseValue>(new VHDLIntegerValue(Convert.ToInt32(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 <VHDLBaseValue> inf = new TimeStampInfo <VHDLBaseValue>(new VHDLIntegerValue(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 <VHDLBaseValue> inf = new TimeStampInfo <VHDLBaseValue>(new VHDLIntegerValue(Convert.ToInt32(el.Value)));
res.Add(el.Key, inf);
}
return(res);
}
return(res);
}
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);
}
/// <summary>
/// Добавление данных в конец дампа
/// </summary>
/// <param name="CurrentTime"></param>
/// <param name="value"></param>
public override void AppendValue(UInt64 CurrentTime, TimeStampInfo value)
{
if (value.Count == 0)
{
return;
}
AbstractTimeStampInfo <T> newValue = valueCovertor.GetAbstractTimeStampInfo(value);
if (dump.Count >= 1)
{
UInt64 lastTime = dump.Keys[dump.Count - 1];
AbstractTimeStampInfo <T> lastInfo = dump.Values[dump.Count - 1];
if (lastTime < CurrentTime)
{
using (AbstractValue first_value = value.FirstValue)
{
if (first_value.Equals(lastInfo.LastValue))
{
value.Info.Remove(0);
}
if (value.Count != 0)
{
dump.Add(CurrentTime, newValue);
}
}
}
else
{
dump.Append(CurrentTime, newValue);
}
}
else
{
dump.Append(CurrentTime, newValue);
}
}
public void MoveNext()
{
foreach (var iter in iterators)
{
if (iter.LastEvent == lastEvent)
{
iter.MoveNext();
}
}
currentValue = CreateTimeStampInfo();
//Проверяем, есть ли ещо данные для выборки
if (IsEndOfIteration == true)
{
return;
}
//выбираем первое событие (точнее минимальное время)
UInt64 Current = default(UInt64);
bool IsSet = false;
foreach (var iter in iterators)
{
if (
(iter.IsEndOfIteration == false) && (((Current > iter.LastEvent) || (IsSet == false)))
)
{
IsSet = true;
Current = iter.LastEvent;
}
}
//Заполнение данных
lastEvent = Current;
currentIndex++;
}
/// <summary>
/// Добавление нового элемента в конец очереди газначения сигнала
/// </summary>
/// <param name="CurrentTime"></param>
/// <param name="value"></param>
public void AppendValue(UInt64 CurrentTime, TimeStampInfo value)
{
Dump.AppendValue(CurrentTime, value);
}
/// <summary> /// Добавлене данных в конец дампа /// </summary> /// <param name="CurrentTime"></param> /// <param name="value"></param> public abstract void AppendValue(UInt64 CurrentTime, TimeStampInfo value);
