public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Spring-Module.xml");
ThreadDAO threadDAO = (ThreadDAO) context.getBean("threadDAO");
List<Thread> threadList = threadDAO.getThreads();
for (Thread thread : threadList) {
System.out.println("Question from " + thread.getQuestions().getUsername() + ":");
System.out.println("");
System.out.println(thread.getQuestions().getText());
System.out.println("");
System.out.println(thread.getAnswers().size() + " Answers");
System.out.println("");
for (Answer answer : thread.getAnswers()) {
System.out.println(answer.getUsername() + ": " + answer.getText());
}
System.out.println("");
System.out.println("-----");
System.out.println("");
}
}
@Override
public Void doInBackground() throws Exception {
setProgress(0);
try {
Thread.sleep(1000);
} catch (InterruptedException ignore) {
}
setProgress(10);
ftpClient.download();
setProgress(30);
apiClient.downloadFile("admin/api/students", "studenti.csv");
setProgress(40);
apiClient.downloadFile("admin/api/static/1", "menu.csv");
setProgress(48);
apiClient.downloadFile("admin/api/statickat", "kategoriemenu.csv");
setProgress(54);
apiClient.downloadFile("admin/api/publikace/1", "publikace.csv");
setProgress(61);
apiClient.downloadFile("admin/api/publikacekat", "publikacekategorie.csv");
setProgress(70);
apiClient.downloadFile("admin/api/skoly", "skoly.csv");
setProgress(75);
apiClient.downloadFile("admin/api/fakulty", "fakulty.csv");
setProgress(79);
apiClient.downloadFile("admin/api/skupiny", "skupinysemestrpredmet.csv");
setProgress(85);
apiClient.downloadFile("admin/api/predmety", "predmet.csv");
setProgress(90);
apiClient.downloadFile("admin/api/ukoly/1", "ukoly.csv");
setProgress(95);
apiClient.downloadFile("admin/api/userukoly/1", "userukoly.csv");
setProgress(100);
Evidence evidence = new Evidence(localPath);
TableModel modelStudenti = new ModelStudenti(evidence);
TableModel modelStatickeStranky = new ModelStatickeStranky(evidence);
TableModel modelOdevzdaneUkoly = new ModelOdevzdaneUkoly(evidence);
TableModel modelPublikace = new ModelPublikace(evidence);
TableModel modelUkoly = new ModelUkoly(evidence);
PraceSDaty archiv = evidence.getArchiv();
Gui gui =
new Gui(
modelStudenti,
modelStatickeStranky,
modelOdevzdaneUkoly,
modelPublikace,
modelUkoly,
archiv,
evidence,
ftpClient,
nacitani);
return null;
}
// TODO : if start or end is already in the highway, will occur the problem, need to fix
public static double routingHierarchy(
long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) {
// System.out.println("start finding the path...");
int debug = 0;
try {
if (!OSMData.nodeHashMap.containsKey(startNode)
|| !OSMData.nodeHashMap.containsKey(endNode)) {
System.err.println("cannot find start or end node!");
return -1;
}
if (startNode == endNode) {
System.out.println("start node is the same as end node.");
return 0;
}
NodeInfo start = OSMData.nodeHashMap.get(startNode);
NodeInfo end = OSMData.nodeHashMap.get(endNode);
double minDistance = Geometry.calculateDistance(start.getLocation(), end.getLocation());
if (minDistance < 5) { // use normal A* algorithm to calculate small distance
return routingAStar(
start.getNodeId(),
end.getNodeId(),
OSMRouteParam.START_TIME,
OSMRouteParam.DAY_INDEX,
pathNodeList);
}
SearchingSharing sharingData = new SearchingSharing();
HashMap<Long, NodeInfoHelper> nodeForwardCache = new HashMap<Long, NodeInfoHelper>();
HashMap<Long, NodeInfoHelper> nodeReverseCache = new HashMap<Long, NodeInfoHelper>();
ForwardSearching forwardSearching =
new ForwardSearching(
startNode, endNode, startTime, dayIndex, sharingData, nodeForwardCache);
ReverseSearching reverseSearching =
new ReverseSearching(endNode, startNode, sharingData, nodeReverseCache);
// two thread run simultaneously
Thread forwardThread = new Thread(forwardSearching);
Thread reverseThread = new Thread(reverseSearching);
// search forward
forwardThread.start();
// let forward searching for a while
// Thread.sleep(100);
// search reverse
reverseThread.start();
// waiting for thread finish
forwardThread.join();
reverseThread.join();
// get the searching intersects
ArrayList<Long> intersectList = sharingData.getIntersectList();
// pick the least cost one according to time-dependent
double minCost = Double.MAX_VALUE;
ArrayList<Long> minCostPath = new ArrayList<Long>();
for (long intersect : intersectList) {
NodeInfoHelper current = nodeForwardCache.get(intersect);
// cost from source to intersect
double cost = current.getCost();
current = nodeReverseCache.get(intersect);
// update the reverse cost as forward cost
current.setCost(cost);
ArrayList<Long> reversePath = new ArrayList<Long>();
double totalCost = Double.MAX_VALUE;
// recalculate from intersect to destination
while (true) {
long nodeId = current.getNodeId();
int timeIndex =
startTime
+ (int)
(current.getCost()
/ OSMParam.SECOND_PER_MINUTE
/ OSMRouteParam.TIME_INTERVAL);
if (timeIndex
> OSMRouteParam.TIME_RANGE
- 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
timeIndex = OSMRouteParam.TIME_RANGE - 1;
long nextNodeId = current.getParentId();
double arriveTime = current.getCost();
// arrive end
if (nextNodeId == 0) {
totalCost = arriveTime;
break;
}
// add node
reversePath.add(nextNodeId);
// calculate cost according adjlist
LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId);
double costTime = 0;
for (ToNodeInfo toNode : adjNodeList) {
if (toNode.getNodeId() == nextNodeId) {
int travelTime;
// forward searching is time dependent
if (toNode.isFix()) // fix time
travelTime = toNode.getTravelTime();
else // fetch from time array
travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
break;
}
}
current = nodeReverseCache.get(nextNodeId);
if (costTime == 0) System.err.println("cost time cannot be zero!");
else current.setCost(costTime);
}
// process the left nodes to real destination
long lastNode = reversePath.get(reversePath.size() - 1);
if (lastNode != endNode) {
NodeInfo last = OSMData.nodeHashMap.get(lastNode);
NodeInfo dest = OSMData.nodeHashMap.get(endNode);
EdgeInfo onEdge = last.getEdgeFromNodes(dest);
current = nodeReverseCache.get(lastNode);
int totalDistance = onEdge.getDistance();
int distance;
long toNodeId;
if (onEdge.getStartNode() == lastNode) { // from start to middle
distance = onEdge.getStartDistance(endNode);
toNodeId = onEdge.getEndNode();
} else { // from end to middle
distance = onEdge.getEndDistance(endNode);
toNodeId = onEdge.getStartNode();
}
LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(lastNode);
double costTime = 0;
int timeIndex =
startTime
+ (int) (totalCost / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL);
if (timeIndex
> OSMRouteParam.TIME_RANGE
- 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
timeIndex = OSMRouteParam.TIME_RANGE - 1;
for (ToNodeInfo toNode : adjNodeList) {
if (toNode.getNodeId() == toNodeId) {
int travelTime;
// forward searching is time dependent
if (toNode.isFix()) // fix time
travelTime = toNode.getTravelTime();
else // fetch from time array
travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
costTime = (double) travelTime / OSMParam.MILLI_PER_SECOND;
break;
}
}
if (costTime != 0) {
costTime *= (double) distance / totalDistance;
}
totalCost += costTime; // add cost
reversePath.add(endNode); // add dest
}
// if found less cost path, build forward path
if (totalCost < minCost) {
ArrayList<Long> forwardPath = new ArrayList<Long>();
minCost = totalCost;
current = nodeForwardCache.get(intersect);
long traceNodeId = current.getParentId();
while (traceNodeId != 0) {
forwardPath.add(traceNodeId); // add node
current = nodeForwardCache.get(traceNodeId);
traceNodeId = current.getParentId();
}
Collections.reverse(forwardPath); // reverse the path list
// record min-cost path, combine forward path and reverse path
minCostPath = new ArrayList<Long>();
minCostPath.addAll(forwardPath);
minCostPath.add(intersect);
minCostPath.addAll(reversePath);
// output kml
// OSMOutput.generatePathKML(nodeHashMap, pathNodeList, "path_" + intersect);
// ArrayList<Long> intersectNode = new ArrayList<Long>();
// intersectNode.add(intersect);
// OSMOutput.generatePathNodeKML(nodeHashMap, intersectNode, "intersect_" + intersect);
}
}
pathNodeList.addAll(minCostPath);
return minCost;
} catch (Exception e) {
e.printStackTrace();
System.err.println("routingHierarchy: debug code " + debug);
}
return 0;
}