public void AddByte(byte value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Byte, ByteValue = value
});
}
public async Task EnsureDataPopulationAsync()
{
try
{
if (IsPopulated())
{
return;
}
DataEntries = _dataRepository.GetDataEntries();
// If there is no data in the database, scrape it from the website and insert into the DB
if (!DataEntries.Any())
{
var result = await _dataScraper.FetchDataFromWebAsync();
result.ForEach(resultEntry => DataEntries.Add(new IanaTimeZoneEntry {
IANATimeZoneID = resultEntry[0], WinTimeZoneID = resultEntry[1]
}));
_dataRepository.InsertEntries(DataEntries);
}
if (DataEntries.Any())
{
PopulateDictionaries();
}
}
catch (Exception e)
{
Debug.WriteLine($"Failed to populate data due to {e}");
}
}
public void AddBool(bool value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Bool, BoolValue = value
});
}
public void AddString(string value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.String, StringValue = value
});
}
public void AddVector3(Vector3 value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Vector3, Vector3Value = value
});
}
public void AddBytes(byte[] value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Bytes, BytesValue = value
});
}
public void AddInt(int value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Int, IntValue = value
});
}
public void AddFloat(float value)
{
DataEntries.Add(new DataEntry()
{
Type = DataType.Float, FloatValue = value
});
}
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="ID">Patient ID</param>
/// <param name="patientClass">Patient class of patient</param>
public EntityPatient(int ID, PatientClass patientClass)
: base(ID)
{
_patientClass = patientClass;
_correspondingDoctor = null;
_staysInBed = false;
DataEntries.Add("TotalWait", 0d);
} // end of EntityPatient
public void Read(NetBuffer buffer)
{
DataEntries.Clear();
Label = buffer.ReadString();
byte entryCount = buffer.ReadByte();
for (int i = 0; i < entryCount; i++)
{
var entry = new DataEntry();
entry.Type = (DataType)buffer.ReadByte();
switch (entry.Type)
{
case DataType.Bool:
entry.BoolValue = buffer.ReadBoolean();
break;
case DataType.Int:
entry.IntValue = buffer.ReadInt32();
break;
case DataType.Float:
entry.FloatValue = buffer.ReadSingle();
break;
case DataType.Byte:
entry.ByteValue = buffer.ReadByte();
break;
case DataType.String:
entry.StringValue = buffer.ReadString();
break;
case DataType.Vector3:
entry.Vector3Value = buffer.ReadVector3();
break;
case DataType.Bytes:
var byteCount = buffer.ReadInt32();
entry.BytesValue = buffer.ReadBytes(byteCount);
break;
}
DataEntries.Add(entry);
}
}
private void PopulateDictionaries()
{
DataEntries.ForEach(entry => IanaToWindows[entry.IANATimeZoneID] = entry.WinTimeZoneID);
foreach (var entry in DataEntries)
{
if (!WindowsToIana.ContainsKey(entry.WinTimeZoneID))
{
WindowsToIana[entry.WinTimeZoneID] = new List <string> {
entry.IANATimeZoneID
};
}
else
{
WindowsToIana[entry.WinTimeZoneID].Add(entry.IANATimeZoneID);
}
}
}
private void ParseDatFile(Stream inStream)
{
try
{
_dat = new DatContainer(inStream, _datName);
var containerData = DataEntries.ToList();
var userStringOffsets = _dat.GetUserStringOffsets();
foreach (var keyValuePair in containerData)
{
var data = keyValuePair.Value;
var isUser = userStringOffsets.Contains(keyValuePair.Key);
Strings.Add(new DatString(data, isUser));
}
}
catch (Exception ex)
{
throw new Exception(string.Format(Settings.Strings["DatWrapper_ParseDatFile_Failed"], ex.ToString()), ex);
}
}
private void ParseDatFile(Stream inStream)
{
Dat = new DatContainer(inStream, datName);
try
{
var containerData = DataEntries.ToList();
foreach (var keyValuePair in containerData)
{
if (keyValuePair.Value is UnicodeString)
{
Strings.Add((UnicodeString)keyValuePair.Value);
}
else if (keyValuePair.Value is UInt64List)
{
UInt64List ul = (UInt64List)keyValuePair.Value;
Strings.Add((UnicodeString) new UnicodeString(ul.Offset, ul.dataTableOffset, ul.ToString()));
}
else if (keyValuePair.Value is UInt32List)
{
UInt32List ul = (UInt32List)keyValuePair.Value;
Strings.Add((UnicodeString) new UnicodeString(ul.Offset, ul.dataTableOffset, ul.ToString()));
}
else if (keyValuePair.Value is Int32List)
{
Int32List ul = (Int32List)keyValuePair.Value;
Strings.Add((UnicodeString) new UnicodeString(ul.Offset, ul.dataTableOffset, ul.ToString()));
}
}
}
catch (Exception ex)
{
throw new Exception(string.Format(Settings.Strings["DatWrapper_ParseDatFile_Failed"], ex.Message), ex);
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (DataEntries.Count == 0)
{
return;
}
if (!DataEntries.All(x => x.Data.Capacity == DataEntries[0].Data.Capacity))
{
return;
}
var max = Maximum;
if (DynamicMaximum)
{
max = float.MinValue;
for (int w = 0; w < DataEntries[0].Data.Capacity; w++)
{
var sum = DataEntries.Sum(x => x.Data[w]);
if (sum > max)
{
max = sum;
}
}
if (max < Minimum)
{
max = Minimum;
}
}
var brushes = new SolidBrush[DataEntries.Count];
for (int i = 0; i < DataEntries.Count; i++)
{
brushes[i] = new SolidBrush(DataEntries[i].Color);
}
float width = (float)Width / (float)DataEntries[0].Data.Capacity;
for (int w = 0; w < DataEntries[0].Data.Capacity; w++)
{
float y_raw = 0;
for (int i = 0; i < DataEntries.Count; i++)
{
var height = DataEntries[i].Data[w];
var y = y_raw;
var display_y = Invert ? ((float)Height / (float)max * y) : (float)Height - ((float)Height / (float)max * (y + height));
var display_height = ((float)Height / (float)max * height);
y_raw += height;
var x = w * width;
e.Graphics.FillRectangle(brushes[i], x, display_y, width, display_height);
}
}
for (int i = 0; i < DataEntries.Count; i++)
{
brushes[i].Dispose();
}
}
public void Reset()
{
DataEntries.Clear();
Label = string.Empty;
}
/// <summary>
/// Creates the DataLogger Config object
/// </summary>
/// <param name="dataEntries">DataEntries object containing an array of structs containing wb-paths to the subscription of data to log.</param>
public Config(DataEntries dataEntries)
{
this.DataEntries = dataEntries;
}
public bool IsPopulated() => DataEntries.Any() && IanaToWindows.Any() && WindowsToIana.Any();
/// <summary>
/// Returns integer count of the number of entries that contain the given output string.
/// </summary>
/// <param name="output">Target concept value</param>
/// <returns>Int</returns>
public int OutputValueCount(string output)
{
return(DataEntries.SelectMany(i => i).Count(i => i == output));
}
