public IEnumerable <Route> Solve(IGraphDatabase graph, City from, City to)
{
Dictionary <City, (double dist, Route last)> distances = new Dictionary <City, (double dist, Route last)>();
HashSet <City> visitedCitites = new HashSet <City>();
distances[from] = (0, null);
City minCity = from;
while (minCity != to)
{
var it = graph.GetRoutesFrom(minCity);
while (it.Get() != null)
{
Route route = it.Get(); /* Change to current Route*/
it.Next(); // my line
if (visitedCitites.Contains(route.To))
{
continue;
}
double dist = distances[minCity].dist + OptimizingValueFunc(route);
if (!distances.ContainsKey(route.To))
{
distances[route.To] = (dist, route);
}
else
{
if (dist < distances[route.To].dist)
{
distances[route.To] = (dist, route);
}
}
}
visitedCitites.Add(minCity);
minCity = null;
foreach (var(city, (dist, route)) in distances)
{
if (visitedCitites.Contains(city))
{
continue;
}
if (minCity == null || dist < distances[city].dist)
{
minCity = city;
}
}
if (minCity == null)
{
return(null);
}
}
List <Route> result = new List <Route>();
for (Route route = distances[to].last; route != null; route = distances[route.From].last)
{
result.Add(route);
}
result.Reverse();
return(result);
}
public override IGraphDatabase UpdatedFilter(Filter filter, IGraphDatabase previous)
{
if (filter.MinPopulation >= 0)
{
return(new MinPopulationFilterDatabaseDecorator(previous, filter.MinPopulation));
}
return(previous);
}
public override IGraphDatabase UpdatedFilter(Filter filter, IGraphDatabase previous)
{
if (filter.AllowedVehicles != null)
{
return(new AllowedVehiclesFilterDatabaseDecorator(previous, filter.AllowedVehicles));
}
return(previous);
}
public override IGraphDatabase UpdatedFilter(Filter filter, IGraphDatabase previous)
{
if (filter.RestaurantRequired)
{
return(new RestaurantFilterDatabaseDecorator(previous));
}
return(previous);
}
public override IGraphDatabase Handle(Filter filter, IGraphDatabase graph, IGraphDatabase cars, IGraphDatabase trains)
{
if (filter.AllowedVehicles.Contains(VehicleType.Train))
{
IGraphDatabase db = new MergeDatabase(graph, trains, true);
return(nextServant.Handle(filter, db, cars, trains));
}
return(nextServant.Handle(filter, graph, cars, trains));
}
public override IEnumerable <Route> Handle(Request request, IGraphDatabase graph)
{
if (request.Solver == "DFS")
{
IAlgorithm solver = new DFS();
return(solver.Solve(graph, graph.GetByName(request.From), graph.GetByName(request.To)));
}
return(nextServant.Handle(request, graph));
}
public override IGraphDatabase Handle(Filter filter, IGraphDatabase graph, IGraphDatabase cars, IGraphDatabase trains)
{
if (filter.RestaurantRequired)
{
IGraphDatabase db = new FilterRestaurant(graph, true);
return(db);
}
return(graph);
}
public override IGraphDatabase Handle(Filter filter, IGraphDatabase graph, IGraphDatabase cars, IGraphDatabase trains)
{
if (filter.MinPopulation > 0)
{
IGraphDatabase db = new FilterPopulation(graph, filter.MinPopulation);
return(nextServant.Handle(filter, db, cars, trains));
}
return(nextServant.Handle(filter, graph, cars, trains));
}
public GraphCompileActionFactory(
ITraceWriter traceWriter,
IGraphDatabase graphDatabase,
IDirectoryWalkerFactory directoryWalkerFactory)
{
_traceWriter = traceWriter;
_graphDatabase = graphDatabase;
_directoryWalkerFactory = directoryWalkerFactory;
}
public void SetupScanner()
{
_database = A.Fake <IGraphDatabase>();
var config = new ReflectionScannerConfiguration {
Assemblies = new[] { AssemblyPath }
};
_scanner = new ReflectionScanner(config, ModelFactory, _database, A.Fake <ILogger <ReflectionScanner> >());
}
public IRouteProblem GetProblem(Request request, IGraphDatabase database)
{
if (request.Problem == "Cost")
{
IRouteProblem problem = new CostProblem(request.From, request.To);
problem.SetGraph(database);
return(problem);
}
return(null);
}
public IRouteProblem GetProblem(Request request, IGraphDatabase database)
{
if (request.Problem == "Time")
{
IRouteProblem problem = new TimeProblem(request.From, request.To);
problem.SetGraph(database);
return(problem);
}
return(Next.GetProblem(request, database));
}
public GraphBuilder(
IModelFactory factory,
IGraphDatabase db,
ILogger logger)
{
_factory = factory;
//_tx = tx;
_db = db;
_logger = logger;
}
public IGraphDatabase Handle(Filter filter, IGraphDatabase previous = null)
{
var tmp = UpdatedFilter(filter, previous);
if (next == null)
{
return(tmp);
}
return(next.Handle(filter, tmp));
}
public ReflectionScanner(
ReflectionScannerConfiguration config,
IModelFactory factory,
IGraphDatabase db,
ILogger <ReflectionScanner> logger)
{
_assemblies = config.Assemblies.ToList();
_factory = factory;
_db = db;
_logger = logger;
}
public GraphExportAction(
ITraceWriter traceWriter,
IGraphDatabase graphDatabase,
string creator,
string description
)
{
_traceWriter = traceWriter;
_graphDatabase = graphDatabase;
_creator = creator;
_description = description;
}
public GraphCompileAction(
ITraceWriter traceWriter,
IGraphDatabase graphDatabase,
IDirectoryWalkerFactory directoryWalkerFactory,
string directory,
IEnumerable <string> excludes
)
{
_traceWriter = traceWriter;
_graphDatabase = graphDatabase;
_directoryWalkerFactory = directoryWalkerFactory;
_directory = directory;
_excludes = excludes;
}
public IEnumerable <Route> Solve(IGraphDatabase graph, City from, City to)
{
Dictionary <City, Route> routes = new Dictionary <City, Route>();
routes[from] = null;
Queue <City> queue = new Queue <City>();
queue.Enqueue(from);
do
{
City city = queue.Dequeue();
/*
* For each outgoing route from city...
*/
Iterator <Route> i = graph.GetRoutesFrom(city);
if (i.IsEmpty())
{
continue;
}
for (Route curr = i.Next(); curr != null; curr = i.Next())
{
Route route = curr; /* Change to current Route*/
if (routes.ContainsKey(route.To))
{
continue;
}
routes[route.To] = route;
if (route.To == to)
{
break;
}
queue.Enqueue(route.To);
}
} while (queue.Count > 0);
if (!routes.ContainsKey(to))
{
return(null);
}
List <Route> result = new List <Route>();
for (Route route = routes[to]; route != null; route = routes[route.From])
{
result.Add(route);
}
result.Reverse();
return(result);
}
public void Merging(IGraphDatabase another)
{
foreach (var item in cityDictionary)
{
City city = another.GetByName(item.Key);
if (city != null)
{
foreach (Route route in routes[cityIds[city]])
{
if (!routes[cityIds[city]].Contains(route))
{
AddRoute(route.From, route.To, route.Cost, route.TravelTime, route.VehicleType);
}
}
}
}
}
public override IEnumerable <Route> Handle(Request request, IGraphDatabase graph)
{
if (request.Solver == "Dijkstra")
{
if (request.Problem == "Cost")
{
IAlgorithm solver = new DijkstraCost();
return(solver.Solve(graph, graph.GetByName(request.From), graph.GetByName(request.To)));
}
if (request.Problem == "Time")
{
IAlgorithm solver = new DijkstraTime();
return(solver.Solve(graph, graph.GetByName(request.From), graph.GetByName(request.To)));
}
}
return(null);
}
public IEnumerable <Route> Solve(IGraphDatabase graph, City from, City to)
{
Dictionary <City, Route> routes = new Dictionary <City, Route>();
routes[from] = null;
Stack <City> stack = new Stack <City>();
stack.Push(from);
do
{
City city = stack.Pop();
/*
* For each outgoing route from city...
*/
var it = graph.GetRoutesFrom(city);
it.Start();
while (it.IsNextExist())
{
Route route = it.Next; /* Change to current Route*/
if (routes.ContainsKey(route.To))
{
continue;
}
routes[route.To] = route;
if (route.To == to)
{
break;
}
stack.Push(route.To);
}
} while (stack.Count > 0);
if (!routes.ContainsKey(to))
{
return(null);
}
List <Route> result = new List <Route>();
for (Route route = routes[to]; route != null; route = routes[route.From])
{
result.Add(route);
}
result.Reverse();
return(result);
}
public IEnumerable <Route> Solve(IGraphDatabase graph, City from, City to)
{
Dictionary <City, Route> routes = new Dictionary <City, Route>();
routes[from] = null;
Stack <City> stack = new Stack <City>();
stack.Push(from);
do
{
City city = stack.Pop();
IIterator <Route> iterator = graph.GetRoutesFrom(city);
while (!iterator.IsDone())
{
Route route = iterator.GetNext();
if (route == null)
{
continue;
}
if (routes.ContainsKey(route.To))
{
continue;
}
routes[route.To] = route;
if (route.To == to)
{
break;
}
stack.Push(route.To);
}
} while (stack.Count > 0);
if (!routes.ContainsKey(to))
{
return(null);
}
List <Route> result = new List <Route>();
for (Route route = routes[to]; route != null; route = routes[route.From])
{
result.Add(route);
}
result.Reverse();
return(result);
}
public IEnumerable <Route> Solve(IGraphDatabase graph, City from, City to)
{
Dictionary <City, Route> routes = new Dictionary <City, Route>();
routes[from] = null;
Queue <City> queue = new Queue <City>();
queue.Enqueue(from);
do
{
City city = queue.Dequeue();
// ======
var it = graph.GetRoutesFrom(city);
while (it.Get() != null)
{
Route route = it.Get(); /* Change to current Route*/
it.Next(); // moja linijka
if (routes.ContainsKey(route.To))
{
continue;
}
routes[route.To] = route;
if (route.To == to)
{
break;
}
queue.Enqueue(route.To);
}
} while (queue.Count > 0);
if (!routes.ContainsKey(to))
{
return(null);
}
List <Route> result = new List <Route>();
for (Route route = routes[to]; route != null; route = routes[route.From])
{
result.Add(route);
}
result.Reverse();
return(result);
}
static IEnumerable <Route> ServeRequest(Request request)
{
(IGraphDatabase cars, IGraphDatabase trains) = MockData.InitDatabases();
if (request.From == "" || request.To == "" || request.Filter.MinPopulation < 0 || request.Filter.AllowedVehicles.Count == 0)
{
Console.WriteLine("Invalid Data\n");
return(null);
}
IGraphDatabase db = new AdjacencyListDatabase();
IDecoratorServant mergecars = new MergeCarsServant();
IDecoratorServant mergetrains = new MergeTrainsServant();
IDecoratorServant filterpop = new FilterPopulationServant();
IDecoratorServant filterrest = new FilterRestaurantServant();
mergecars.SetNext(mergetrains);
mergetrains.SetNext(filterpop);
filterpop.SetNext(filterrest);
IGraphDatabase db4 = mergecars.Handle(request.Filter, db, cars, trains);
/*
*
* Add request handling here and return calculated route
* 5. The operation of the request
* Operation of the request should:
* — get the required data from any of the user interfaces using RequestMapper, <= in execute before serverequest
* — check if the data is correct (non-blank 'from' and 'to' fields, non-negative minimal population, at least one means of transport is chosen),
* — detect which algorithm is required,
* — deliver data to the algorithm,
* — allow the addition of city filters and road filters.
*/
IAlgorithmServant bfs = new BFSServant();
IAlgorithmServant dfs = new DFSServant();
IAlgorithmServant dijkstra = new DijkstraServant();
bfs.SetNext(dfs);
dfs.SetNext(dijkstra);
return(bfs.Handle(request, db4));
}
public MergingDatase(IGraphDatabase adjDb, IGraphDatabase matDb)
{
this.adjDb = adjDb;
this.matDb = matDb;
}
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 PopulationDatabase(IGraphDatabase database, int minPopulation)
{
this.database = database;
this.minPopulation = minPopulation;
}
public HasRestaurantDatabase(IGraphDatabase database, bool hasRestaurant)
{
this.database = database;
this.hasRestaurant = hasRestaurant;
}
public abstract IGraphDatabase Handle(Filter filter, IGraphDatabase graph, IGraphDatabase cars, IGraphDatabase trains);
public abstract IEnumerable <Route> Handle(Request request, IGraphDatabase graph);
