public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
ISolver solver = null;
if (request.Solver == "BFS")
{
solver = new BFS();
}
if (request.Solver == "DFS")
{
solver = new DFS();
}
if (request.Solver == "Dijkstra")
{
if (request.Problem == "Time")
{
solver = new DijkstraTime();
}
if (request.Problem == "Cost")
{
solver = new DijkstraCost();
}
}
if (solver != null)
{
problem.Accept(solver);
return(problem.Results);
}
Console.WriteLine("Pick Solver failed");
return(null);
}
public override IEnumerable <Route> Solve(Request request, IRouteProblem problem, IGraphDatabase database)
{
if (problem == null)
{
return(null);
}
if (request.Solver == "Dijkstra")
{
if (request.Problem == "Cost")
{
return(problem.Solve(new DijkstraCost()));
}
else
{
return(problem.Solve(new DijkstraTime()));
}
}
else
{
if (NextInChain == null)
{
return(null);
}
else
{
return(NextInChain.Solve(request, problem, database));
}
}
}
public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
problem.Graph.Filtering(request.Filter.MinPopulation, request.Filter.RestaurantRequired,
request.Filter.AllowedVehicles, problem.Graph.GetByName(request.From),
problem.Graph.GetByName(request.To));
return(this.next.Handle(request, problem));
}
static IEnumerable <Route> ServeRequest(Request request)
{
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
/*
*
* Add request handling here and return calculated route
*
*/
//Verifying data
if (request.From == string.Empty || request.To == string.Empty || request.Filter.MinPopulation < 0 || request.Filter.AllowedVehicles.Count < 1)
{
return(null);
}
//Verifying type of problem
IRouteProblem problem = DetermineProblem(request);
//Verifying AllowedVehicles
IGraphDatabase database;
if (request.Filter.AllowedVehicles.Contains(VehicleType.Car) && request.Filter.AllowedVehicles.Contains(VehicleType.Train))
{
database = new CombinedTwoIGraphDatabaseDecorator(cars, trains);
}
else if (request.Filter.AllowedVehicles.Contains(VehicleType.Car))
{
database = cars;
}
else
{
database = trains;
}
//Filtering
if (request.Filter.RestaurantRequired)
{
database = new RestaurantRequiredIGraphDatabaseDecorator(database);
}
database = new MinPopulationIGraphDatabaseDecorator(database, request.Filter.MinPopulation);
//Add database
problem.Graph = database;
ISolver[] solvers = { new BFSSolver(), new DFSSolver(), new DijkstraSolver() };
problem.Algorithm = request.Solver;
foreach (var s in solvers)
{
IEnumerable <Route> ret = problem.Accept(s);
if (problem.Solved)
{
return(ret);
}
}
return(null);
}
public override IEnumerable <Route> Handle(Request req, IRouteProblem problem)
{
if (problem == null)
{
return(null);
}
return(Next?.Handle(req, problem));
}
public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
if (Test(request))
{
return(next.Handle(request, problem));
}
Console.WriteLine("Verify failed");
return(null);
}
protected override IRouteProblem HandleProblem(Request req, IRouteProblem problem)
{
if (req.Filter == null)
{
return(problem);
}
problem.Graph = new FilteredDatabase(problem.Graph, filter.GetFilterCondition(req.Filter));
return(problem);
}
public override IEnumerable <Route> Handle(Request req, IRouteProblem problem)
{
if (req.Solver == solver)
{
IEnumerable <Route> result = problem.TrySolveWith(graphSolver);
if (result != null)
{
return(result);
}
}
return(Next?.Handle(req, problem));
}
public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
if (request.Problem == "Cost")
{
return(this.next.Handle(request, new CostProblem(request.From, request.To)));
}
if (request.Problem == "Time")
{
return(this.next.Handle(request, new TimeProblem(request.From, request.To)));
}
Console.WriteLine("PickProblem failed");
return(null);
}
static IEnumerable <Route> ServeRequest(Request request)
{
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
RequestHandler requestHandler = RequestHandler.GetRequestHandler(cars, trains);
if (!requestHandler.Validate(request))
{
return(null);
}
IRouteProblem problem = requestHandler.Apply(request);
return(requestHandler.Solve(problem));
}
static IRouteProblem DetermineProblem(Request request)
{
IRouteProblem[] problems = { new CostProblem(), new TimeProblem() };
foreach (var p in problems)
{
IRouteProblem problem = p.Visit(request);
if (problem != null)
{
return(problem);
}
}
throw new Exception("Nieznany typ problemu");
}
protected override IRouteProblem HandleProblem(Request req, IRouteProblem problem)
{
if (req.Filter.AllowedVehicles.Contains(type))
{
if (problem.Graph == null)
{
problem.Graph = database;
}
else
{
problem.Graph = new MergedDatabase(problem.Graph, database);
}
}
return(problem);
}
public IRouteProblem Apply(Request request)
{
IRouteProblem problem = null;
if (Next != null)
{
problem = Next.Apply(request);
}
if (problem == null && request.Problem == "Time")
{
problem = new TimeProblem(request.From, request.To, request.Solver);
}
return(problem);
}
public IRouteProblem Apply(Request request)
{
IRouteProblem problem = null;
if (Next != null)
{
problem = Next.Apply(request);
}
if (problem != null)
{
problem.Graph = new AllowedVehiclesFilteredDatabase(problem.Graph, request.Filter.AllowedVehicles);
}
return(problem);
}
public IRouteProblem Apply(Request request)
{
IRouteProblem problem = null;
if (Next != null)
{
problem = Next.Apply(request);
}
if (problem != null)
{
problem.Graph = new RestaurantRequiredFilteredDatabase(problem.Graph, request.Filter.RestaurantRequired);
}
return(problem);
}
public IRouteProblem Apply(Request request)
{
IRouteProblem problem = null;
if (Next != null)
{
problem = Next.Apply(request);
}
if (problem != null)
{
problem.Graph = new MinPopulationFilteredDatabase(problem.Graph, request.Filter.MinPopulation);
}
return(problem);
}
public override IEnumerable <Route> Solve(Request request, IRouteProblem problem, IGraphDatabase database)
{
if (NextInChain == null)
{
return(null);
}
if (request.Problem == "Time")
{
IRouteProblem newproblem = new TimeProblem(request.From, request.To);
newproblem.Graph = database;
return(NextInChain.Solve(request, newproblem, database));
}
else
{
return(NextInChain.Solve(request, problem, database));
}
}
public override IEnumerable <Route> Handle(Request req, IRouteProblem problem)
{
if (req == null)
{
return(null);
}
string[] values = new string[] { req.From, req.To, req.Solver, req.Problem };
foreach (string s in values)
{
if (s == null || s == "")
{
return(null);
}
}
return(Next?.Handle(req, HandleProblem(req, problem)));
}
public override IEnumerable <Route> Solve(Request request, IRouteProblem problem, IGraphDatabase database)
{
if (request.From == null || request.From == "" ||
request.To == null || request.To == "" ||
request.Filter.MinPopulation < 0 ||
request.Filter.AllowedVehicles.Count == 0)
{
return(null);
}
if (NextInChain != null)
{
return(NextInChain.Solve(request, problem, database));
}
else
{
return(null);
}
}
public override IEnumerable <Route> Solve(Request request, IRouteProblem problem, IGraphDatabase database)
{
if (problem == null)
{
return(null);
}
if (request.Solver == "BFS")
{
return(problem.Solve(new BFS()));
}
else
{
if (NextInChain == null)
{
return(null);
}
else
{
return(NextInChain.Solve(request, problem, database));
}
}
}
public IEnumerable <Route> Handle(Request request, IRouteProblem problem)
{
if (request.Filter.AllowedVehicles.Contains(VehicleType.Car) &&
request.Filter.AllowedVehicles.Contains(VehicleType.Train))
{
matDb.Merging(adjDb);
adjDb.Merging(matDb);
problem.Graph = adjDb;
return(this.next.Handle(request, problem));
}
if (request.Filter.AllowedVehicles.Contains(VehicleType.Car))
{
problem.Graph = adjDb;
return(this.next.Handle(request, problem));
}
if (request.Filter.AllowedVehicles.Contains(VehicleType.Train))
{
problem.Graph = matDb;
return(this.next.Handle(request, problem));
}
Console.WriteLine("Merging failed");
return(null);
}
static IEnumerable <Route> ServeRequest(Request request)
{
if (!CheckRequest(request))
{
return(null);
}
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
List <IGraphDatabase> databases = new List <IGraphDatabase>();
databases.Add(cars);
databases.Add(trains);
IGraphDatabase database = new VehicleDatabase(databases, request.Filter.AllowedVehicles);
database = new PopulationDatabase(database, request.Filter.MinPopulation);
database = new HasRestaurantDatabase(database, request.Filter.RestaurantRequired);
List <ISolver> solvers = new List <ISolver>();
solvers.Add(new BFS());
solvers.Add(new DFS());
solvers.Add(new DijkstraCost());
solvers.Add(new DijkstraTime());
IRouteProblem problem = ProblemFactory.MakeProblem(request.Problem, request.From, request.To);
problem.Graph = database;
foreach (ISolver solver in solvers)
{
if (solver.Name == request.Solver && problem.TrySolveBySolver(solver, out IEnumerable <Route> routes))
{
return(routes);
}
}
Console.WriteLine("Cannot find algorithm to solve this problem");
return(null);
}
public abstract IEnumerable <Route> Solve(Request request, IRouteProblem problem, IGraphDatabase database);
static IEnumerable <Route> ServeRequest(Request request)
{
// Chain of responsibility walicdacji requestu
IChain validatingChain = new FromValidate();
validatingChain.AddNext(new ToValidate())
.AddNext(new FilterPopulationvalidate())
.AddNext(new Vehiclesvalidate());
if (!validatingChain.Handle(request))
{
return(null);
}
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
// unia bazy danych taki mini dekorator
IGraphDatabase database = new GraphDatabaseUnion(cars, trains);
// Chain of responsibility tworzenia dekoratora bazy danych
IFilterDBChain filterDBChain = new RestaurantDBChainDecorator();
filterDBChain.AddNext(new AllowedVehiclesDBChainDecorator())
.AddNext(new MinPopulationDBChainDecorator());
IGraphDatabase filteredDatabase = filterDBChain.Handle(request.Filter, database);
// lista solverów tutaj dodajemy nowy solver -- jedyna zmiana!!
List <IExtendedSolver> listOfSolvers = new List <IExtendedSolver>();
listOfSolvers.Add(new DijkstraCostSolverExtended());
listOfSolvers.Add(new DijkstraTimeSolverExtended());
listOfSolvers.Add(new DFSSolverExtended());
listOfSolvers.Add(new BFSSolverExtended());
// tworzenie chain do tworznie problemów
IChainCreatingProblem creatingProblem = new CostCreateProblem();
creatingProblem.AddNext(new TimeCreateProblem());
// uzupełnianie i tworznie problemu
IRouteProblem prob = creatingProblem.Handle(request);
if (prob == null)
{
return(null);
}
prob.Graph = filteredDatabase;
// odwiedzanie solverów
foreach (var i in listOfSolvers)
{
if (i.IsNameEquals(request.Solver))
{
var res = prob.AcceptVisitor(i);
if (res != null)
{
return(res);
}
}
}
return(null);
}
public IEnumerable <Route> TimeProblem(IRouteProblem problem)
{
return(dfs.Solve(problem.Graph, problem.Graph.GetByName(problem.From), problem.Graph.GetByName(problem.To)));
}
public virtual IEnumerable <Route> Handle(Request req, IRouteProblem problem)
{
return(Next?.Handle(req, HandleProblem(req, problem)));
}
protected virtual IRouteProblem HandleProblem(Request req, IRouteProblem problem)
{
return(problem);
}
public IEnumerable <Route> CostProblem(IRouteProblem problem)
{
dijkstra = new DijkstraCost();
return(dijkstra.Solve(problem.Graph, problem.Graph.GetByName(problem.From), problem.Graph.GetByName(problem.To)));
}
public IEnumerable <Route> Solve(IRouteProblem problem)
{
return(problem.Solve(Solver));
}
protected override IRouteProblem HandleProblem(Request req, IRouteProblem problem = null)
{
return(problem ?? resolver.Resolve(req));
}
