private void SplitAndSpillOverlappingIntervals(AllocationContext context, LiveInterval current)
{
foreach (int iIndex in context.Active)
{
LiveInterval interval = _intervals[iIndex];
if (!interval.IsFixed && interval.Register == current.Register)
{
SplitAndSpillOverlappingInterval(context, current, interval);
context.Active.Clear(iIndex);
}
}
foreach (int iIndex in context.Inactive)
{
LiveInterval interval = _intervals[iIndex];
if (!interval.IsFixed && interval.Register == current.Register && interval.Overlaps(current))
{
SplitAndSpillOverlappingInterval(context, current, interval);
context.Inactive.Clear(iIndex);
}
}
}
/// <summary>
/// Delete a staff member from the database by their ID
/// </summary>
/// <param name="staffId">the database ID of the staff member entry</param>
/// <returns>true if the staff member was found and deleted, false otherwise</returns>
public bool Delete(int staffId)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
StaffMember staffMember = dbContext.StaffMembers
.Include(sm => sm.Positions)
.ThenInclude(sp => sp.Position)
.SingleOrDefault(sm => sm.StaffMemberId == staffId);
if (staffMember == null)
{
return(false);
}
// Replace allocations with static variant
foreach (var pos in staffMember.Positions)
{
pos.Position.StaffPosition = new UnknownStaffPosition
{
StaffName = staffMember.FirstName,
};
}
dbContext.StaffMembers.Remove(staffMember);
dbContext.SaveChanges();
return(true);
}
}
/// <summary>
/// Update the specified id and handoverDTO.
/// </summary>
/// <returns>The update.</returns>
/// <param name="id">Identifier.</param>
/// <param name="handoverDTO">Handover dto.</param>
public bool Update(int id, HandoverDTO handoverDTO)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Handover handover = dbContext.Handovers
.Include(h => h.HandoverIssues)
.SingleOrDefault(h => h.HandoverID == id);
if (handover == null)
{
return(false);
}
//Update all the attributes
Model.Handover newHandover = HandoverDTOToModel(handoverDTO);
handover.AdmissionUnit = newHandover.AdmissionUnit;
handover.AdmissionDate = newHandover.AdmissionDate;
handover.Alerts = newHandover.Alerts;
handover.BedNumber = newHandover.BedNumber;
handover.NurseName = newHandover.NurseName;
handover.HandoverIssues = newHandover.HandoverIssues;
handover.Isolation = newHandover.Isolation;
handover.PatientName = newHandover.PatientName;
handover.PatientId = newHandover.PatientId;
handover.PastMedicalHistory = newHandover.PastMedicalHistory;
handover.PresentingComplaint = newHandover.PresentingComplaint;
handover.SignificantEvents = newHandover.SignificantEvents;
handover.StudentName = newHandover.StudentName;
handover.SwabSent = newHandover.SwabSent;
handover.SwabSentDate = newHandover.SwabSentDate;
// Update
dbContext.Update(handover);
dbContext.SaveChanges();
return(true);
}
}
/// <summary>
/// Search for the allocation at a certain time for the senior team.
/// </summary>
/// <param name="time">The time to search for in seconds since UNIX epoch.</param>
/// <returns>The senior team allocation at the time if it exists, null otherwise.</returns>
public SeniorTeam GetPastSeniorTeam(long time)
{
using (var context = new AllocationContext(_dbOptions))
{
var allocations = context.TeamAllocations
.Include(t => t.Positions)
.ThenInclude(p => p.StaffPosition)
.Where(p => p.Type == Model.TeamType.Senior)
.Where(p => time >= p.Time);
var allocation = allocations.FirstOrDefault(p => p.Time == allocations.Max(q => q.Time));
if (allocation == null)
{
return(null);
}
else
{
foreach (var pos in allocation.Positions.Where(p => p.StaffPosition is KnownStaffPosition))
{
context.Entry(pos.StaffPosition as KnownStaffPosition)
.Reference(sp => sp.StaffMember)
.Load();
}
return(ModelConverter.SeniorTeamFromModel(allocation));
}
}
}
/// <summary>
/// Retrieve an existing staff member from the database by their database ID
/// </summary>
/// <param name="staffId">The database ID of the staff member.</param>
/// <returns>A data object representation of the retrieved staff member.</returns>
public DataObject.StaffMember Get(int staffId)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
// Retrieve the staff member by ID, including all fields
StaffMember staffMember = dbContext.StaffMembers
.Include(sm => sm.Designation)
.Include(sm => sm.StaffSkills)
.ThenInclude(ss => ss.Skill)
.SingleOrDefault(sm => sm.StaffMemberId == staffId);
// If we got nothing, bail out
if (staffMember == null)
{
return(null);
}
// Turn the skills back into skill names
ICollection <string> skills = staffMember.StaffSkills
.Select(ss => ss.Skill.Name)
.ToList();
// Return a fresh data passing object
return(new DataObject.StaffMember(staffMember.FirstName,
staffMember.LastName,
staffMember.Alias,
staffMember.Designation.Name,
skills,
staffMember.LastDouble,
null,
staffMember.PhotoId,
staffMember.RosterOnId));
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="T:HospitalAllocation.Providers.Allocation.Database.AllocationDatabaseStore"/>
/// class using the specified options.
/// </summary>
/// <param name="dbOptions">The options used to access the database.</param>
public AllocationDatabaseStore(DbContextOptions <AllocationContext> dbOptions)
{
_dbOptions = dbOptions;
using (var context = new AllocationContext(dbOptions))
{
// Fill the memory store with the latest allocations, if any exist
_allocation = new AllocationMemoryStore();
if (context.TeamAllocations.Where(t => t.Type == Model.TeamType.A).Any())
{
AllocationProvider.SetPodAllocation(_allocation.PodA,
ModelConverter.PodFromModel(GetLatestAllocation(Model.TeamType.A, context)));
}
if (context.TeamAllocations.Where(t => t.Type == Model.TeamType.B).Any())
{
AllocationProvider.SetPodAllocation(_allocation.PodB,
ModelConverter.PodFromModel(GetLatestAllocation(Model.TeamType.B, context)));
}
if (context.TeamAllocations.Where(t => t.Type == Model.TeamType.C).Any())
{
AllocationProvider.SetPodAllocation(_allocation.PodC,
ModelConverter.PodFromModel(GetLatestAllocation(Model.TeamType.C, context)));
}
if (context.TeamAllocations.Where(t => t.Type == Model.TeamType.D).Any())
{
AllocationProvider.SetPodAllocation(_allocation.PodD,
ModelConverter.PodFromModel(GetLatestAllocation(Model.TeamType.D, context)));
}
if (context.TeamAllocations.Where(t => t.Type == Model.TeamType.Senior).Any())
{
AllocationProvider.SetSeniorTeamAllocation(_allocation.SeniorTeam,
ModelConverter.SeniorTeamFromModel(GetLatestAllocation(Model.TeamType.Senior, context)));
}
}
}
/// <summary>
/// Check if a designation exists
/// </summary>
/// <param name="name">The given name</param>
/// <returns>If it exists</returns>
public bool Exists(string name)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
// If there is any existing desigation in the database that has the same name.
return(dbContext.Designations.Any(d => String.Equals(d.Name, name, StringComparison.OrdinalIgnoreCase)));
}
}
/// <summary>
/// Lists the entire collection of skills
/// </summary>
/// <returns>Immutable list of all the skills in the database</returns>
public ImmutableList <KnownSkill> List()
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
List <Model.Skill> skills = dbContext.Skills.Select(x => x).ToList();
// Map the Model list to immutable data list
return(skills.Select(x => new KnownSkill(x.Name, x.SkillId)).ToImmutableList());
}
}
/// <summary>
/// Create a new staff member from a given staff member object and return their new allocted database ID
/// </summary>
/// <param name="staffMember">the staff member data to save in the database</param>
/// <returns>the integer identifier of the new staff entry</returns>
public int Create(DataObject.StaffMember staffMember)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
// Find if this staff member's designation is already known
Model.Designation designation = dbContext.Designations
.SingleOrDefault(d => String.Equals(d.Name, staffMember.Designation, StringComparison.OrdinalIgnoreCase));
if (designation == null)
{
throw new ArgumentException(String.Format("Unrecognised designation: {0}", staffMember.Designation));
}
// Now dig out the skills we already know about. We could ask for only the skills that this
// staff member has, but then we need to check those skills against the staff member's with
// case insensitive comparison on the DB's side. It's probably both faster and simpler to read
// in all the skills and then filter on our side
IDictionary <string, Model.Skill> dbSkills = new Dictionary <string, Model.Skill>(dbContext.Skills.ToDictionary(s => s.Name, s => s),
StringComparer.OrdinalIgnoreCase);
// Create the new staff member entry
StaffMember dbStaffMember = new StaffMember()
{
FirstName = staffMember.FirstName,
LastName = staffMember.LastName,
Alias = staffMember.Alias,
Designation = designation,
LastDouble = staffMember.LastDouble,
PhotoId = staffMember.PhotoId,
RosterOnId = staffMember.RosterOnId,
};
// Now generate their skill entries
var skills = new List <StaffSkill>();
foreach (string skillName in staffMember.Skills)
{
if (!dbSkills.ContainsKey(skillName))
{
throw new ArgumentException(String.Format("Unrecognised skill: {0}", skillName));
}
skills.Add(new StaffSkill()
{
StaffMember = dbStaffMember, Skill = dbSkills[skillName]
});
}
dbStaffMember.StaffSkills = skills;
// Finally, stick them in the database
dbContext.StaffMembers.Add(dbStaffMember);
dbContext.SaveChanges();
// EF Core should magically populate this property after the commit
return(dbStaffMember.StaffMemberId);
}
}
/// <summary>
/// Lists the entire collection of designations
/// </summary>
/// <returns>Immutable list of all the designations in the database</returns>
public ImmutableList <KnownDesignation> List()
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
return(dbContext.Designations
.Select(x =>
new KnownDesignation(x.DesignationId, x.Name))
.ToImmutableList());
}
}
/// <summary>
/// Gets the handover.
/// </summary>
/// <returns>The handover.</returns>
/// <param name="id">Identifier.</param>
public HandoverDTO GetHandover(int id)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Handover handover = dbContext.Handovers
.Include(h => h.HandoverIssues)
.SingleOrDefault(h => h.HandoverID == id);
return(HandoverModelToDTO(handover));
}
}
public static ModelConverter FromDb(DbContextOptions <AllocationContext> dbOptions)
{
using (var dbContext = new AllocationContext(dbOptions))
{
IDictionary <int, StaffMember> staff = dbContext.StaffMembers
.ToDictionary(sm => sm.StaffMemberId, sm => sm);
return(new ModelConverter(staff));
}
}
public AllocationResult RunPass(
ControlFlowGraph cfg,
StackAllocator stackAlloc,
RegisterMasks regMasks)
{
NumberLocals(cfg);
AllocationContext context = new AllocationContext(stackAlloc, regMasks, _intervals.Count);
BuildIntervals(cfg, context);
for (int index = 0; index < _intervals.Count; index++)
{
LiveInterval current = _intervals[index];
if (current.IsEmpty)
{
continue;
}
if (current.IsFixed)
{
context.Active.Set(index);
if (current.Register.Type == RegisterType.Integer)
{
context.IntUsedRegisters |= 1 << current.Register.Index;
}
else /* if (interval.Register.Type == RegisterType.Vector) */
{
context.VecUsedRegisters |= 1 << current.Register.Index;
}
continue;
}
AllocateInterval(context, current, index);
}
for (int index = RegistersCount * 2; index < _intervals.Count; index++)
{
if (!_intervals[index].IsSpilled)
{
ReplaceLocalWithRegister(_intervals[index]);
}
}
InsertSplitCopies();
InsertSplitCopiesAtEdges(cfg);
return(new AllocationResult(
context.IntUsedRegisters,
context.VecUsedRegisters,
context.StackAlloc.TotalSize));
}
/// <summary>
/// Generates the recent doubles for a staff member.
/// </summary>
/// <param name="context">The database context to use.</param>
/// <param name="staffId">The ID of the staff member.</param>
/// <param name="recentDoubleTime">The earliest time considered recent.</param>
/// <returns>The recent doubles for the staff member.</returns>
private static ICollection <long> GenerateRecentDoubles(
AllocationContext context, int staffId, long recentDoubleTime)
{
// Find recent doubles for the staff member
var doubles = context.StaffMembers
.Include(s => s.Positions)
.ThenInclude(sp => sp.Position)
.ThenInclude(p => p.Allocation)
.Single(s => s.StaffMemberId == staffId)
.Positions
.Where(p => p.Position.Allocation.Time >= recentDoubleTime)
.GroupBy(p => p.Position.Allocation.Time)
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
// Add the stored last double value if it is relevant
var staff = context.StaffMembers.Find(staffId);
if (staff.LastDouble.HasValue && staff.LastDouble.Value >= recentDoubleTime)
{
doubles.Add(staff.LastDouble.Value);
}
if (doubles.Count == 0)
{
return(doubles);
}
// Find and remove the last doubles that occur within a time interval
doubles.Sort();
long intervalStart = doubles.Min();
var removeList = new List <int>();
for (int i = 1; i < doubles.Count; i++)
{
if (doubles[i] > intervalStart + DoubleIntervalSeconds)
{
intervalStart = doubles[i];
}
else
{
removeList.Add(i);
}
}
removeList.Reverse();
foreach (var index in removeList)
{
doubles.RemoveAt(index);
}
return(doubles);
}
/// <summary>
/// Get a skill matching the Id
/// </summary>
/// <param name="skillId">The id with which to query the database</param>
/// <returns>The matching skill</returns>
public KnownSkill Get(int id)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Skill skill = dbContext.Skills.Find(id);
if (skill == null)
{
return(null);
}
return(new KnownSkill(skill.Name, skill.SkillId));
}
}
/// <summary>
/// Get a designation matching the Id
/// </summary>
/// <param name="designationId">The id with which to query the databse</param>
/// <returns>The matching designation</returns>
public KnownDesignation Get(int id)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Designation designation = dbContext.Designations.Find(id);
if (designation == null)
{
return(null);
}
return(new KnownDesignation(designation.DesignationId, designation.Name));
}
}
public ICSVFileStream GetCSVFile(DateTime timestamp)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
CSVFileStorage csvfilestorage = dbContext.CSVFileStorages.Single(c => c.CSVTimeStamp == timestamp);
if (csvfilestorage == null)
{
return(null);
}
return(new MemoryCSVFileStream(csvfilestorage.CSVFileData, csvfilestorage.CSVTimeStamp, csvfilestorage.CSVFileFormat));
}
}
public ICSVFileStream GetMostRecentCSVFile()
{
using (var dbContext = new AllocationContext(_dbOptions))
{
CSVFileStorage csvfilestorage = dbContext.CSVFileStorages.OrderBy(c => c.CSVTimeStamp).Last();
if (csvfilestorage == null)
{
return(null);
}
return(new MemoryCSVFileStream(csvfilestorage.CSVFileData, csvfilestorage.CSVTimeStamp, csvfilestorage.CSVFileFormat));
}
}
private void Spill(AllocationContext context, LiveInterval interval)
{
Debug.Assert(!interval.IsFixed, "Trying to spill a fixed interval.");
Debug.Assert(interval.UsesCount == 0, "Trying to spill a interval with uses.");
// We first check if any of the siblings were spilled, if so we can reuse
// the stack offset. Otherwise, we allocate a new space on the stack.
// This prevents stack-to-stack copies being necessary for a split interval.
if (!interval.TrySpillWithSiblingOffset())
{
interval.Spill(context.StackAlloc.Allocate(interval.Local.Type));
}
}
/// <summary>
/// Update an existing designation
/// </summary>
/// <param name="designationId">The id of existing designation</param>
/// <param name="designation">The new designation to update to</param>
/// <returns>Success status</returns>
public bool Update(int designationId, KnownDesignation designation)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Designation dbDesignation = dbContext.Designations.Find(designationId);
if (dbDesignation == null)
{
return(false);
}
dbDesignation.Name = designation.Name;
dbContext.SaveChanges();
return(true);
}
}
/// <summary>
/// Update an existing skill
/// </summary>
/// <param name="skillId">The id of the existing skill</param>
/// <param name="skill">The new skill to update to</param>
/// <returns>Success status</returns>
public bool Update(int skillId, KnownSkill skill)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Skill dbSkill = dbContext.Skills.Find(skillId);
if (dbSkill == null)
{
return(false);
}
dbSkill.Name = skill.Name;
dbContext.SaveChanges();
return(true);
}
}
/// <summary>
/// Retrieve an image with the given identifier from the database
/// </summary>
/// <param name="id">the database identifier of the image to retrieve</param>
/// <returns>a data stream of the image</returns>
public IImageStream GetImage(int id)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
Photo photo = dbContext.Photos.SingleOrDefault(p => p.PhotoId == id);
if (photo == null)
{
return(null);
}
return(new MemoryImageStream(photo.Image, photo.Format));
}
}
/// <summary>
/// Deletes a note
/// </summary>
/// <param name="noteId">The given note id</param>
/// <returns>Success status</returns>
public bool Delete(int noteId)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Note note = dbContext.Notes.Find(noteId);
if (note == null)
{
return(false);
}
dbContext.Notes.Remove(note);
dbContext.SaveChanges();
return(true);
}
}
/// <summary>
/// Delete the specified id.
/// </summary>
/// <returns>The delete.</returns>
/// <param name="id">Identifier.</param>
public bool Delete(int id)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Handover handover = dbContext.Handovers.Find(id);
if (handover == null)
{
return(false);
}
// Remove the object in database
dbContext.Handovers.Remove(handover);
dbContext.SaveChanges();
return(true);
}
}
public ICSVFileStream GetCSVFile(int id)
{
using (var dbContext = new AllocationContext(_dbOptions))
{
try
{
CSVFileStorage csvfilestorage = dbContext.CSVFileStorages.Single(c => c.CSVFileID == id);
return(new MemoryCSVFileStream(csvfilestorage.CSVFileData, csvfilestorage.CSVTimeStamp, csvfilestorage.CSVFileFormat));
}
catch
{
return(null);
}
}
}
/// <summary>
/// Create the specified handoverDTO.
/// </summary>
/// <returns>The create.</returns>
/// <param name="handoverDTO">Handover dto.</param>
public int Create(HandoverDTO handoverDTO)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
// Create the handover Model object
Model.Handover handover = HandoverDTOToModel(handoverDTO);
// Store the object in database
dbContext.Handovers.Add(handover);
dbContext.SaveChanges();
// EF Core should magically populate this property after the commit
return(handover.HandoverID);
}
}
/// <summary>
/// Updates an existing note
/// </summary>
/// <param name="noteId">Id of the existing note</param>
/// <param name="newNote">The new note</param>
/// <returns>Success status</returns>
public bool Update(int noteId, KnownNote newNote)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Note note = dbContext.Notes.Find(noteId);
if (note == null)
{
return(false);
}
note.Contents = newNote.Contents;
note.LastModificationTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
dbContext.SaveChanges();
return(true);
}
}
public ImmutableList <KnownNote> GetNotes()
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
ImmutableList <KnownNote> notes = dbContext.Notes
.Select(n => new KnownNote(
n.NoteId,
n.StaffMemberId,
n.Contents,
n.CreationTime,
n.LastModificationTime))
.ToImmutableList();
return(notes);
}
}
/// <summary>
/// Inserts an allocation into the database by updating the existing allocation if an
/// allocation already exists at that time, and creating a new allocation otherwise.
/// </summary>
/// <param name="context">The context to insert into.</param>
/// <param name="time">The time of the allocation in UNIX time seconds.</param>
/// <param name="oldAllocations">The allocations at time.</param>
/// <param name="allocation">The allocation to insert.</param>
private static void InsertAllocation(AllocationContext context, long time,
IQueryable <TeamAllocation> oldAllocations, TeamAllocation allocation)
{
var oldAllocation = oldAllocations.SingleOrDefault(a => a.Type == allocation.Type);
if (oldAllocation != null)
{
oldAllocation.Positions = allocation.Positions;
context.Update(oldAllocation);
}
else
{
allocation.Time = time;
context.TeamAllocations.Add(allocation);
}
}
/// <summary>
/// Deletes a designation if not associated with any staff
/// </summary>
/// <param name="designationID">The id of designation to delete</param>
/// <returns>Success status</returns>
public bool Delete(int designationId)
{
using (var dbContext = new AllocationContext(_dbContextOptions))
{
Model.Designation designation = dbContext.Designations
.Include(d => d.StaffMembers)
.SingleOrDefault(d => d.DesignationId == designationId);
// Only delete a skill that exists and is not associated with other staff
if (designation == null || designation.StaffMembers?.Any() == true)
{
return(false);
}
dbContext.Designations.Remove(designation);
dbContext.SaveChanges();
return(true);
}
}
