public InListOutOfList(List<SubCalendarEvent> FullList, List<List<List<SubCalendarEvent>>> AllMyList, List<TimeLine> MyFreeSpots)
{
DictData_TimeLine = new Dictionary<List<TimeLine>, List<SubCalendarEvent>>();
foreach (List<List<SubCalendarEvent>> ListToCheck in AllMyList)
{
List<SubCalendarEvent> TotalList = new List<SubCalendarEvent>();
int i = 0;
List<TimeLine> timeLineEntry = new List<TimeLine>();
foreach (List<SubCalendarEvent> myList in ListToCheck)
{
TimeLine myTimeLine = new TimeLine(MyFreeSpots[i].Start, MyFreeSpots[i].End);
TotalList.AddRange(myList);
TimeSpan TotalTimeSpan = new TimeSpan(0);
foreach (SubCalendarEvent mySubEvent in myList)
{
TotalTimeSpan=TotalTimeSpan.Add(mySubEvent.ActiveSlot.BusyTimeSpan);
}
BusyTimeLine EffectivebusySlot = new BusyTimeLine("1000000_1000001", MyFreeSpots[i].Start, MyFreeSpots[i].Start.Add(TotalTimeSpan));
myTimeLine.AddBusySlots(EffectivebusySlot);
timeLineEntry.Add(myTimeLine);
i++;
}
DictData_TimeLine.Add(timeLineEntry, Utility.NotInList_NoEffect(FullList, TotalList));
}
}
public override void updateEventSequence()
{
EventSequence = new TimeLine(this.Start, this.End);
EventSequence.AddBusySlots(BusyFrame);
}
public bool PinToEndAndIncludeInTimeLine(TimeLine LimitingTimeLine, CalendarEvent RestrctingCalendarEvent)
{
if (new EventID(RestrctingCalendarEvent.ID).getLevelID(0) != SubEventID.getLevelID(0))
{
throw new Exception("Oh oh Sub calendar event Trying to pin to end of invalid calendar event. Check that you have matchin IDs");
}
DateTime ReferenceTime = new DateTime();
EndDateTime=RestrctingCalendarEvent.End;
if (EndDateTime > LimitingTimeLine.End)
{
ReferenceTime = LimitingTimeLine.End;
}
/*else
{
ReferenceTime = End;
}*/
DateTime MyStartTime = ReferenceTime - this.EventDuration;
if (this.getCalendarEventRange.IsTimeLineWithin(new TimeLine(MyStartTime, ReferenceTime)))
{
StartDateTime = MyStartTime;
//ActiveSlot = new BusyTimeLine(this.ID, (MyStartTime), ReferenceTime);
TimeSpan BusyTimeLineShift = MyStartTime - ActiveSlot.Start;
ActiveSlot.shiftTimeline(BusyTimeLineShift);
EndDateTime = ReferenceTime;
LimitingTimeLine.AddBusySlots(ActiveSlot);
return true;
}
return false;
}
public bool PinToEndAndIncludeInTimeLine(TimeLine LimitingTimeLine)
{
DateTime ReferenceTime = new DateTime();
EndDateTime = this.getCalendarEventRange.End;
ReferenceTime = EndDateTime;
if (EndDateTime > LimitingTimeLine.End)
{
ReferenceTime = LimitingTimeLine.End;
}
DateTime MyStartTime = ReferenceTime - this.EventDuration;
if(this.getCalendarEventRange.IsTimeLineWithin(new TimeLine(MyStartTime,ReferenceTime)))
{
StartDateTime = MyStartTime;
//ActiveSlot = new BusyTimeLine(this.ID, (MyStartTime), ReferenceTime);
TimeSpan BusyTimeLineShift = MyStartTime - ActiveSlot.Start;
ActiveSlot.shiftTimeline(BusyTimeLineShift);
EndDateTime = ReferenceTime;
LimitingTimeLine.AddBusySlots(ActiveSlot);
return true;
}
return false;
}
List<mTuple<bool, SubCalendarEvent>> stitchUnRestrictedSubCalendarEvent(TimeLine FreeBoundary, List<mTuple<bool, SubCalendarEvent>> restrictedSnugFitAvailable, Dictionary<TimeSpan, Dictionary<string, mTuple<bool, SubCalendarEvent>>> PossibleEntries, Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> CompatibleWithList,double Occupancy)
{
TimeLine[] AllFreeSpots = FreeBoundary.getAllFreeSlots();
int TotalEventsForThisTImeLine = 0;
foreach (KeyValuePair<TimeSpan, mTuple<int, TimeSpanWithStringID>> eachKeyValuePair in CompatibleWithList)
{
TotalEventsForThisTImeLine += eachKeyValuePair.Value.Item1;
}
CompatibleWithList.Clear();
DateTime EarliestReferenceTIme = FreeBoundary.Start;
List<mTuple<bool, SubCalendarEvent>> FrontPartials = new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>();
List<mTuple<bool, SubCalendarEvent>> EndPartials = new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>();
Dictionary<DateTime, List<mTuple<bool, SubCalendarEvent>>> FrontPartials_Dict = new System.Collections.Generic.Dictionary<DateTime, System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>>();
Dictionary<DateTime, List<mTuple<bool, SubCalendarEvent>>> EndPartials_Dict = new System.Collections.Generic.Dictionary<DateTime, System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>>();
Dictionary<TimeSpan, Dictionary<string, mTuple<bool, SubCalendarEvent>>> PossibleEntries_Cpy = new Dictionary<TimeSpan, Dictionary<string, mTuple<bool, SubCalendarEvent>>>();
Dictionary<string, Dictionary<string, SubCalendarEvent>> CalendarIDAndNonPartialSubCalEvents = new Dictionary<string, Dictionary<string, SubCalendarEvent>>();//List of non partials for current Reference StartTime To End of FreeBoundary. Its gets updated with Partials once the earliest reference time passes the partial event start time
foreach (KeyValuePair<TimeSpan, Dictionary<string, mTuple<bool, SubCalendarEvent>>> eachKeyValuePair in PossibleEntries)//populates PossibleEntries_Cpy. I need a copy to maintain all references to PossibleEntries
{
Dictionary<string, mTuple<bool, SubCalendarEvent>> NewDictEntry = new Dictionary<string, mTuple<bool, SubCalendarEvent>>();
foreach (KeyValuePair<string, mTuple<bool, SubCalendarEvent>> KeyValuePair0 in eachKeyValuePair.Value)
{
mTuple<bool, SubCalendarEvent> MyEvent = KeyValuePair0.Value;
if (MyEvent.Item2.ID == "469_471")
{
;
}
bool isInrestrictedSnugFitAvailable = false;
if (CompatibleWithList.ContainsKey(eachKeyValuePair.Key))
{
++CompatibleWithList[eachKeyValuePair.Key].Item1;
}
else
{
CompatibleWithList.Add(eachKeyValuePair.Key, new mTuple<int, TimeSpanWithStringID>(1, new TimeSpanWithStringID(KeyValuePair0.Value.Item2.ActiveDuration, KeyValuePair0.Value.Item2.ActiveDuration.Ticks.ToString())));
}
foreach (mTuple<bool, SubCalendarEvent> eachMtuple in restrictedSnugFitAvailable)//checks if event is in restricted list
{
if (eachMtuple.Item2.ID == MyEvent.Item2.ID)
{
isInrestrictedSnugFitAvailable = true;
break;
}
}
if (!isInrestrictedSnugFitAvailable)
{
NewDictEntry.Add(KeyValuePair0.Value.Item2.ID, KeyValuePair0.Value);
if (FreeBoundary.IsDateTimeWithin(KeyValuePair0.Value.Item2.getCalendarEventRange.Start))
{
FrontPartials.Add(KeyValuePair0.Value);
}
else
{
if (FreeBoundary.IsDateTimeWithin(KeyValuePair0.Value.Item2.getCalendarEventRange.End))
{
EndPartials.Add(KeyValuePair0.Value);
}
else
{
string CalLevel0ID=KeyValuePair0.Value.Item2.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(CalLevel0ID))
{
CalendarIDAndNonPartialSubCalEvents[CalLevel0ID].Add(KeyValuePair0.Value.Item2.ID, KeyValuePair0.Value.Item2);
}
else
{
//CalendarIDAndNonPartialSubCalEvents.Add(CalLevel0ID, new List<SubCalendarEvent>() { KeyValuePair0.Value.Item2 });
CalendarIDAndNonPartialSubCalEvents.Add(CalLevel0ID, new Dictionary<string, SubCalendarEvent>());
CalendarIDAndNonPartialSubCalEvents[CalLevel0ID].Add(KeyValuePair0.Value.Item2.ID, KeyValuePair0.Value.Item2);
}
}
}
}
}
if (NewDictEntry.Count > 0)
{ PossibleEntries_Cpy.Add(eachKeyValuePair.Key, NewDictEntry); }
}
FrontPartials = FrontPartials.OrderBy(obj => obj.Item2.getCalendarEventRange.Start).ToList();
EndPartials = EndPartials.OrderBy(obj => obj.Item2.getCalendarEventRange.End).ToList();
foreach (mTuple<bool, SubCalendarEvent> eachmTuple in FrontPartials)//populates FrontPartials_Dict in ordered manner since FrontPartials is ordered
{
if (FrontPartials_Dict.ContainsKey(eachmTuple.Item2.getCalendarEventRange.Start))
{
FrontPartials_Dict[eachmTuple.Item2.getCalendarEventRange.Start].Add(eachmTuple);
}
else
{
FrontPartials_Dict.Add(eachmTuple.Item2.getCalendarEventRange.Start, new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>() { eachmTuple });
}
}
foreach (mTuple<bool, SubCalendarEvent> eachmTuple in EndPartials)//populates EndPartials_Dict in ordered manner since EndPartials is ordered
{
if (EndPartials_Dict.ContainsKey(eachmTuple.Item2.getCalendarEventRange.Start))
{
EndPartials_Dict[eachmTuple.Item2.getCalendarEventRange.Start].Add(eachmTuple);
}
else
{
EndPartials_Dict.Add(eachmTuple.Item2.getCalendarEventRange.Start, new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>() { eachmTuple });
}
}
List<SubCalendarEvent> CompleteArranegement = new System.Collections.Generic.List<SubCalendarEvent>();
int StartingReferneceIndex = 0;
/*foreach (mTuple<bool, SubCalendarEvent> eachmTuple in restrictedSnugFitAvailable)//removes the restricted from CompatibleWithList
{
--CompatibleWithList[eachmTuple.Item2.ActiveDuration.Ticks.ToString()].Item1;
//PossibleEntries_Cpy[eachmTuple.Item2.ActiveDuration.Ticks.ToString()].Remove(eachmTuple.Item2.ID);
}*/
List<DateTime> ListOfFrontPartialsStartTime = FrontPartials_Dict.Keys.ToList();
int i = 0;
int j = 0;
int FrontPartialCounter = 0;
if (restrictedSnugFitAvailable.Count < 1)
{
;
}
Tuple<DateTime, List<SubCalendarEvent>> TimeLineUpdated = null;
SubCalendarEvent BorderElementBeginning = null;
SubCalendarEvent BorderElementEnd = null;
SubCalendarEvent LastSubCalElementForEarlierReferenceTime = null;
for (; i < restrictedSnugFitAvailable.Count; i++)
{
//bool isFreeSpotBeforeRigid = AllFreeSpots[i].End <= restrictedSnugFitAvailable[i].Item2.Start;
TimeLineUpdated = null;
if (CompleteArranegement.Count == 46)
{
;
}
if (i ==2)
{
;
}
restrictedSnugFitAvailable[i].Item2.PinSubEventsToStart(new TimeLine(EarliestReferenceTIme, restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End));
List<BusyTimeLine> RestrictedBusySlots = new System.Collections.Generic.List<BusyTimeLine>();
FreeBoundary = new TimeLine(FreeBoundary.Start, FreeBoundary.End);
foreach (mTuple<bool, SubCalendarEvent> eachmTuple in restrictedSnugFitAvailable)
{
eachmTuple.Item1 = true;
RestrictedBusySlots.Add(eachmTuple.Item2.ActiveSlot);
string timeSpanString = eachmTuple.Item2.ActiveDuration.Ticks.ToString();
string SubEventID = eachmTuple.Item2.ID;
}
FreeBoundary.AddBusySlots(RestrictedBusySlots.ToArray());
List<SubCalendarEvent> LowestCostArrangement = new System.Collections.Generic.List<SubCalendarEvent>();
TimeLine PertinentFreeSpot = null;
TimeLine FreeSpotUpdated = null;
j = i + 1;
if (ListOfFrontPartialsStartTime.Count > 0)//fits any sub calEvent in preceeding restricting free spot
{
DateTime RestrictedStopper = restrictedSnugFitAvailable[i].Item2.Start;
bool breakForLoop = false;
bool PreserveRestrictedIndex = false;
for (; FrontPartialCounter < ListOfFrontPartialsStartTime.Count; FrontPartialCounter++)
{
TimeLineUpdated = null;
DateTime PertinentFreeSpotStart = EarliestReferenceTIme;
DateTime PertinentFreeSpotEnd;
if (CompleteArranegement.Count == 46)
{
;
}
if ((ListOfFrontPartialsStartTime[FrontPartialCounter] < RestrictedStopper))
{
PertinentFreeSpotEnd = ListOfFrontPartialsStartTime[FrontPartialCounter];
//FrontPartials_Dict.Remove(ListOfFrontPartialsStartTime[FrontPartialCounter]);
ListOfFrontPartialsStartTime.RemoveAt(FrontPartialCounter);
--FrontPartialCounter;
PreserveRestrictedIndex = true;
}
else
{
PertinentFreeSpotEnd = RestrictedStopper;
if (breakForLoop)
{//populates with final boundary for each restricted
PertinentFreeSpot = new TimeLine(PertinentFreeSpotStart, PertinentFreeSpotEnd);
BorderElementBeginning = CompleteArranegement.Count>0?CompleteArranegement[CompleteArranegement.Count-1]:null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = restrictedSnugFitAvailable[i].Item2;//uses restricted value as boundary element
LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy,Occupancy);
DateTime EarliestTimeForBetterEarlierReferenceTime = PertinentFreeSpot.Start;
LastSubCalElementForEarlierReferenceTime = ((CompleteArranegement.Count < 1) || (CompleteArranegement == null) ? null : CompleteArranegement[CompleteArranegement.Count - 1]);
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();
if (LowestCostArrangement.Count > 0)
{
if (!(LowestCostArrangement[0].getCalendarEventRange.Start == PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();// new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, PertinentFreeSpot);
}
EarliestReferenceTIme = PertinentFreeSpot.End;// LowestCostArrangement[LowestCostArrangement.Count - 1].End;
SubCalendarEvent LastSubCalEvent = LowestCostArrangement[LowestCostArrangement.Count - 1];
EarliestTimeForBetterEarlierReferenceTime = LastSubCalEvent.End;
LastSubCalElementForEarlierReferenceTime = LastSubCalEvent;
}
TimeLineUpdated = null;
TimeLineUpdated = ObtainBetterEarlierReferenceTime(LowestCostArrangement, CalendarIDAndNonPartialSubCalEvents, RestrictedStopper - EarliestTimeForBetterEarlierReferenceTime, EarliestReferenceTIme, new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End), LastSubCalElementForEarlierReferenceTime);
if (TimeLineUpdated != null)
{
LowestCostArrangement = TimeLineUpdated.Item2;
EarliestReferenceTIme = TimeLineUpdated.Item1;
}
foreach (SubCalendarEvent eachSubCalendarEvent in LowestCostArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
LowestCostArrangement = CompleteArranegement.Concat(LowestCostArrangement).ToList();
LowestCostArrangement = PlaceSubCalEventInLowestCostPosition(FreeBoundary, restrictedSnugFitAvailable[i].Item2, LowestCostArrangement);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeBoundary);
CompleteArranegement = LowestCostArrangement;
EarliestReferenceTIme = LowestCostArrangement[LowestCostArrangement.Count - 1].End;
PreserveRestrictedIndex = false;
break;
}
--FrontPartialCounter;
if (j < restrictedSnugFitAvailable.Count)
{
RestrictedStopper = restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End > restrictedSnugFitAvailable[j].Item2.Start ? restrictedSnugFitAvailable[j].Item2.Start : restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End;
}
else
{
RestrictedStopper = restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End > FreeBoundary.End ? FreeBoundary.End : restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End;
}
RestrictedStopper -= restrictedSnugFitAvailable[i].Item2.ActiveDuration;
breakForLoop = true;
}
PertinentFreeSpot = new TimeLine(PertinentFreeSpotStart, PertinentFreeSpotEnd);
BorderElementBeginning = CompleteArranegement.Count > 0 ? CompleteArranegement[CompleteArranegement.Count - 1] : null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = restrictedSnugFitAvailable[i].Item2;//uses restricted value as boundary element
LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy, Occupancy);
DateTime LatestDaterforEarlierReferenceTime = PertinentFreeSpot.Start;
LastSubCalElementForEarlierReferenceTime = ((CompleteArranegement.Count < 1) || (CompleteArranegement == null) ? null : CompleteArranegement[CompleteArranegement.Count - 1]);//updates the last element as either null or the last element in the current Complete arrangement
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();
if (LowestCostArrangement.Count > 0)
{
if (!(LowestCostArrangement[0].getCalendarEventRange.Start == PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
//FreeSpotUpdated = new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();
Utility.PinSubEventsToStart(LowestCostArrangement, PertinentFreeSpot);
}
EarliestReferenceTIme = PertinentFreeSpot.End;
///Comeback to this
///
SubCalendarEvent LastSubCalEvent = LowestCostArrangement[LowestCostArrangement.Count - 1];
LatestDaterforEarlierReferenceTime = LastSubCalEvent.End;
LastSubCalElementForEarlierReferenceTime = LastSubCalEvent;
}
TimeLineUpdated = ObtainBetterEarlierReferenceTime(LowestCostArrangement, CalendarIDAndNonPartialSubCalEvents, RestrictedStopper - LatestDaterforEarlierReferenceTime, EarliestReferenceTIme, new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End), LastSubCalElementForEarlierReferenceTime);
//errorline
if (TimeLineUpdated != null)
{
LowestCostArrangement = TimeLineUpdated.Item2;
EarliestReferenceTIme = TimeLineUpdated.Item1;
}
foreach (SubCalendarEvent eachSubCalendarEvent in LowestCostArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
CompleteArranegement.AddRange(LowestCostArrangement);
int DateTimeCounter = 0;
for (; DateTimeCounter < FrontPartials_Dict.Keys.Count; DateTimeCounter++)//updates CalendarIDAndNonPartialSubCalEvents if frontpartial Startime has been passed. Alls updates FrontPartials_Dict
{
DateTime eachDateTIme = FrontPartials_Dict.Keys.ToList()[DateTimeCounter];
if (EarliestReferenceTIme >= eachDateTIme)
{
List<mTuple<bool, SubCalendarEvent>> mTUpleSubCalEvents = FrontPartials_Dict[eachDateTIme];
foreach (mTuple<bool, SubCalendarEvent> eachmTUple in mTUpleSubCalEvents)
{
string CalLevel0ID = eachmTUple.Item2.SubEvent_ID.getLevelID(0);
if (!CompleteArranegement.Contains(eachmTUple.Item2))
{
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(CalLevel0ID))
{
CalendarIDAndNonPartialSubCalEvents[CalLevel0ID].Add(eachmTUple.Item2.ID, eachmTUple.Item2);
}
else
{
//CalendarIDAndNonPartialSubCalEvents.Add(CalLevel0ID, new List<SubCalendarEvent>() { KeyValuePair0.Value.Item2 });
CalendarIDAndNonPartialSubCalEvents.Add(CalLevel0ID, new Dictionary<string, SubCalendarEvent>());
CalendarIDAndNonPartialSubCalEvents[CalLevel0ID].Add(eachmTUple.Item2.ID, eachmTUple.Item2);
}
}
}
FrontPartials_Dict.Remove(eachDateTIme);
}
}
}
if (PreserveRestrictedIndex)//verifies if we took the path of restricted or front partial element. The latter needs a preservation of the current restricted Subcalevent index index
{
--i;
}
}
else
{//No FrontPartials
DateTime ReferenceEndTime = restrictedSnugFitAvailable[i].Item2.Start;
PertinentFreeSpot = new TimeLine(EarliestReferenceTIme, ReferenceEndTime);
BorderElementBeginning = CompleteArranegement.Count > 0 ? CompleteArranegement[CompleteArranegement.Count - 1] : null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = restrictedSnugFitAvailable[i].Item2;//uses restricted value as boundary element
LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy,Occupancy);
if (LowestCostArrangement.Count > 0)
{
if (!(LowestCostArrangement[0].getCalendarEventRange.Start == PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, PertinentFreeSpot);
}
EarliestReferenceTIme = FreeSpotUpdated.End;// LowestCostArrangement[LowestCostArrangement.Count - 1].End;
}
foreach (SubCalendarEvent eachSubCalendarEvent in LowestCostArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
List<SubCalendarEvent> AdditionalCOstArrangement = new System.Collections.Generic.List<SubCalendarEvent>();
if (j < restrictedSnugFitAvailable.Count)
{
DateTime StartDateTimeAfterFitting = PertinentFreeSpot.End;//this is the barring end time of the preceding boundary search
DateTime RelativeEndTime = restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End > restrictedSnugFitAvailable[j].Item2.Start ? restrictedSnugFitAvailable[j].Item2.Start : restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End;
RelativeEndTime -= restrictedSnugFitAvailable[i].Item2.ActiveDuration;
TimeLine CurrentlyFittedTimeLine = new TimeLine(StartDateTimeAfterFitting, RelativeEndTime);
BorderElementBeginning = CompleteArranegement.Count > 0 ? CompleteArranegement[CompleteArranegement.Count - 1] : null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = restrictedSnugFitAvailable[i].Item2;//uses restricted value as boundary element
AdditionalCOstArrangement = OptimizeArrangeOfSubCalEvent(CurrentlyFittedTimeLine, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy, Occupancy);
if (AdditionalCOstArrangement.Count > 0)
{//Additional get populated
if (!(AdditionalCOstArrangement[0].getCalendarEventRange.Start == CurrentlyFittedTimeLine.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, CurrentlyFittedTimeLine.End);
Utility.PinSubEventsToStart(AdditionalCOstArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = new TimeLine(AdditionalCOstArrangement[0].getCalendarEventRange.Start, CurrentlyFittedTimeLine.End);
Utility.PinSubEventsToStart(AdditionalCOstArrangement, FreeSpotUpdated);
}
foreach (SubCalendarEvent eachSubCalendarEvent in AdditionalCOstArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
RelativeEndTime = AdditionalCOstArrangement[AdditionalCOstArrangement.Count - 1].End;
RelativeEndTime += restrictedSnugFitAvailable[i].Item2.ActiveDuration; ;
FreeSpotUpdated = new TimeLine(FreeSpotUpdated.Start, RelativeEndTime);
AdditionalCOstArrangement = PlaceSubCalEventInLowestCostPosition(FreeSpotUpdated, restrictedSnugFitAvailable[i].Item2, AdditionalCOstArrangement);
}
else
{//if there is no other Restricted in list
RelativeEndTime += restrictedSnugFitAvailable[i].Item2.ActiveDuration;
CurrentlyFittedTimeLine = new TimeLine(CurrentlyFittedTimeLine.Start, RelativeEndTime);
AdditionalCOstArrangement = PlaceSubCalEventInLowestCostPosition(CurrentlyFittedTimeLine, restrictedSnugFitAvailable[i].Item2, AdditionalCOstArrangement);
}
}
else
{
DateTime RelativeEndTime = restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End > FreeBoundary.End ? FreeBoundary.End : restrictedSnugFitAvailable[i].Item2.getCalendarEventRange.End;
TimeLine CurrentlyFittedTimeLine = new TimeLine(EarliestReferenceTIme, RelativeEndTime);
AdditionalCOstArrangement = PlaceSubCalEventInLowestCostPosition(CurrentlyFittedTimeLine, restrictedSnugFitAvailable[i].Item2, AdditionalCOstArrangement);
}
List<SubCalendarEvent> var2 = new System.Collections.Generic.List<SubCalendarEvent>();//List is a addition of LowestCostArrangement and AdditionalCOstArrangement
var2 = LowestCostArrangement.Concat(AdditionalCOstArrangement).ToList();
CompleteArranegement.AddRange(LowestCostArrangement);
CompleteArranegement.AddRange(AdditionalCOstArrangement);
if (CompleteArranegement.Count > 0)
{
EarliestReferenceTIme = CompleteArranegement[CompleteArranegement.Count - 1].End;
}
}
}
{ //Handles THe Last Free Space outside of rigids
TimeLine FreeSpotOutSideRigids = new TimeLine(EarliestReferenceTIme, FreeBoundary.End);
TimeLine PertinentFreeSpot = new TimeLine(EarliestReferenceTIme, FreeBoundary.End); ;
TimeLine FreeSpotUpdated;
List<SubCalendarEvent> LowestCostArrangement;
if (ListOfFrontPartialsStartTime.Count > 0)
{
for (FrontPartialCounter = 0; FrontPartialCounter < ListOfFrontPartialsStartTime.Count; FrontPartialCounter++)
{
DateTime PertinentFreeSpotStart = EarliestReferenceTIme;
DateTime PertinentFreeSpotEnd;
PertinentFreeSpotEnd = ListOfFrontPartialsStartTime[FrontPartialCounter];
//FrontPartials_Dict.Remove(ListOfFrontPartialsStartTime[FrontPartialCounter]);
ListOfFrontPartialsStartTime.RemoveAt(FrontPartialCounter);
--FrontPartialCounter;
PertinentFreeSpot = new TimeLine(PertinentFreeSpotStart, PertinentFreeSpotEnd);
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();
BorderElementBeginning = CompleteArranegement.Count > 0 ? CompleteArranegement[CompleteArranegement.Count - 1] : null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = null;
LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy, Occupancy);
DateTime LatestTimeForBetterEarlierReferenceTime = PertinentFreeSpot.Start;
LastSubCalElementForEarlierReferenceTime = ((CompleteArranegement.Count < 1) || (CompleteArranegement == null) ? null : CompleteArranegement[CompleteArranegement.Count - 1]);
if (LowestCostArrangement.Count > 0)
{
if ((LowestCostArrangement[0].getCalendarEventRange.Start != PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();// new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
EarliestReferenceTIme = PertinentFreeSpot.End;// LowestCostArrangement[LowestCostArrangement.Count - 1].End;
SubCalendarEvent LastSubCalEvent = LowestCostArrangement[LowestCostArrangement.Count - 1];
LatestTimeForBetterEarlierReferenceTime = LastSubCalEvent.End;
LastSubCalElementForEarlierReferenceTime = LastSubCalEvent;
/*
Dictionary<string, double> AllValidNodes = CalendarEvent.DistanceToAllNodes(LastSubCalEvent.SubEvent_ID.getLevelID(0));
SubCalendarEvent AppendableEVent;
foreach (string eachstring in AllValidNodes.Keys)
{
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(eachstring))
{
AppendableEVent = CalendarIDAndNonPartialSubCalEvents[eachstring].ToList()[0].Value;//Assumes Theres Always an element
if ((AppendableEVent.ActiveDuration <= (FreeBoundary.End - LastSubCalEvent.End)) && (!LowestCostArrangement.Contains(AppendableEVent)))
{
LowestCostArrangement.Add(AppendableEVent);
CalendarIDAndNonPartialSubCalEvents[eachstring].Remove(AppendableEVent.ID);
if (CalendarIDAndNonPartialSubCalEvents[eachstring].Count < 1)//checks if List is empty. Deletes keyValuepair if list is empty
{
CalendarIDAndNonPartialSubCalEvents.Remove(eachstring);
}
FreeSpotUpdated = new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
EarliestReferenceTIme = AppendableEVent.End;
break;
}
}
}*/
}
TimeLineUpdated = null;
TimeLineUpdated = ObtainBetterEarlierReferenceTime(LowestCostArrangement, CalendarIDAndNonPartialSubCalEvents, FreeBoundary.End - LatestTimeForBetterEarlierReferenceTime, EarliestReferenceTIme, new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End), LastSubCalElementForEarlierReferenceTime);
if (TimeLineUpdated != null)
{
LowestCostArrangement = TimeLineUpdated.Item2;
EarliestReferenceTIme = TimeLineUpdated.Item1;
}
foreach (SubCalendarEvent eachSubCalendarEvent in LowestCostArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
CompleteArranegement.AddRange(LowestCostArrangement);
}
}
DateTime ReferenceEndTime = FreeBoundary.End;
PertinentFreeSpot = new TimeLine(EarliestReferenceTIme, ReferenceEndTime);
/*LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(null, null), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy);
if (LowestCostArrangement.Count > 0)
{
if (!(LowestCostArrangement[0].getCalendarEventRange.Start == PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();// new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
EarliestReferenceTIme = FreeSpotUpdated.End;// LowestCostArrangement[LowestCostArrangement.Count - 1].End;
}*/
BorderElementBeginning = CompleteArranegement.Count > 0 ? CompleteArranegement[CompleteArranegement.Count - 1] : null;//Checks if Complete arrangement has partially being filled. Sets Last elements as boundary Element
BorderElementEnd = null;
LowestCostArrangement = OptimizeArrangeOfSubCalEvent(PertinentFreeSpot, new Tuple<SubCalendarEvent, SubCalendarEvent>(BorderElementBeginning, BorderElementEnd), CompatibleWithList.Values.ToList(), PossibleEntries_Cpy, Occupancy);
LastSubCalElementForEarlierReferenceTime = ((CompleteArranegement.Count < 1) || (CompleteArranegement == null) ? null : CompleteArranegement[CompleteArranegement.Count - 1]);
DateTime LimitForBetterEarlierReferencTime = EarliestReferenceTIme;
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();
if (LowestCostArrangement.Count > 0)
{
if ((LowestCostArrangement[0].getCalendarEventRange.Start != PertinentFreeSpot.Start))//Pin SubEvents To Start
{//if the first element is not a partial Sub Cal Event element
FreeSpotUpdated = new TimeLine(EarliestReferenceTIme, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
}
else
{
FreeSpotUpdated = PertinentFreeSpot.CreateCopy();// new TimeLine(LowestCostArrangement[0].getCalendarEventRange.Start, PertinentFreeSpot.End);
Utility.PinSubEventsToStart(LowestCostArrangement, PertinentFreeSpot);
}
EarliestReferenceTIme = PertinentFreeSpot.End;// LowestCostArrangement[LowestCostArrangement.Count - 1].End;
SubCalendarEvent LastSubCalEvent = LowestCostArrangement[LowestCostArrangement.Count - 1];
LimitForBetterEarlierReferencTime=LastSubCalEvent.End;
LastSubCalElementForEarlierReferenceTime = LastSubCalEvent;
/*
Dictionary<string, double> AllValidNodes = CalendarEvent.DistanceToAllNodes(LastSubCalEvent.SubEvent_ID.getLevelID(0));
SubCalendarEvent AppendableEVent;
foreach (string eachstring in AllValidNodes.Keys)
{
if (CalendarIDAndNonPartialSubCalEvents.ContainsKey(eachstring))
{
AppendableEVent = CalendarIDAndNonPartialSubCalEvents[eachstring].ToList()[0].Value;//Assumes Theres Always an element
if ((AppendableEVent.ActiveDuration <= (FreeBoundary.End - LastSubCalEvent.End)) && (!LowestCostArrangement.Contains(AppendableEVent)))
{
LowestCostArrangement.Add(AppendableEVent);
CalendarIDAndNonPartialSubCalEvents[eachstring].Remove(AppendableEVent.ID);
if (CalendarIDAndNonPartialSubCalEvents[eachstring].Count < 1)//checks if List is empty. Deletes keyValuepair if list is empty
{
CalendarIDAndNonPartialSubCalEvents.Remove(eachstring);
}
FreeSpotUpdated = new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End);
Utility.PinSubEventsToStart(LowestCostArrangement, FreeSpotUpdated);
EarliestReferenceTIme = AppendableEVent.End;
break;
}
}
}*/
}
TimeLineUpdated = null;
TimeLineUpdated = ObtainBetterEarlierReferenceTime(LowestCostArrangement, CalendarIDAndNonPartialSubCalEvents, FreeBoundary.End - LimitForBetterEarlierReferencTime, EarliestReferenceTIme, new TimeLine(FreeSpotUpdated.Start, FreeBoundary.End), LastSubCalElementForEarlierReferenceTime);
if (TimeLineUpdated != null)
{
LowestCostArrangement = TimeLineUpdated.Item2;
EarliestReferenceTIme = TimeLineUpdated.Item1;
}
foreach (SubCalendarEvent eachSubCalendarEvent in LowestCostArrangement)
{
--CompatibleWithList[eachSubCalendarEvent.ActiveDuration].Item1;
PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Remove(eachSubCalendarEvent.ID);
string SubCalString = eachSubCalendarEvent.SubEvent_ID.getLevelID(0);
if(CalendarIDAndNonPartialSubCalEvents.ContainsKey(SubCalString))
{
CalendarIDAndNonPartialSubCalEvents[SubCalString].Remove(eachSubCalendarEvent.ID);
if (CalendarIDAndNonPartialSubCalEvents[SubCalString].Count < 1)
{
CalendarIDAndNonPartialSubCalEvents.Remove(SubCalString);
}
}
if (PossibleEntries_Cpy[eachSubCalendarEvent.ActiveDuration].Count < 1)
{
PossibleEntries_Cpy.Remove(eachSubCalendarEvent.ActiveDuration);
}
}
CompleteArranegement.AddRange(LowestCostArrangement);
}
List<mTuple<bool, SubCalendarEvent>> retValue = new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>();
foreach (SubCalendarEvent eachSubCalendarEvent in CompleteArranegement)
{
PossibleEntries[eachSubCalendarEvent.ActiveDuration][eachSubCalendarEvent.ID].Item1 = true;
retValue.Add(PossibleEntries[eachSubCalendarEvent.ActiveDuration][eachSubCalendarEvent.ID]);
}
//List<List<SubCalendarEvent>> unrestrictedValidCombinations = generateCombinationForDifferentEntries(CompatibleWithList, PossibleEntries);
retValue = reAlignSubCalEvents(FreeBoundary, retValue);
if (TotalEventsForThisTImeLine != retValue.Count)
{
;
}
return retValue;
}
List<mTuple<bool, SubCalendarEvent>> FurtherFillTimeLineWithSubCalEvents(List<mTuple<bool, SubCalendarEvent>> AllReadyAssignedSubCalEvents, TimeLine ReferenceTimeLine, Dictionary<TimeLine, Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>> AllCompatibleWithList, TimeLine PreceedingTimeLine, Dictionary<TimeLine, Dictionary<TimeSpan, Dictionary<string, mTuple<bool, SubCalendarEvent>>>> PossibleEntries)
{
/*
* CompatibleWithList has whats left after stitchUnRestrictedSubCalendarEvent has removed all possible fittable Events
* Hack Alert: The current implementation does not optimize for restricted values
*/
List<SubCalendarEvent> AssignedSubCalendarEvents = new System.Collections.Generic.List<SubCalendarEvent>();
foreach (mTuple<bool, SubCalendarEvent> eachmTuple in AllReadyAssignedSubCalEvents)
{
AssignedSubCalendarEvents.Add(eachmTuple.Item2);
}
List<TimeSpanWithStringID> LeftOvers = new System.Collections.Generic.List<TimeSpanWithStringID>();
foreach (KeyValuePair<TimeSpan, mTuple<int, TimeSpanWithStringID>> eachKeyValuePair in AllCompatibleWithList[PreceedingTimeLine])
{
if (eachKeyValuePair.Value.Item1 > 0)
{
LeftOvers.Add(eachKeyValuePair.Value.Item2);
}
}
PreceedingTimeLine.Empty();
TimeLine UpdatedTImeLine = Utility.AddSubCaleventsToTimeLine(PreceedingTimeLine, AssignedSubCalendarEvents);
PreceedingTimeLine.AddBusySlots(UpdatedTImeLine.OccupiedSlots);
List<TimeLine> AllFreeSpots = PreceedingTimeLine.getAllFreeSlots().ToList();
Dictionary<TimeLine, List<mTuple<bool, SubCalendarEvent>>> matchingValidSubcalendarEvents = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>>();//Dictionary contains a match up of the free within already assigned variables and possible fillers
Dictionary<TimeLine, Dictionary<string, mTuple<int, TimeSpanWithStringID>>> ForSnugArray = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.Dictionary<string, mTuple<int, TimeSpanWithStringID>>>();
Dictionary<TimeLine, SnugArray> FreeSpotSnugArrays = new System.Collections.Generic.Dictionary<TimeLine, SnugArray>();
Dictionary<TimeLine, List<Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>>> FreeSpotSnugPossibiilities = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<System.Collections.Generic.Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>>>();
//Dictionary<TimeLine, List<TimeSpanWithStringID>> FreeSpotSnugPossibilities = new System.Collections.Generic.Dictionary<TimeLine, SnugArray>();
Dictionary<string, SubCalendarEvent> AllMovableSubCalEvents = new System.Collections.Generic.Dictionary<string, SubCalendarEvent>();
List<Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>> AllMoveOvrSet = new System.Collections.Generic.List<System.Collections.Generic.Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>>();
// Dictionary<string, Dictionary<SubCalendarEvent, List<TimeLine>>> SubEventToMatchingTimeLinePossible = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.Dictionary<SubCalendarEvent, System.Collections.Generic.List<TimeLine>>>();
Dictionary<TimeLine, Dictionary<TimeSpan, List<mTuple<bool, SubCalendarEvent>>>> TimeLine_WithMathChingSubCalevents = new Dictionary<TimeLine, Dictionary<TimeSpan, List<mTuple<bool, SubCalendarEvent>>>>();// string in second dictionary is the String of the duration of the SubCalendarEvent
Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> TotalPossibleTimeSpanWithStrings = new System.Collections.Generic.Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>();
foreach (TimeLine eachTimeLine in AllFreeSpots)
{
List<mTuple<bool, SubCalendarEvent>> PossibleFillers = removeSubCalEventsThatCantWorkWithTimeLine(eachTimeLine, PossibleEntries[PreceedingTimeLine].ToList(), true);//hack we need to ensure cases of partial fit
ForSnugArray.Add(eachTimeLine, new System.Collections.Generic.Dictionary<string, mTuple<int, TimeSpanWithStringID>>());
TimeLine_WithMathChingSubCalevents.Add(eachTimeLine, new System.Collections.Generic.Dictionary<TimeSpan, System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>>());
foreach (mTuple<bool, SubCalendarEvent> eachmTuple in PossibleFillers)
{
if (ForSnugArray[eachTimeLine].ContainsKey(eachmTuple.Item2.ActiveDuration.ToString()))
{
++ForSnugArray[eachTimeLine][eachmTuple.Item2.ActiveDuration.ToString()].Item1;
}
else
{
ForSnugArray[eachTimeLine].Add(eachmTuple.Item2.ActiveDuration.ToString(), new mTuple<int, TimeSpanWithStringID>(1, new TimeSpanWithStringID(eachmTuple.Item2.ActiveDuration, eachmTuple.Item2.ActiveDuration.ToString())));
}
if (!AllMovableSubCalEvents.ContainsKey(eachmTuple.Item2.ID))//populates all movable SubCalendarEVents
{
AllMovableSubCalEvents.Add(eachmTuple.Item2.ID, eachmTuple.Item2);
if (TotalPossibleTimeSpanWithStrings.ContainsKey(eachmTuple.Item2.ActiveDuration))
{
++TotalPossibleTimeSpanWithStrings[eachmTuple.Item2.ActiveDuration].Item1;
}
else
{
TotalPossibleTimeSpanWithStrings.Add(eachmTuple.Item2.ActiveDuration, new mTuple<int, TimeSpanWithStringID>(1, new TimeSpanWithStringID(eachmTuple.Item2.ActiveDuration, eachmTuple.Item2.ActiveDuration.ToString())));
}
}
TimeSpan IdTimeSpan = eachmTuple.Item2.ActiveDuration;
if (TimeLine_WithMathChingSubCalevents[eachTimeLine].ContainsKey(IdTimeSpan))
{
TimeLine_WithMathChingSubCalevents[eachTimeLine][IdTimeSpan].Add(eachmTuple);
}
else
{
TimeLine_WithMathChingSubCalevents[eachTimeLine].Add(IdTimeSpan, new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>() { eachmTuple });
}
/*if (SubEventToMatchingTimeLinePossible.ContainsKey(eachmTuple.Item2.ActiveDuration.ToString()))// builds a dictionary of the TimeSpan String ID and a Dictionary of SubCalendar EVents with a List of feasible TimeLine
{
if (SubEventToMatchingTimeLinePossible[eachmTuple.Item2.ActiveDuration.ToString()].ContainsKey(eachmTuple.Item2))
{
SubEventToMatchingTimeLinePossible[eachmTuple.Item2.ActiveDuration.ToString()][eachmTuple.Item2].Add(eachTimeLine);
}
else
{
SubEventToMatchingTimeLinePossible[eachmTuple.Item2.ActiveDuration.ToString()].Add(eachmTuple.Item2, new System.Collections.Generic.List<TimeLine>() { eachTimeLine });
}
}
else
{
SubEventToMatchingTimeLinePossible.Add(eachmTuple.Item2.ActiveDuration.ToString(), new System.Collections.Generic.Dictionary<SubCalendarEvent, System.Collections.Generic.List<TimeLine>>());
SubEventToMatchingTimeLinePossible[eachmTuple.Item2.ActiveDuration.ToString()].Add(eachmTuple.Item2, new System.Collections.Generic.List<TimeLine>() { eachTimeLine });
}*/
}
matchingValidSubcalendarEvents.Add(eachTimeLine, PossibleFillers);
}
foreach (TimeLine eachTimeLine in AllFreeSpots)
{
FreeSpotSnugArrays.Add(eachTimeLine, new SnugArray(ForSnugArray[eachTimeLine].Values.ToList(), eachTimeLine.TimelineSpan));
}
foreach (TimeLine eachTimeLine in AllFreeSpots)
{
FreeSpotSnugPossibiilities.Add(eachTimeLine, FreeSpotSnugArrays[eachTimeLine].MySnugPossibleEntries);
}
foreach (List<Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>> allFreeSpotSnugPossibiilities in FreeSpotSnugPossibiilities.Values)
{
AllMoveOvrSet.AddRange(allFreeSpotSnugPossibiilities);
}
TimeSpanWithStringID UnAssignedTimeSpanWithString = new TimeSpanWithStringID(ReferenceTimeLine.TimelineSpan, ReferenceTimeLine.TimelineSpan.ToString());
/*if (LeftOvers.Count > 0)
{
UnAssignedTimeSpanWithString = LeftOvers[0];
}*/
TimeSpan TotalMovedSofar = new TimeSpan(0);
Dictionary<TimeLine, List<mTuple<bool, SubCalendarEvent>>> FreeSpots_MatchedEvents = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>>();
Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> CompatibleListForReferenceTimeLine = AllCompatibleWithList[ReferenceTimeLine];
foreach (TimeLine eachTimeLine in AllFreeSpots)
{
FreeSpots_MatchedEvents.Add(eachTimeLine, new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>());
Tuple<Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>, Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>> UpdatedCompatibleList_BestSnugPossibility = UpdateCompatibleListOfTimeLine(CompatibleListForReferenceTimeLine, FreeSpotSnugPossibiilities[eachTimeLine], ReferenceTimeLine, UnAssignedTimeSpanWithString, TotalPossibleTimeSpanWithStrings);
Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> UpdatedCompatibleList = UpdatedCompatibleList_BestSnugPossibility.Item1;
Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> BestSnugAvailability = UpdatedCompatibleList_BestSnugPossibility.Item2;
TotalMovedSofar += SnugArray.TotalTimeSpanOfSnugPossibility(BestSnugAvailability);
Dictionary<TimeSpan, List<mTuple<bool, SubCalendarEvent>>> TimeLineMatchingSubEvents = TimeLine_WithMathChingSubCalevents[eachTimeLine];
foreach (KeyValuePair<TimeSpan, mTuple<int, TimeSpanWithStringID>> eachKeyValuePair in BestSnugAvailability)
{
if (TimeLineMatchingSubEvents[eachKeyValuePair.Key].Count > 0)
{
FreeSpots_MatchedEvents[eachTimeLine].Add(TimeLineMatchingSubEvents[eachKeyValuePair.Key][0]);
TimeLineMatchingSubEvents[eachKeyValuePair.Key].RemoveAt(0);
--TotalPossibleTimeSpanWithStrings[eachKeyValuePair.Key].Item1;
if (TotalPossibleTimeSpanWithStrings[eachKeyValuePair.Key].Item1 == 0)
{
TotalPossibleTimeSpanWithStrings.Remove(eachKeyValuePair.Key);
}
}
else
{
;
}
}
//KeyValuePair<string, mTuple<int, TimeSpanWithStringID>> eachKeyValuePair
List<TimeSpan> AllKeys = CompatibleListForReferenceTimeLine.Keys.ToList();
foreach (TimeSpan eachTimeSpan in AllKeys)//Updates the Compatible List of the Reference timelin, in order to reflect movement in data
{
if (UpdatedCompatibleList.ContainsKey(eachTimeSpan))//checks if reference timeLine has updated keys
{
CompatibleListForReferenceTimeLine[eachTimeSpan] = UpdatedCompatibleList[eachTimeSpan];
}
else
{
CompatibleListForReferenceTimeLine.Remove(eachTimeSpan);
}
}
}
TimeSpan FreeSpaceAfterMovement = ReferenceTimeLine.TimelineSpan - SnugArray.TotalTimeSpanOfSnugPossibility(CompatibleListForReferenceTimeLine);
if (LeftOvers.Count > 0)//checks if there are move overs from preceeding compatible TimeLine
{
SnugArray BestFitIntoCurrentTimeLine = new SnugArray(AllCompatibleWithList[PreceedingTimeLine].Values.ToList(), FreeSpaceAfterMovement);//Tries to construct tightest fit on newly created free space in reference timelin....hack alert, it does not prioritize restricted elements
List<Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>>> SortedData = BestFitIntoCurrentTimeLine.MySnugPossibleEntries;//sort the snug possibility based on mst filling
if (SortedData.Count > 0)
{
Dictionary<TimeSpan, mTuple<int, TimeSpanWithStringID>> selectedDictionary = SortedData[SortedData.Count - 1];
foreach (KeyValuePair<TimeSpan, mTuple<int, TimeSpanWithStringID>> eachKeyValuePair in selectedDictionary)
{
if (CompatibleListForReferenceTimeLine.ContainsKey(eachKeyValuePair.Key))
{
CompatibleListForReferenceTimeLine[eachKeyValuePair.Key].Item1 += eachKeyValuePair.Value.Item1;
AllCompatibleWithList[PreceedingTimeLine][eachKeyValuePair.Key].Item1 -= eachKeyValuePair.Value.Item1;
}
else
{
CompatibleListForReferenceTimeLine.Add(eachKeyValuePair.Key, eachKeyValuePair.Value);
AllCompatibleWithList[PreceedingTimeLine][eachKeyValuePair.Key].Item1 -= eachKeyValuePair.Value.Item1;
}
if (AllCompatibleWithList[PreceedingTimeLine][eachKeyValuePair.Key].Item1 < 0)
{
;
}
}
}
}
List<mTuple<bool, SubCalendarEvent>> retValue = new System.Collections.Generic.List<mTuple<bool, SubCalendarEvent>>(AllReadyAssignedSubCalEvents);
foreach (TimeLine eachTimeLine in AllFreeSpots)//Snaps each Subcalevent to the beginning of a free TimeLine
{
List<SubCalendarEvent> ListOfSubCalEvents = Utility.mTupleToSubCalEvents(FreeSpots_MatchedEvents[eachTimeLine]);
if (Utility.PinSubEventsToStart(ListOfSubCalEvents, eachTimeLine))
{
retValue.AddRange(FreeSpots_MatchedEvents[eachTimeLine]);
}
else
{
;
}
}
return retValue;
}
// this looks at the timeline of the calendar event and then tries to rearrange all subevents within the range to suit final output. Such that there will be sufficient time space for each subevent
KeyValuePair<CalendarEvent, TimeLine> ReArrangeTimeLineWithinWithinCalendaEventRange(CalendarEvent MyCalendarEvent)
{
/*
Name{: Jerome Biotidara
* this function is responsible for making sure there is some dynamic allotment of time to the subeevents. It takes a calendarevent, checks the alloted time frame and tries to move subevents within the time frame to satisfy the final goal.
*/
SubCalendarEvent[] ArrayOfInterferringSubEvents = getInterferringSubEvents(MyCalendarEvent);//It gets all the subevents within the time frame
ArrayOfInterferringSubEvents = SortSubCalendarEvents(ArrayOfInterferringSubEvents.ToList(), false).ToArray();
BusyTimeLine[] InterferringDateTime = new BusyTimeLine[ArrayOfInterferringSubEvents.Length];
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
int i=0;
for (; i < InterferringDateTime.Length; i++)//for loop populates InteferringDateTIme so that it can be populated
{
InterferringDateTime[i] = ArrayOfInterferringSubEvents[i].ActiveSlot;
}
InterferringDateTime = SortBusyTimeline(InterferringDateTime.ToList(), false).ToArray();
List<BusyTimeLine>[] MyEdgeElements = getEdgeElements(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<CalendarEvent>[] CalendarEventsTimeCategories = CategorizeCalendarEventTimeLine(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<SubCalendarEvent>[]SubEventsTimeCategories= CategorizeSubEventsTimeLine(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<SubCalendarEvent> RigidSubCalendarEvents = new List<SubCalendarEvent>(0);
List<BusyTimeLine> RigidSubCalendarEventsBusyTimeLine = new List<BusyTimeLine>(0);
i = 0;
int j = 0;
for (; i < SubEventsTimeCategories.Length; i++)//loop detects the rigid subevents and populates RigidSubCalendarEvents list
{
j = 0;
for (; j < SubEventsTimeCategories[i].Count; j++)
{
if (SubEventsTimeCategories[i][j].Rigid)
{
RigidSubCalendarEvents.Add(SubEventsTimeCategories[i][j]);
RigidSubCalendarEventsBusyTimeLine.Add(SubEventsTimeCategories[i][j].ActiveSlot);
}
}
}
ArrayOfInterferringSubEvents = Utility.NotInList(ArrayOfInterferringSubEvents.ToList(), RigidSubCalendarEvents).ToArray();
List<CalendarEvent> EndingBeforeDeadlineList = CalendarEventsTimeCategories[1].Concat(CalendarEventsTimeCategories[3]).ToList();
CalendarEvent[] EndingBeforeDeadlineArray = EndingBeforeDeadlineList.ToArray();
Array.Sort(EndingBeforeDeadlineArray, CalendarEvent.CompareByEndDate);
EndingBeforeDeadlineList = EndingBeforeDeadlineArray.ToList();
//List<CalendarEvent>[]SubEventsTimeCategories= CategorizeSubEventsTimeLine
/*
* SubEventsTimeCategories has 4 list of containing lists.
* 1st is a List with Elements Starting before The Mycalendaervent timeline and ends after the busytimeline
* 2nd is a list with elements starting before the mycalendarvent timeline but ending before the myevent timeline
* 3rd is a list with elements starting after the Mycalendar event start time but ending after the Myevent timeline
* 4th is a list with elements starting after the MyCalendar event start time and ends before the Myevent timeline
* */
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = generateDictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents(ArrayOfInterferringSubEvents.ToList());
if (MyCalendarEvent.RepetitionStatus == false)//generates random subevents for the calendar event
{
SubCalendarEvent[] TempSubCalendarEventsForMyCalendarEvent = new SubCalendarEvent[MyCalendarEvent.NumberOfSplit];
//int i;
for (i = 0; i < TempSubCalendarEventsForMyCalendarEvent.Length; i++)//populates the subevents for the calendar event
{
TimeSpan MyActiveTimeSpanPerSplit = new TimeSpan((long)((MyCalendarEvent.ActiveDuration.TotalSeconds / MyCalendarEvent.NumberOfSplit) * 10000000));
TempSubCalendarEventsForMyCalendarEvent[i] = new SubCalendarEvent(MyActiveTimeSpanPerSplit, MyCalendarEvent.Start, (MyCalendarEvent.Start + MyActiveTimeSpanPerSplit), new TimeSpan(), MyCalendarEvent.ID, MyCalendarEvent.EventTimeLine);
TempSubCalendarEventsForMyCalendarEvent[i] = new SubCalendarEvent(TempSubCalendarEventsForMyCalendarEvent[i].ID, TempSubCalendarEventsForMyCalendarEvent[i].Start, TempSubCalendarEventsForMyCalendarEvent[i].End, new BusyTimeLine(TempSubCalendarEventsForMyCalendarEvent[i].ID, TempSubCalendarEventsForMyCalendarEvent[i].Start, TempSubCalendarEventsForMyCalendarEvent[i].End), MyCalendarEvent.EventTimeLine);
MyCalendarEvent.AllEvents[i] = TempSubCalendarEventsForMyCalendarEvent[i];
}
}
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(MyCalendarEvent, MyCalendarEvent.AllEvents.ToList());
List<CalendarEvent> SortedInterFerringCalendarEvents_Deadline = DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList();
SortedInterFerringCalendarEvents_Deadline = SortedInterFerringCalendarEvents_Deadline.OrderBy(obj => obj.End).ToList();
//SortCalendarEvent(DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList(),false);
//SortedInterFerringCalendarEvents.Add(MyCalendarEvent);
//SubEventsTimeCategories[]
TimeLine ReferenceTimeLine = new TimeLine(MyCalendarEvent.Start,MyCalendarEvent.End);
ReferenceTimeLine.AddBusySlots(RigidSubCalendarEventsBusyTimeLine.ToArray());//Adds all the rigid elements
TimeLine[] ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine), ReferenceTimeLine).ToArray();
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(ArrayOfFreeSpots, ReferenceTimeLine).ToArray();
//CompleteSchedule.MergeTimeLines(ReferenceTimeLine);//further check that mergre doesnt duplicate timeLines
//NotInList(SortedInterFerringCalendarEve,
Dictionary<TimeLine, List<CalendarEvent>> DictTimeLineAndListOfCalendarevent = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<CalendarEvent>>();
/*foreach (CalendarEvent MyCalendarEvent0 in EndingBeforeDeadlineArray)//Foreach statement pins interferring subevents to start of timeline//Disabling pintostart to see if Buildsnugpossibility can fix this
{
foreach (TimeLine MyTimeLine in ArrayOfFreeSpots)
{
TimeLine TimeLineAfterPinToStart=MyCalendarEvent0.PinSubEventsToStart(MyTimeLine, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[MyCalendarEvent0]);
if (TimeLineAfterPinToStart != null)
{
ReferenceTimeLine.MergeTimeLines(TimeLineAfterPinToStart);
break;
}
//CalendarEvent[] PertinentCalendarEvents = getPertinentCalendarEvents(EndingBeforeDeadlineArray, MyTimeLine);
//Array.Sort(PertinentCalendarEvents, CalendarEvent.CompareByEndDate);
//DictTimeLineAndListOfCalendarevent.Add(MyTimeLine, PertinentCalendarEvents.ToList());
}
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine),ReferenceTimeLine).ToArray();
}*/
/*foreach (TimeLine MyTimeLine in ArrayOfFreeSpots)
{
TimeLine TimeLineAfterPinToStart = MyCalendarEvent.PinSubEventsToStart(MyTimeLine, TempSubCalendarEventsForMyCalendarEvent.ToList());
if (TimeLineAfterPinToStart != null)
{
ReferenceTimeLine.MergeTimeLines(TimeLineAfterPinToStart);
break;
}
}*/
/*BusyTimeLine[] BeforeSnugListFunctionalityImplemented=CompleteSchedule.OccupiedSlots;//****IMPORTANT DO NOT DELETE UNLESS YOU UNDERSTAND WHY YOU WANT TO DELETE COMMENT SECTIONN
CompleteSchedule.OccupiedSlots=ReferenceTimeLine.OccupiedSlots;
MyCalendarEvent=EvaluateTotalTimeLineAndAssignValidTimeSpots(MyCalendarEvent);
if (MyCalendarEvent != null)
{
return MyCalendarEvent;
}*/
//DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(MyCalendarEvent, MyCalendarEvent.AllEvents.ToList());
//RETURN HERE JEROME
List<List<List<SubCalendarEvent>>> SnugListOfPossibleSubCalendarEventsClumps = BuildAllPossibleSnugLists(SortedInterFerringCalendarEvents_Deadline, MyCalendarEvent, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents, CalendarEventsTimeCategories, ReferenceTimeLine);
//Remember Jerome, I need to implement a functionality that permutates through the various options of pin to start option. So take for example two different event timeline that are pertinent to a free spot however one has a dead line preceeding the other, there will be a pin to start for two scenarios, one for each calendar event in which either of them gets pinned first.
return EvaluateEachSnugPossibiliyOfSnugPossibility(SnugListOfPossibleSubCalendarEventsClumps, ReferenceTimeLine,MyCalendarEvent);
;//this will not be the final output. I'll need some class that stores the current output of both rearrange busytimelines and deleted timelines
}
List<SubCalendarEvent> resolveInTo24HourSlots(List<SubCalendarEvent> currentListOfSubCalendarElements, TimeLine limitingTimeLine, mTuple<SubCalendarEvent,SubCalendarEvent>edgeElements=null)
{
//function takes a full freespot and tries to spread it out into 24 hour sections
//this is done by intially sending every subcalevenet towards the end of the Timeline after which it takes 24hour chunks and attempts to
List<SubCalendarEvent> currentListOfSubCalendarElements_cpy = currentListOfSubCalendarElements.ToList();
Utility.PinSubEventsToStart(currentListOfSubCalendarElements_cpy, limitingTimeLine);
TimeLine limitingTimeLine_cpy = limitingTimeLine.CreateCopy();
limitingTimeLine.AddBusySlots(currentListOfSubCalendarElements_cpy.Select(obj => obj.ActiveSlot));
List<TimeLineWithEdgeElements> AllFreeSpots = limitingTimeLine_cpy.getAllFreeSlotsWithEdges().ToList();
AllFreeSpots=AllFreeSpots.Where(obj => obj.TimelineSpan.Ticks > 0).OrderBy(obj=>obj.End).ToList();
for (int i = AllFreeSpots.Count() - 1; AllFreeSpots.Count() > 0; )
{
TimeLine eachTimeLine = AllFreeSpots[i];
List<SubCalendarEvent> reassignedElements = TossEndWards(currentListOfSubCalendarElements, eachTimeLine);//tries to toss any subcalendarevent towards the end
reassignedElements=reassignedElements.OrderBy(obj => obj.End).ToList();
Utility.PinSubEventsToEnd(reassignedElements, eachTimeLine);
SubCalendarEvent lastElement;// = reassignedElements.Last();
currentListOfSubCalendarElements.RemoveAll(obj => reassignedElements.Contains(obj));
if (reassignedElements.Count > 0)
{
lastElement = reassignedElements.First();
limitingTimeLine = new TimeLine(limitingTimeLine.Start, lastElement.Start);
}
else
{
currentListOfSubCalendarElements.OrderBy(obj => obj.End);
if (currentListOfSubCalendarElements.Count > 0)//hack alert you need to coscious of coliision scenario
{
lastElement = currentListOfSubCalendarElements.Last();
lastElement.PinToEnd(limitingTimeLine);
currentListOfSubCalendarElements.Remove(lastElement);
limitingTimeLine = new TimeLine(limitingTimeLine.Start, lastElement.Start);
}
else
{
break;
}
}
Utility.PinSubEventsToStart(currentListOfSubCalendarElements, limitingTimeLine);
limitingTimeLine.AddBusySlots(currentListOfSubCalendarElements.Select(obj => obj.ActiveSlot));
AllFreeSpots = limitingTimeLine.getAllFreeSlotsWithEdges().ToList();
i = AllFreeSpots.Count() - 1;
}
TimeSpan TotalDuration = Utility.SumOfActiveDuration(currentListOfSubCalendarElements_cpy);
double Occupancy = (double)TotalDuration.Ticks / (double)limitingTimeLine_cpy.TimelineSpan.Ticks;
List<SubCalendarEvent> currentListOfSubCalendarElements_cpy_ref = currentListOfSubCalendarElements_cpy.ToList();
Dictionary<string, mTuple<SubCalendarEvent, BusyTimeLine>> currentListOfSubCalendarElements_cpy_ref_Dict = currentListOfSubCalendarElements_cpy_ref.ToDictionary(obj => obj.ID, obj => new mTuple<SubCalendarEvent, BusyTimeLine>(obj, obj.ActiveSlot.CreateCopy()));
TimeLine limitingTimeLine_cpy_cpy_ref = limitingTimeLine_cpy.CreateCopy();
List<SubCalendarEvent> FullyUpdated = new List<SubCalendarEvent>();
while(true)
{
Tuple<List<SubCalendarEvent>, TimeLine> CollectionUpdated = every24Interval(currentListOfSubCalendarElements_cpy_ref, limitingTimeLine_cpy_cpy_ref, Occupancy, currentListOfSubCalendarElements_cpy_ref_Dict);
TimeSpan currTotalDuration = Utility.SumOfActiveDuration(CollectionUpdated.Item1);
double currOccupancy =-8898;
if(CollectionUpdated.Item2.TimelineSpan.Ticks>0)
{ currOccupancy = (double)currTotalDuration.Ticks / (double)CollectionUpdated.Item2.TimelineSpan.Ticks; }
if (currOccupancy > Occupancy)
{
;
}
FullyUpdated.AddRange(CollectionUpdated.Item1);
limitingTimeLine_cpy_cpy_ref = new TimeLine(CollectionUpdated.Item2.End, limitingTimeLine_cpy_cpy_ref.End);
currentListOfSubCalendarElements_cpy_ref.RemoveAll(obj => FullyUpdated.Contains(obj));
if ((currentListOfSubCalendarElements_cpy_ref.Count < 1) || (limitingTimeLine_cpy_cpy_ref.TimelineSpan.Ticks <= 0))
{
break;
}
}
currentListOfSubCalendarElements_cpy = currentListOfSubCalendarElements_cpy.OrderBy(obj => obj.End).ToList();
List<SubCalendarEvent> retValue = currentListOfSubCalendarElements_cpy;
return retValue;
}