public new Object Clone()
{
var op = base.Clone() as IOperator;
var init = InitialStep.Clone() as IPlanStep;
var goal = GoalStep.Clone() as IPlanStep;
return(new Composite(op, init, goal, SubSteps.ToList(), SubOrderings.ToList(), SubLinks.ToList())
{
Height = this.Height,
NonEqualities = this.NonEqualities
});
}
/// <summary>
/// The compositeschedule has terms, preconditions, and effects.
/// All preconditions and effects are expected to be ground because they are created based on the ground decomposition
/// Thus, unlike the parent class, there is no need to propagate bindings to terms, preconditions, and effects.
/// </summary>
/// <param name="td"></param>
public void ApplyDecomposition(TimelineDecomposition td)
{
subSteps = td.SubSteps;
subOrderings = td.SubOrderings;
subLinks = td.SubLinks;
foreach (var substep in subSteps)
{
foreach (var term in substep.Terms)
{
if (!td.Terms.Contains(term))
{
//var termAsPredicate = term as Predicate;
//if (termAsPredicate != null)
//{
//}
Terms.Add(term);
}
}
}
Cntgs = td.fabCntgs;
// The way things are done round here is just to group in discourse stuff with fabula stuff. We have two plans... but they can go in one plan.
foreach (var camplanstep in td.discourseSubSteps)
{
SubSteps.Add(camplanstep as IPlanStep);
}
foreach (var dordering in td.discOrderings)
{
SubOrderings.Add(new Tuple <IPlanStep, IPlanStep>(dordering.First, dordering.Second));
}
foreach (var discCntg in td.discCntgs)
{
Cntgs.Add(new Tuple <IPlanStep, IPlanStep>(discCntg.First, discCntg.Second));
}
foreach (var dlink in td.discLinks)
{
SubLinks.Add(new CausalLink <IPlanStep>(dlink.Predicate, dlink.Head, dlink.Tail));
}
// these should already be ground.
InitialActionSeg = td.InitialActionSeg.Clone();
FinalActionSeg = td.FinalActionSeg.Clone();
InitialAction = td.InitialAction.Clone() as IPlanStep;
FinalAction = td.FinalAction.Clone() as IPlanStep;
InitialCamAction = td.InitialCamAction.Clone() as CamPlanStep;
FinalCamAction = td.FinalCamAction.Clone() as CamPlanStep;
}
public new Object Clone()
{
var op = base.Clone() as IOperator;
var newSubsteps = new List <IPlanStep>();
foreach (var substep in SubSteps)
{
var newsubstep = substep.Clone() as IPlanStep;
newsubstep.Action = newsubstep.Action.Clone() as Operator;
newSubsteps.Add(newsubstep);
}
// var newinitial = InitialStep.Clone() as IPlanStep;
//newinitial.Action = InitialStep.Action.Clone() as Operator;
// do same for literals
return(new Decomposition(op, Literals, InitialStep.Clone() as IPlanStep, GoalStep.Clone() as IPlanStep, newSubsteps, SubOrderings.ToList(), SubLinks.ToList()));
// return new Decomposition(op, Literals, newSubsteps, SubOrderings, SubLinks);
}
