public ClumpSubCalendarEvent(List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine)
{
Appendables=Appendables.OrderBy(obj => obj.getCalendarEventRange.End).ToList();
SubCalendarEvent RelativeSubEvent = Appendables[0];
Appendables.Remove(RelativeSubEvent);
ClumpSubCalendarEvent myThis = new ClumpSubCalendarEvent(RelativeSubEvent, Appendables, BoundaryTimeLine.CreateCopy());
SubCalEventsOverLapWithBase = myThis.SubCalEventsOverLapWithBase;
//List<SubCalendarEvent> NonOverLapping;
BaseEvent= myThis.BaseEvent;
this.BoundaryTimeLine =myThis.BoundaryTimeLine;
//List<SubCalendarEvent> BaseClump;
//List<ClumpSubCalendarEvent> NonOverLapping_Clump;
BreakOffClump= myThis.BreakOffClump;
ClumpedResults= myThis.ClumpedResults;
BaseReferenceStartTime = myThis.BaseReferenceStartTime;
}
public ClumpSubCalendarEvent(SubCalendarEvent BaseSubCalendarEvent, List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine)
{
SubCalEventsOverLapWithBase = new List<SubCalendarEvent>();
BaseEvent = BaseSubCalendarEvent;
DateTime var1 = BaseEvent.getCalendarEventRange.End < BoundaryTimeLine.End ? BaseEvent.getCalendarEventRange.End : BoundaryTimeLine.End;//hack assumes base can fit within boundary
this.BoundaryTimeLine = new TimeLine(BoundaryTimeLine.Start, var1);
DateTime ReferenceStartTime = var1 - BaseEvent.ActiveDuration;
BreakOffClump = null;
ClumpedResults = new Dictionary<SubCalendarEvent, ClumpSubCalendarEvent>();
int i = 0;
for (; i < Appendables.Count; i++)
{
List<SubCalendarEvent> ReferenceClump = new List<SubCalendarEvent>();
ReferenceClump.Add(BaseSubCalendarEvent);
DateTime TimeLimit = ReferenceStartTime - Appendables[i].ActiveDuration;
bool Zero = (Appendables[i].getCalendarEventRange.Start <= TimeLimit);
bool One = (TimeLimit >= BoundaryTimeLine.Start);
//bool Two = (BoundaryTimeLine.TimelineSpan>=Appendables[i].EventTimeLine.TimelineSpan);//this is a hack, since the length of SubcalEvent Event TimeLine is the same length of time as its busy time span
if (Zero && One)// && Two)
{
List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList();
// List<SubCalendarEvent> ExtendedList = ReferenceClump.ToList();
SubCalendarEvent RelativeSubEvent = Appendables[i];
Removed_Unnecessary.Remove(RelativeSubEvent);
// ExtendedList.Add((Appendables[i]));
ClumpedResults.Add(RelativeSubEvent, null);
//NonOverLapping_Clump.Add();
if (Removed_Unnecessary.Count > 0)
{
++Completed;
if (Completed >= 100)
{
break;
}
}
}
else
{
//List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList();
//List<SubCalendarEvent> ExtendedList = ReferenceClump.ToList();
//Removed_Unnecessary.Remove(Appendables[i]);
SubCalEventsOverLapWithBase.Add(Appendables[i]);
}
}
List<SubCalendarEvent> arg1=ClumpedResults.Keys.ToList();
//if(arg1!=null)
{
int j=0;
DateTime BaseReferenceEndTime = BaseEvent.getCalendarEventRange.End > BoundaryTimeLine.End ? BoundaryTimeLine.End : BaseEvent.getCalendarEventRange.End;//End Time for Base to be used as the reference for the current base end time
for (;j<arg1.Count;j++)
{
ClumpedResults[arg1[j]] = populateClumpedResults(BaseReferenceEndTime, arg1[j], ClumpedResults[arg1[j]], ReferenceStartTime - arg1[j].ActiveDuration, BoundaryTimeLine);
}
}
if (SubCalEventsOverLapWithBase.Count > 0)
{
SubCalendarEvent BreakOffSubCalEvent = SubCalEventsOverLapWithBase[0];
SubCalEventsOverLapWithBase.Remove(BreakOffSubCalEvent);
BreakOffClump = new ClumpSubCalendarEvent(BreakOffSubCalEvent, SubCalEventsOverLapWithBase, new TimeLine((getLeftMostPossibleStartLine(BaseEvent, BoundaryTimeLine) + BaseEvent.ActiveDuration), BoundaryTimeLine.End));
}
List<SubCalendarEvent> Fittable = new List<SubCalendarEvent>();
}
ClumpSubCalendarEvent populateClumpedResults(DateTime BaseEndTime,SubCalendarEvent refSubCalendarEvent, ClumpSubCalendarEvent refClumpSubCalendarEvent, DateTime RefereceStartTime, TimeLine BoundaryTimeLine)
{
List<SubCalendarEvent> Arg1 = ClumpedResults.Keys.ToList();
bool temp = Arg1.Remove(refSubCalendarEvent);
refClumpSubCalendarEvent = new ClumpSubCalendarEvent(RefereceStartTime,BaseEndTime, Arg1, BoundaryTimeLine);
return refClumpSubCalendarEvent;
}
public ClumpSubCalendarEvent(DateTime ReferenceStartTime, DateTime PreCeedingBaseEndtime,List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine)
{
/*
* This Constructor is called when a continuation in Clumping is made. Look at diagram below
*
* | |Clump1||baseEvent|| |
*
* The vertical bars represent the various boundaries(StartTime and Stop Time). Note there is no TimeSpace between Clump1 and baseEvent
*
* Clump1 in the image is a continuation in the clumping. Remember Clumping tries to build towards the Left. The ReferenceStartTime is the calculated start time of Clump1. PreCeedingBaseEndtime is the End time of the Base Event in the diagram. It will be used in the line with "BreakOffClump = new ClumpSubCalendarEvent..."
*/
int i = 0;
//NonOverLapping_Clump = new List<ClumpSubCalendarEvent>();
//OverLapping_Clump = new List<ClumpSubCalendarEvent>();
SubCalEventsOverLapWithBase = new List<SubCalendarEvent>();
List<SubCalendarEvent> UnClumppable = new List<SubCalendarEvent>();
ClumpedResults = new Dictionary<SubCalendarEvent, ClumpSubCalendarEvent>();
BreakOffClump = null;
this.BoundaryTimeLine = new TimeLine(BoundaryTimeLine.Start, ReferenceStartTime); ;
/*BaseEvent = BaseClump[0];//this can be reevaluated to cater to the most constrained. i.e the one with limted a later sart time and percentage fill for whatever is left.
ReferenceStartTime = BaseEvent.getCalendarEventRange.End < BoundaryTimeLine.End ? BaseEvent.getCalendarEventRange.End : BoundaryTimeLine.End;
foreach (SubCalendarEvent mySubCalendarEvent in BaseClump)
{
ReferenceStartTime -= BaseEvent.ActiveDuration;
}*/
for (; i < Appendables.Count; i++)
{
//List<SubCalendarEvent> ReferenceClump = new List<SubCalendarEvent>(BaseClump);
DateTime TimeLimit = ReferenceStartTime - Appendables[i].ActiveDuration;
bool Zero = (Appendables[i].getCalendarEventRange.Start <= TimeLimit);
bool One = (TimeLimit >= BoundaryTimeLine.Start);
//bool Two = (BoundaryTimeLine.TimelineSpan >= Appendables[i].EventTimeLine.TimelineSpan);
if (Zero && One)// && Two)
{
List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList();
SubCalendarEvent RelativeSubEvent = Appendables[i];
Removed_Unnecessary.Remove(RelativeSubEvent);
ClumpedResults.Add(RelativeSubEvent, null);
/*if (CompleteResolvedNonOverlapping.Count > 100)//This is a hack to resolve the memory issue
{
break;
}*/
}
else
{
SubCalEventsOverLapWithBase.Add(Appendables[i]);
}
}
List<SubCalendarEvent> arg1 = ClumpedResults.Keys.ToList();
int j = 0;
for (; j < arg1.Count; j++)
{
ClumpedResults[arg1[j]] = populateClumpedResults(PreCeedingBaseEndtime, arg1[j], ClumpedResults[arg1[j]], ReferenceStartTime - arg1[j].ActiveDuration, BoundaryTimeLine);
}
if (SubCalEventsOverLapWithBase.Count > 0)
{
SubCalendarEvent BreakOffSubCalEvent = SubCalEventsOverLapWithBase[0];
SubCalEventsOverLapWithBase.Remove(BreakOffSubCalEvent);
BreakOffClump = new ClumpSubCalendarEvent(BreakOffSubCalEvent, SubCalEventsOverLapWithBase, new TimeLine(PreCeedingBaseEndtime, BoundaryTimeLine.End));
}
}
List<List<SubCalendarEvent>> Pseudo_generateTreeCallsToSnugArray(List<SubCalendarEvent> SortedAvailableSubCalEvents_Deadline, TimeLine BoundaryTimeLine)//, Dictionary<TimeLine, List<SubCalendarEvent>> DictionaryOfTimelineAndSubcalendarEvents)//, List<SubCalendarEvent> usedSubCalendarEvensts)
{
List<List<SubCalendarEvent>> RetValue = new System.Collections.Generic.List<System.Collections.Generic.List<SubCalendarEvent>>();
if (SortedAvailableSubCalEvents_Deadline.Count < 1)
{
return RetValue;
// throw new Exception("Check your Stack Calls to Pseudo_generateTreeCallsToSnugArray. Theres an error you are passing empty SortedAvailableSubCalEvents_Deadline");
}
ClumpSubCalendarEvent ClumpedSubEvents = new ClumpSubCalendarEvent(SortedAvailableSubCalEvents_Deadline.ToList(), BoundaryTimeLine);
List<List<SubCalendarEvent>> ClumpendListOfSubCalEvetns = ClumpedSubEvents.GenerateList(0);
ClumpSubCalendarEvent.Completed = 0;
foreach (List<SubCalendarEvent> AlreadyAssignedSubCalEvents in ClumpendListOfSubCalEvetns)
{
Utility.PinSubEventsToEnd(AlreadyAssignedSubCalEvents.ToList(), BoundaryTimeLine);
//Utility.PinSubEventsToStart(AlreadyAssignedSubCalEvents.ToList(), BoundaryTimeLine);
/*TimeLine UpdatedBoundary = new TimeLine(AlreadyAssignedSubCalEvents[AlreadyAssignedSubCalEvents.Count - 1].End, BoundaryTimeLine.End);
List<SubCalendarEvent> SubCalEventsLeft=Utility.NotInList_NoEffect(SortedAvailableSubCalEvents_Deadline, AlreadyAssignedSubCalEvents);
List<List<SubCalendarEvent>> FurtherClumpedList = new System.Collections.Generic.List<System.Collections.Generic.List<SubCalendarEvent>>();
if (SubCalEventsLeft.Count > 0)
{
FurtherClumpedList = Pseudo_generateTreeCallsToSnugArray(SubCalEventsLeft, UpdatedBoundary);
}
if (FurtherClumpedList.Count > 0)
{
foreach (List<SubCalendarEvent> UpdatedClumpList in FurtherClumpedList)
{
UpdatedClumpList.AddRange(AlreadyAssignedSubCalEvents);
}
}
else
{
FurtherClumpedList = new System.Collections.Generic.List<System.Collections.Generic.List<SubCalendarEvent>>();
FurtherClumpedList.Add(new System.Collections.Generic.List<SubCalendarEvent>());
FurtherClumpedList[0].AddRange(AlreadyAssignedSubCalEvents);
}
RetValue.AddRange(FurtherClumpedList);*/
RetValue.Add(AlreadyAssignedSubCalEvents);
}
return RetValue;
}
