public override void Handle(Obstacle element, ParsedRefinedByAttribute attribute, KAOSModel model)
{
var refinement = new ObstacleRefinement(model);
refinement.SetParentObstacle(element);
// Parse the reference to children
foreach (var child in attribute.ParsedRefinees)
{
var id = child.Identifier;
var param = child.Parameters;
IRefineeParameter refineeParameter = null;
if (param != null)
{
if (param is ParsedPrimitiveRefineeParameter <double> )
{
var cast = ((ParsedPrimitiveRefineeParameter <double>)param);
refineeParameter = new PrimitiveRefineeParameter <double> (cast.Value);
}
else
{
throw new NotImplementedException();
}
}
Obstacle refinee;
DomainProperty domprop;
DomainHypothesis domhyp;
if ((refinee = model.obstacleRepository.GetObstacle(id)) != null)
{
refinement.Add(refinee, refineeParameter);
}
else if ((domprop = model.domainRepository.GetDomainProperty(id)) != null)
{
refinement.Add(domprop, refineeParameter);
}
else if ((domhyp = model.domainRepository.GetDomainHypothesis(id)) != null)
{
refinement.Add(domhyp, refineeParameter);
}
else
{
refinee = new Obstacle(model, id)
{
Implicit = true
};
model.obstacleRepository.Add(refinee);
refinement.Add(refinee);
}
}
if (!refinement.IsEmpty)
{
model.Add(refinement);
}
}
private static void AssertParameter(GoalRefinement refinement, string goalId, double expected)
{
IRefineeParameter p1 = refinement.SubGoalIdentifiers.Single(x => x.Identifier == goalId).Parameters;
Assert.IsInstanceOf(typeof(PrimitiveRefineeParameter <double>), p1);
var cp1 = (PrimitiveRefineeParameter <double>)p1;
Assert.AreEqual(expected, cp1.Value);
}
string ToString(IRefineeParameter param)
{
if (param != null)
{
return("[" + param.ToString() + "]");
}
else
{
return("");
}
}
DoubleSatisfactionRate ComputeRefineeSatisfactionRate(IEnumerable <GoalRefinee> refinees, Func <string, ISatisfactionRate> get)
{
return(refinees.Aggregate(
DoubleSatisfactionRate.ZERO,
(x, y) => {
IRefineeParameter parameter = y.Parameters;
if (!(parameter is PrimitiveRefineeParameter <double>))
{
throw new PropagationException(PropagationException.MISSING_PARAMETER);
}
var doubleParam = ((PrimitiveRefineeParameter <double>)parameter).Value;
ISatisfactionRate sr = get(y.Identifier).Product(doubleParam);
return (DoubleSatisfactionRate)x.Sum(sr);
}
));
}
public GoalRefinee(string identifier, IRefineeParameter parameters)
{
Identifier = identifier;
Parameters = parameters;
}
public void Add(DomainHypothesis domHyp, IRefineeParameter parameter)
{
this.DomainHypothesisIdentifiers.Add(new GoalRefinee(domHyp.Identifier, parameter));
}
public void Add(DomainProperty domProp, IRefineeParameter parameter)
{
this.DomainPropertyIdentifiers.Add(new GoalRefinee(domProp.Identifier, parameter));
}
public void Add(Goal goal, IRefineeParameter parameter)
{
this.SubGoalIdentifiers.Add(new GoalRefinee(goal.Identifier, parameter));
}
public void Add(Obstacle obstacle, IRefineeParameter parameter)
{
this.SubobstacleIdentifiers.Add(new ObstacleRefinee(obstacle.Identifier, parameter));
}
public ObstacleRefinee(string identifier, IRefineeParameter parameters)
{
Identifier = identifier;
Parameters = parameters;
}
public override void Handle(Goal element, ParsedRefinedByAttribute attribute, KAOSModel model)
{
var refinement = new GoalRefinement(model);
refinement.SetParentGoal(element);
// Parse the reference to children
foreach (var child in attribute.ParsedRefinees)
{
var id = child.Identifier;
var param = child.Parameters;
IRefineeParameter refineeParameter = null;
if (param != null)
{
if (param is ParsedPrimitiveRefineeParameter <double> )
{
var cast = ((ParsedPrimitiveRefineeParameter <double>)param);
refineeParameter = new PrimitiveRefineeParameter <double> (cast.Value);
}
else
{
throw new NotImplementedException();
}
}
Goal refinee;
DomainProperty domprop;
DomainHypothesis domhyp;
if ((refinee = model.goalRepository.GetGoal(id)) != null)
{
refinement.Add(refinee, refineeParameter);
}
else if ((domprop = model.domainRepository.GetDomainProperty(id)) != null)
{
refinement.Add(domprop, refineeParameter);
}
else if ((domhyp = model.domainRepository.GetDomainHypothesis(id)) != null)
{
refinement.Add(domhyp, refineeParameter);
}
else
{
refinee = new Goal(model, id)
{
Implicit = true
};
model.goalRepository.Add(refinee);
refinement.Add(refinee);
}
}
// Parse the context
if (!string.IsNullOrEmpty(attribute.ContextIdentifier))
{
var id = attribute.ContextIdentifier;
Context context;
if ((context = model.modelMetadataRepository.GetContext(id)) == null)
{
context = new Context(model, id);
model.modelMetadataRepository.Add(context);
}
refinement.ContextIdentifier = context.Identifier;
}
// Parse the refinement pattern provided
if (attribute.RefinementPattern != null)
{
if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.Milestone)
{
refinement.RefinementPattern = RefinementPattern.Milestone;
}
else if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.Case)
{
refinement.RefinementPattern = RefinementPattern.Case;
}
else if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.IntroduceGuard)
{
refinement.RefinementPattern = RefinementPattern.IntroduceGuard;
}
else if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.DivideAndConquer)
{
refinement.RefinementPattern = RefinementPattern.DivideAndConquer;
}
else if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.Uncontrollability)
{
refinement.RefinementPattern = RefinementPattern.Uncontrollability;
}
else if (attribute.RefinementPattern.Name == ParsedRefinementPatternName.Unmonitorability)
{
refinement.RefinementPattern = RefinementPattern.Unmonitorability;
}
else
{
throw new BuilderException("Unsupported pattern " + refinement.RefinementPattern, attribute);
}
}
if (!refinement.IsEmpty)
{
model.Add(refinement);
}
}