public void RepairWithComposite(OpenCondition oc, CompositePlanStep repairStep)
{
var needStep = Find(oc.step);
if (!needStep.Name.Equals("DummyGoal") && !needStep.Name.Equals("DummyInit"))
{
needStep.Fulfill(oc.precondition);
}
orderings.Insert(repairStep.GoalStep as IPlanStep, needStep);
//this.ID += string.Format("(^Orl[{0},{1}])", repairStep.GoalStep.ID, needStep.ID);
// Causal Link between repair step's goal condition and need step.
var clink = new CausalLink <IPlanStep>(oc.precondition, repairStep.GoalStep as IPlanStep, needStep);
causalLinks.Add(clink);
foreach (var step in Steps)
{
if (step.ID == repairStep.ID || step.ID == needStep.ID)
{
continue;
}
if (!CacheMaps.IsThreat(oc.precondition, step))
{
continue;
}
if (step.Height > 0)
{
// we need to check that this step's goal step
var stepAsComp = step as CompositePlanStep;
if (decomplinks.OnDecompPath(clink.Head, step.ID))
{
// must be ordered within
if (Orderings.IsPath(clink.Tail, stepAsComp.GoalStep))
{
// already tucked into Q's borders
continue;
}
if (!decomplinks.OnDecompPath(clink.Tail, step.ID))
{
// Special Case is when clink.Tail is goal step. Then we cannot tuck clink.Tail into borders.
if (clink.Tail.Equals(goalStep))
{
// We want to end this plan's existence, so we add a threat that cannot be resolved.
Flaws.Add(new ThreatenedLinkFlaw(clink, step));
continue;
}
// Q --> s -p-> t, not p in eff(Q), not Q --> t
// then, need to tuck t into Q's borders.
var tailRoot = GetStepByID(decomplinks.GetRoot(clink.Tail)) as CompositePlanStep;
Orderings.Insert(tailRoot.GoalStep, stepAsComp.InitialStep);
//this.ID += string.Format("(^Od[{0},{1}])", tailRoot.GoalStep.ID, stepAsComp.InitialStep.ID);
}
continue;
}
if (decomplinks.OnDecompPath(clink.Tail, step.ID))
{
// step cannot threaten
continue;
}
// step is a threat to need precondition
if (Orderings.IsPath(clink.Tail, stepAsComp.InitialStep))
{
continue;
}
if (Orderings.IsPath(stepAsComp.GoalStep, repairStep.InitialStep as IPlanStep))
{
continue;
}
Flaws.Add(new ThreatenedLinkFlaw(clink, stepAsComp));
// Flaws.Add(new ThreatenedLinkFlaw(clink, compInit));
}
else
{
// is it possible that step is a sub-step of repair step? Yes it is.
if (decomplinks.OnDecompPath(step, repairStep.ID))
{
// but, there's nothing we can do about it; and all links to repairStep.GoalStep are there to be threatened
continue;
}
// step is a threat to need precondition
if (Orderings.IsPath(needStep, step))
{
continue;
}
if (Orderings.IsPath(step, repairStep.InitialStep as IPlanStep))
{
continue;
}
Flaws.Add(new ThreatenedLinkFlaw(clink, step));
}
}
}
public void RepairWithMerge(IPredicate neededCondition, IPlanStep needStep, CompositeSchedulePlanStep repairStep)
//public void RepairWithMerge(ContextPredicate neededCondition, ContextPredicate producedCondition, IPlanStep needStep, CompositeSchedulePlanStep repairStep)
{
// needStep is initialStep;
var needStepComposite = GetStepByID(DeLinks.GetParent(needStep)) as CompositeSchedulePlanStep;
var subStepTermID = neededCondition.Terms[0].Constant;
var stepThatNeedsToBeMerged = GetStepByID(DeLinks.GetSubSteps(needStepComposite).Single(sid => GetStepByID(sid).Action.ID.ToString().Equals(subStepTermID)));
//var stepThatNeedsToBeMerged = needStepComposite.SubSteps.Where(s => s.Action.ID.ToString().Equals(subStepTermID)).First();
//var stepThatNeedsToBeMerged = neededCondition.ActionRef;
var stepThatDoesMerging = GetStepByID(DeLinks.GetSubSteps(repairStep).Single(sid => GetStepByID(sid).Action.ID.ToString().Equals(subStepTermID)));
//var stepThatDoesMerging = repairStep.SubSteps.Where(s => s.Action.ID.ToString().Equals(subStepTermID)).First();
// We assume that no timeline decomposition contains the same exact sub-step twice.
//var stepThatDoesMerging = producedCondition.ActionRef;
// In case the sub-step has been merged, find the most recent reference
//var getID = MM.FindRoot(stepThatDoesMerging.ID);
//if (getID != stepThatDoesMerging.ID)
//{
// stepThatDoesMerging = Steps.Where(s => s.ID == getID).First();
//}
//getID = MM.FindRoot(stepThatNeedsToBeMerged.ID);
//if (getID != stepThatNeedsToBeMerged.ID)
//{
// stepThatNeedsToBeMerged = Steps.Where(s => s.ID == getID).First();
//}
// rewrite the produced sub-step
RewrittenAs(stepThatNeedsToBeMerged, stepThatDoesMerging);
//MergeSteps(stepThatDoesMerging, stepThatNeedsToBeMerged);
// get the produced step's decompositional root
var repairStepRoot = GetStepByID(DeLinks.GetRoot(repairStep)) as CompositePlanStep;
// removed the consumed rewritten sub-step
DeLinks.RemoveSubStep(needStepComposite, stepThatNeedsToBeMerged);
//needStepComposite.SubSteps.Remove(stepThatNeedsToBeMerged);
// add decomp link to produced step's root
DeLinks.Insert(needStepComposite, repairStepRoot);
//repairStepRoot.Parent = needStepComposite;
//needStepComposite.SubSteps.Add(repairStepRoot);
// Add orderings to keep repair Step within decompositional borders
Orderings.Insert(needStepComposite.InitialStep, repairStepRoot.InitialStep);
//this.ID += string.Format("(^Om[{0},{1}])", needStepComposite.InitialStep.ID, repairStepRoot.InitialStep.ID);
Orderings.Insert(repairStepRoot.GoalStep, needStepComposite.GoalStep);
//this.ID += string.Format("(^Om[{0},{1}])", repairStepRoot.GoalStep.ID, needStepComposite.GoalStep.ID);
Orderings.Insert(needStepComposite.InitialStep, repairStep.InitialStep);
Orderings.Insert(repairStep.GoalStep, needStepComposite.GoalStep);
// the needstep camera schedule sub-steps may not be ordered relative to the action being merged.
foreach (var needCamSubStep in needStepComposite.CamScheduleSubSteps)
{
Orderings.Insert(repairStep.GoalStep, needCamSubStep);
//this.ID += string.Format("(^Ocams[{0},{1}])", needCamSubStep.ID, repairStep.InitialStep.ID);
//foreach (var repairCamSubStep in repairStep.CamScheduleSubSteps)
//{
// Orderings.Insert(repairCamSubStep, needCamSubStep);
// this.ID += string.Format("(^Ocams[{0},{1}])", repairCamSubStep.ID, needCamSubStep.ID);
//}
}
}