Predicate GetOrCreatePredicate(ParsedPredicateReferenceExpression parsedPred,
Dictionary <string, KAOSTools.Core.Entity> declarations)
{
var idOrName = parsedPred.PredicateSignature;
Predicate predicate;
if (idOrName is NameExpression)
{
predicate = model.Predicates().SingleOrDefault(t => t.Name == idOrName.Value);
}
else if (idOrName is IdentifierExpression)
{
predicate = model.Predicates().SingleOrDefault(t => t.Identifier == idOrName.Value);
}
else
{
throw new NotImplementedException(idOrName.GetType().Name + " is not yet supported");
}
if (predicate == null)
{
if (idOrName is NameExpression)
{
predicate = new Predicate(model)
{
Name = idOrName.Value, Implicit = true
}
}
;
else if (idOrName is IdentifierExpression)
{
predicate = new Predicate(model)
{
Identifier = idOrName.Value, Implicit = true
}
}
;
else
{
throw new NotImplementedException();
}
foreach (var arg in parsedPred.ActualArguments)
{
predicate.Arguments.Add(new PredicateArgument()
{
Name = arg, Type = declarations[arg]
});
}
model.Add(predicate);
}
else
{
// Check that same number of arguments are used (if none is already declared)
if (predicate.Arguments.Count > 0 && parsedPred.ActualArguments.Count != predicate.Arguments.Count)
{
throw new BuilderException("Predicate '" + idOrName.Value + "' arguments mismatch. " +
"Expect " + predicate.Arguments.Count + " arguments but " + parsedPred.ActualArguments.Count + " received.",
parsedPred.Filename, parsedPred.Line, parsedPred.Col);
}
else
{
// Check that arguments match the declared type (if none is already declared)
if (predicate.Arguments.Count > 0)
{
for (int i = 0; i < parsedPred.ActualArguments.Count; i++)
{
var parsedArg = parsedPred.ActualArguments[i];
if (!declarations[parsedArg].Ancestors().Contains(predicate.Arguments[i].Type))
{
throw new BuilderException("Predicate '" + idOrName + "' arguments mismatch. " +
"Argument '" + parsedArg + "' is type '" + declarations[parsedArg].FriendlyName + "' " +
"but type '" + predicate.Arguments[i].Type.FriendlyName + "' is expected. Make sure that you do not mix names and identifiers.",
parsedPred.Filename, parsedPred.Line, parsedPred.Col);
}
}
}
// Otherwise, create all needed arguments
else
{
for (int i = 0; i < parsedPred.ActualArguments.Count; i++)
{
var parsedArg = parsedPred.ActualArguments[i];
predicate.Arguments.Add(new PredicateArgument()
{
Name = parsedArg,
Type = declarations[parsedArg]
});
}
}
}
}
return(predicate);
}
public static void Main(string[] args)
{
//DeployAmbulanceAtStationAllocator();
//Thread.Sleep(TimeSpan.FromSeconds(10));
Console.WriteLine("Hello World!");
var monitoringDelay = TimeSpan.FromSeconds(1);
logger.Info("Connecting to database");
var provider = new PostgreSQLDatabaseProvider();
var connectionString = ConfigurationManager.ConnectionStrings["postgres"].ConnectionString;
var config = DatabaseConfiguration.Build()
.UsingConnectionString(connectionString)
.UsingProvider(provider)
.UsingDefaultMapper <ConventionMapper>();
db = new Database(config);
incidentRepository = new IncidentRepository(db);
ambulanceRepository = new AmbulanceRepository(db);
allocationRepository = new AllocationRepository(db);
hospitalRepository = new HospitalRepository(db);
configurationRepository = new ConfigurationRepository(db);
logger.Info("Connected to database");
logger.Info("Building KAOS model.");
var filename = "./Models/simple.kaos";
var parser = new KAOSTools.Parsing.ModelBuilder();
model = parser.Parse(File.ReadAllText(filename), filename);
var model2 = parser.Parse(File.ReadAllText(filename), filename);
ActiveResolutions = Enumerable.Empty <Resolution>();
var declarations = parser.Declarations;
logger.Info("(done)");
logger.Info("Configuring monitors.");
// Configure all the monitors (for all obstacles and domain properties).
KAOSMetaModelElement[] goals = model.Goals().ToArray();
KAOSMetaModelElement[] obstacles = model.LeafObstacles().ToArray();
var projection = new HashSet <string>(GetAllPredicates(goals));
monitor = new GoalMonitor(model, goals.Union(obstacles), projection, HandleFunc,
// new TimedStateInformationStorage(TimeSpan.FromMinutes(60), TimeSpan.FromMinutes(120)),
monitoringDelay);
logger.Info("(done)");
foreach (var p in model.Predicates())
{
Console.WriteLine(p.FriendlyName);
}
// What goals and obstacles should appear in LOG
cpsGoals = model.Goals(x => x.CustomData.ContainsKey("log_cps"));
cpsObstacles = model.Obstacles(x => x.CustomData.ContainsKey("log_cps"));
// Initialize obstruction sets
obstructionLock = new object();
ComputeObstructionSets();
Console.WriteLine("Waiting ...");
Console.ReadKey();
logger.Info("Launching monitors");
monitor.Run(false);
var goalMonitorProcessor = new GoalMonitorProcessor(monitor);
csvExport = new CSVGoalExportProcessor("experiment-goal.csv", "experiment-obstacle.csv");
// goalMonitorProcessor.AddProcessor(csvExport, monitoringDelay);
new Timer((state) => UpdateCPS(), null, monitoringDelay, monitoringDelay);
new Timer((state) => MonitorStep(), null, monitoringDelay, monitoringDelay);
Thread.Sleep(TimeSpan.FromSeconds(5));
logger.Info("Launching processors");
//new Timer((state) => LogStatistic(), null, monitoringDelay, monitoringDelay);
new Timer((state) => LogCSV(), null, monitoringDelay, monitoringDelay);
// Configure optimization process.
optimizer = new Optimizer(monitor, model2);
new Timer((state) => Optimize(), null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(60));
while (true)
{
;
}
}
