public override void Handle(Goal element, ParsedExceptAttribute attribute, KAOSModel model)
{
var exception = new GoalException(model);
exception.AnchorGoalIdentifier = element.Identifier;
exception.ResolvingGoalIdentifier = attribute.CountermeasureIdentifier;
exception.ResolvedObstacleIdentifier = attribute.ObstacleIdentifier;
if (!model.goalRepository.GoalExists(attribute.CountermeasureIdentifier))
{
model.Add(new Goal(model)
{
Identifier = attribute.CountermeasureIdentifier,
Implicit = true
});
}
if (!model.obstacleRepository.ObstacleExists(attribute.ObstacleIdentifier))
{
model.Add(new Obstacle(model)
{
Identifier = attribute.ObstacleIdentifier,
Implicit = true
});
}
model.Add(exception);
}
Goal GenerateGoal()
{
Goal goal = new Goal(_model, "goal-" + Guid.NewGuid().ToString());
_model.Add(goal);
return(goal);
}
public override void Handle(Entity element, ParsedAttributeAttribute attribute, KAOSModel model)
{
var a = new EntityAttribute(model);
a.Identifier = attribute.Identifier;
GivenType givenType;
if (attribute.Type == null)
{
// No given type was specified
givenType = null;
}
else if (attribute.Type is IdentifierExpression)
{
var identifier = ((IdentifierExpression)attribute.Type).Value;
if ((givenType = model.entityRepository.GetGivenType(identifier)) == null)
{
givenType = new GivenType(model, identifier)
{
Implicit = true
};
model.entityRepository.Add(givenType);
}
}
else
{
throw new UnsupportedValue(element, attribute, attribute.Type);
}
a.TypeIdentifier = givenType?.Identifier;
a.EntityIdentifier = element.Identifier;
model.Add(a);
}
void KeepObstructedGoal(Resolution resolution)
{
// Get the anchor goal
var anchor = resolution.AnchorIdentifier;
var anchor_goal = _model.Goal(anchor);
// Get the refinements in which the anchor goal is involved
var refinements = _model.GoalRefinements(x => x.SubGoalIdentifiers.Any(y => y.Identifier == anchor));
// Create a new goal
var new_anchor = new Goal(_model);
new_anchor.Name = anchor_goal.Name;
new_anchor.FormalSpec = anchor_goal.FormalSpec;
_model.Add(new_anchor);
// Replace anchor goal by new goal in refinements
foreach (var r in refinements)
{
r.SubGoalIdentifiers = new HashSet <GoalRefinee> (r.SubGoalIdentifiers.Where(x => x.Identifier != anchor));
r.Add(new_anchor);
}
// Create a new refinement with anchor goal and cm goal
var new_refinement = new GoalRefinement(_model);
new_refinement.ParentGoalIdentifier = new_anchor.Identifier;
new_refinement.Add(anchor);
new_refinement.Add(resolution.ResolvingGoalIdentifier);
_model.Add(new_refinement);
Obstacle obstacle = resolution.Obstacle();
propagator.DownPropagateAddConjunct
(resolution,
new Not(obstacle.FormalSpec),
obstacle.Name != null ? "Not " + obstacle.Name : null);
// Set the probability of the resolved obstacle to 0
// TODO Use a flag "resolved"
obstacle.Resolved = true;
//_model.satisfactionRateRepository.AddObstacleSatisfactionRate (obstacle.Identifier, new DoubleSatisfactionRate (0));
// Remove the resolution, its appearans in refinements and obstructions
//Delete (resolution);
}
public override void Handle(Goal element, ParsedProvidedNotAttribute attribute, KAOSModel model)
{
var providedNot = new GoalProvidedNot(model,
element.Identifier,
attribute.ObstacleIdentifier,
fb.BuildFormula(attribute.Formula));
if (!model.obstacleRepository.ObstacleExists(attribute.ObstacleIdentifier))
{
model.Add(new Obstacle(model)
{
Identifier = attribute.ObstacleIdentifier,
Implicit = true
});
}
model.Add(providedNot);
}
public override void Handle(Goal element, ParsedRelaxedToAttribute attribute, KAOSModel model)
{
var relaxedTo = new GoalRelaxedTo(model,
element.Identifier,
attribute.ObstacleIdentifier,
fb.BuildFormula(attribute.Formula));
if (!model.obstacleRepository.ObstacleExists(attribute.ObstacleIdentifier))
{
model.Add(new Obstacle(model)
{
Identifier = attribute.ObstacleIdentifier,
Implicit = true
});
}
model.Add(relaxedTo);
}
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);
}
}
public override void Handle(Goal element, ParsedReplacesAttribute attribute, KAOSModel model)
{
var goalReplacement = new GoalReplacement(model);
goalReplacement.AnchorGoalIdentifier = element.Identifier;
goalReplacement.ResolvingGoalIdentifier = attribute.ReplacedGoalIdentifier;
goalReplacement.ResolvedObstacleIdentifier = attribute.ObstacleIdentifier;
model.Add(goalReplacement);
}
void KeepObstructedGoal(Resolution resolution)
{
// Create the exception
var exception = new GoalException(_model);
exception.AnchorGoalIdentifier = resolution.AnchorIdentifier;
exception.ResolvedObstacleIdentifier = resolution.ObstacleIdentifier;
exception.ResolvingGoalIdentifier = resolution.ResolvingGoalIdentifier;
_model.Add(exception);
var anchor = _model.Goal(resolution.AnchorIdentifier);
Propagate(anchor, resolution.Obstacle());
Obstacle obstacle = resolution.Obstacle();
obstacle.Resolved = true;
}
public override void Handle(Agent element, ParsedMonitorsAttribute attribute, KAOSModel model)
{
foreach (var id in attribute.ParsedPredicates)
{
Predicate p;
if ((p = model.formalSpecRepository.GetPredicate(id)) == null)
{
p = new Predicate(model, id)
{
Implicit = true
};
model.Add(p);
}
var monitoringLink = new AgentMonitoringLink(model)
{
AgentIdentifier = element.Identifier,
PredicateIdentifier = p.Identifier
};
model.Add(monitoringLink);
}
}
GivenType GetOrCreateGivenType(string id)
{
var type = model.GivenType(t => t.Identifier == id);
if (type == null)
{
type = new GivenType(model)
{
Identifier = id, Implicit = true
};
model.Add(type);
}
return(type);
}
public override void Handle(Goal element, ParsedAssignedToAttribute attribute, KAOSModel model)
{
var assignment = new GoalAgentAssignment(model);
assignment.GoalIdentifier = element.Identifier;
foreach (var child in attribute.Values)
{
if (child is IdentifierExpression)
{
var identifier = ((IdentifierExpression)child).Value;
Agent agent;
if ((agent = model.agentRepository.GetAgent(identifier)) == null)
{
agent = new Agent(model, identifier)
{
Implicit = true
};
model.agentRepository.Add(agent);
}
assignment.Add(agent);
}
else
{
throw new NotImplementedException(string.Format("'{0}' is not supported in '{1}' on '{2}'. ({3},{4})",
child.GetType().Name,
attribute.GetType().Name,
element.GetType().Name, attribute.Line, attribute.Col));
}
}
if (!assignment.IsEmpty)
{
model.Add(assignment);
}
}
public override void Handle(Goal element, ParsedObstructedByAttribute attribute, KAOSModel model)
{
var obstruction = new Obstruction(model);
obstruction.SetObstructedGoal(element);
if (attribute.Value is IdentifierExpression)
{
var id = ((IdentifierExpression)attribute.Value).Value;
Obstacle obstacle;
if ((obstacle = model.obstacleRepository.GetObstacle(id)) == null) {
obstacle = new Obstacle(model, id) { Implicit = true };
model.obstacleRepository.Add(obstacle);
}
obstruction.SetObstacle(obstacle);
}
else
{
throw new UnsupportedValue(element, attribute, attribute.Value);
}
model.Add(obstruction);
}
public override void Handle(Obstacle element, ParsedResolvedByAttribute attribute, KAOSModel model)
{
Goal goal;
if (attribute.Value is IdentifierExpression)
{
var id = ((IdentifierExpression)attribute.Value).Value;
if ((goal = model.goalRepository.GetGoal(id)) == null)
{
goal = new Goal(model, id)
{
Implicit = true
};
model.goalRepository.Add(goal);
}
}
else
{
throw new UnsupportedValue(element, attribute, attribute.Value);
}
var resolution = new Resolution(model);
resolution.SetObstacle(element);
resolution.SetResolvingGoal(goal);
if (attribute.Pattern != null)
{
if (attribute.Pattern.Name == "substitution")
{
resolution.ResolutionPattern = ResolutionPattern.GoalSubstitution;
}
else if (attribute.Pattern.Name == "prevention")
{
resolution.ResolutionPattern = ResolutionPattern.ObstaclePrevention;
}
else if (attribute.Pattern.Name == "obstacle_reduction")
{
resolution.ResolutionPattern = ResolutionPattern.ObstacleReduction;
}
else if (attribute.Pattern.Name == "restoration")
{
resolution.ResolutionPattern = ResolutionPattern.GoalRestoration;
}
else if (attribute.Pattern.Name == "weakening")
{
resolution.ResolutionPattern = ResolutionPattern.GoalWeakening;
}
else if (attribute.Pattern.Name == "mitigation")
{
resolution.ResolutionPattern = ResolutionPattern.ObstacleMitigation;
}
else if (attribute.Pattern.Name == "weak_mitigation")
{
resolution.ResolutionPattern = ResolutionPattern.ObstacleWeakMitigation;
}
else if (attribute.Pattern.Name == "strong_mitigation")
{
resolution.ResolutionPattern = ResolutionPattern.ObstacleStrongMitigation;
}
else
{
throw new NotImplementedException();
}
}
if (attribute.AnchorId != null)
{
Goal anchor;
if ((anchor = model.goalRepository.GetGoal(attribute.AnchorId)) == null)
{
anchor = new Goal(model, attribute.AnchorId)
{
Implicit = true
};
model.goalRepository.Add(anchor);
}
resolution.AnchorIdentifier = attribute.AnchorId;
}
model.Add(resolution);
}
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);
}
}