public List<Vertice> get(Zone zone) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List<Vertice> vertices = new ArrayList<Vertice>();
try {
conn = getConnection();
st = conn.prepareStatement(SELECT_VERTICE);
st.setInt(1, zone.getId());
rs = st.executeQuery();
while (rs.next()) {
Vertice v = new Vertice();
v.setId(rs.getInt(1));
v.setVertexorder(rs.getInt(2));
v.setX(rs.getInt(3));
v.setZ(rs.getInt(4));
vertices.add(v);
}
} catch (Exception e) {
Zones.log.warning(
"[Zones]Error loading vertices of " + zone.getName() + "[" + zone.getId() + "] :");
e.printStackTrace();
} finally {
try {
if (conn != null) conn.close();
if (st != null) st.close();
if (rs != null) rs.close();
} catch (Exception e) {
}
}
return vertices;
}
public void mostraListaAdjacencia() {
System.out.println("\nLista de Adjacência");
for (Vertice vertice : this.listaVertice) {
vertice.mostraAdjacentes();
System.out.println();
}
}
public int CalcularTiempoDeInfeccion(Grafo<String> grafo, Vertice<String> in) {
int nuevaDist = 0;
int maxDist = 0;
int n = grafo.listaDeVertices().tamanio();
int[] distancias = new int[n];
ColaGenerica<Vertice<String>> q = new ColaGenerica<Vertice<String>>();
for (int c = 0; c < n; c++) {
distancias[c] = Integer.MAX_VALUE;
}
distancias[in.posicion()] = 0;
q.encolar(in);
while (!q.esVacia()) {
Vertice<String> v = q.desencolar();
nuevaDist = distancias[v.posicion()] + 1;
ListaGenerica<Arista<String>> ady = grafo.listaDeAdyacentes(v);
ady.comenzar();
while (!ady.fin()) {
Arista<String> a = ady.proximo();
if (distancias[a.verticeDestino().posicion()] == Integer.MAX_VALUE) {
q.encolar(a.verticeDestino());
distancias[a.verticeDestino().posicion()] = nuevaDist;
if (nuevaDist > maxDist) {
maxDist = nuevaDist;
}
}
}
}
return maxDist;
}
/**
* Compara el vértice con otro objeto. La comparación es <em>recursiva</em>. Las clases que
* extiendan {@link Vertice} deben sobrecargar el método {@link Vertice#equals}.
*
* @param o el objeto con el cual se comparará el vértice.
* @return <code>true</code> si el objeto es instancia de la clase {@link Vertie}, su elemento
* es igual al elemento de éste vértice, y los descendientes de ambos son recursivamente
* iguales; <code>false</code> en otro caso.
*/
@Override
public boolean equals(Object o) {
if (o == null || raiz == null || getClass() != o.getClass()) return false;
@SuppressWarnings("unchecked")
Vertice vertice = (Vertice) o;
return raiz.get().equals(vertice.get())
&& equals(raiz.izquierdo, vertice.izquierdo)
&& equals(raiz.derecho, vertice.derecho);
}
private boolean equals(Vertice i, Vertice d) {
// En el caso de que vertices de un nodo y ambos no tengas hijos.
if (i == null && d == null) return true;
// Si los vertices hijos son diferentes.
else if (i != null && d == null || i == null && d != null) return false;
// Compara el elemento y despues a sus hijos por izquierda y
return i.get().equals(d.get())
&& equals(i.izquierdo, d.izquierdo)
&& equals(i.derecho, d.derecho);
}
public void montarGrafo() throws FileNotFoundException, IOException {
String valor;
valor = scan.next();
Vertice ver = new Vertice();
ver.setId(Integer.parseInt(valor));
ver.setVerticeVizinha(Integer.parseInt(scan.next()));
ver.setPeso(Integer.parseInt(scan.next()));
grafo.add(ver);
while (scan.hasNext()) {
valor = scan.next();
existe = verticeExiste(Integer.parseInt(valor));
if (existe != -1) {
grafo.get(existe).setVerticeVizinha(Integer.parseInt(scan.next()));
grafo.get(existe).setPeso(Integer.parseInt(scan.next()));
} else {
Vertice ver1 = new Vertice();
ver1.setId(Integer.parseInt(valor));
ver1.setVerticeVizinha(Integer.parseInt(scan.next()));
ver1.setPeso(Integer.parseInt(scan.next()));
grafo.add(ver);
}
exibeGrafo();
}
}
/**
* Busca recursivamente un elemento, a partir del vértice recibido.
*
* @param vertice el vértice a partir del cuál comenzar la búsqueda. Puede ser <code>null</code>.
* @param elemento el elemento a buscar a partir del vértice.
* @return el vértice que contiene el elemento a buscar, si se encuentra en el árbol; <code>null
* </code> en otro caso.
*/
protected Vertice busca(Vertice vertice, T elemento) {
if (vertice == null) return null;
if (vertice.get().equals(elemento)) return vertice;
Vertice mi = busca(vertice.izquierdo, elemento);
Vertice md = busca(vertice.derecho, elemento);
return mi != null ? mi : md;
}
/**
* Compara el árbol con un objeto.
*
* @param o el objeto con el que queremos comparar el árbol.
* @return <code>true</code> si el objeto recibido es un árbol binario y los árboles son iguales;
* <code>false</code> en otro caso.
*/
@Override
public boolean equals(Object o) {
if (o == null || getClass() != o.getClass()) return false;
@SuppressWarnings("unchecked")
ArbolBinario<T> arbol = (ArbolBinario<T>) o;
return esVacio() || raiz.equals(arbol.raiz);
}
public boolean save(Zone zone) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = getConnection();
st = conn.prepareStatement(SAVE_ZONE, Statement.RETURN_GENERATED_KEYS);
st.setString(1, zone.getName());
st.setString(2, zone.getZonetype());
st.setString(3, zone.getFormtype());
st.setString(4, zone.getWorld());
st.setString(5, zone.getAdmins());
st.setString(6, zone.getUsers());
st.setString(7, zone.getSettings());
st.setInt(8, zone.getMiny());
st.setInt(9, zone.getMaxy());
st.setInt(10, zone.getSize());
st.setString(11, zone.getConfig().toString());
st.execute();
rs = st.getGeneratedKeys();
if (rs.next()) {
zone.setId(rs.getInt(1));
}
} catch (Exception e) {
Zones.log.warning("[Zones]Error deleting " + zone.getName() + "[" + zone.getId() + "] :");
e.printStackTrace();
return false;
} finally {
try {
if (conn != null) conn.close();
if (st != null) st.close();
if (rs != null) rs.close();
} catch (Exception e) {
}
}
if (zone.getId() == 0) return false;
for (Vertice vertice : zone.getVertices()) {
vertice.setId(zone.getId());
save(vertice);
}
return true;
}
public void run(Graph graph, Vertice vertice) {
vertice.markAsExplored();
vertice.setLeader(DfsLoop.leader);
for (Edge edge : getEdges(vertice)) {
Vertice endPoint = null;
if (edge.getTail().equals(vertice)) {
endPoint = edge.getHead();
} else {
endPoint = edge.getTail();
}
if (!endPoint.isExplored()) {
this.run(graph, endPoint);
}
}
DfsLoop.finishingTime++;
vertice.setFinishingTime(DfsLoop.finishingTime);
}
public boolean save(Vertice vertice) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = getConnection();
st = conn.prepareStatement(SAVE_VERTICE);
st.setInt(1, vertice.getId());
st.setInt(2, vertice.getVertexorder());
st.setInt(3, vertice.getX());
st.setInt(4, vertice.getZ());
st.execute();
} catch (Exception e) {
Zones.log.warning(
"[Zones]Error saving vertices "
+ vertice.getId()
+ "["
+ vertice.getVertexorder()
+ "] :");
e.printStackTrace();
return false;
} finally {
try {
if (conn != null) conn.close();
if (st != null) st.close();
if (rs != null) rs.close();
} catch (Exception e) {
}
}
return true;
}
public String execAnalise(Grafo grafo) {
vColoridos = new ArrayList(); // vertices coloridos
aColoridas = new ArrayList(); // arestas coloridas
for (int i = 0; i < grafo.getQtdVertices(); i++)
if ((grafo.getAcendedor()).estaAceso(grafo.getVertice(i)))
vColoridos.add(new Integer((grafo.getVertice(i)).getNome()));
if (vColoridos.size() != 0) {
for (int i = 0; i < vColoridos.size(); i++) {
Vertice colorido = grafo.getVerticeByNome(((Integer) vColoridos.get(i)).intValue());
ArrayList adjacencias = grafo.getAdjacencias(colorido);
ArrayList a = new ArrayList();
for (int j = 0; j < adjacencias.size(); j++) {
Vertice V = (Vertice) adjacencias.get(j);
if (pertenceColoridos(V.getNome()))
if ((grafo.getAcendedor()).estaAceso(grafo.getArestaEntreVertices(colorido, V)))
a.add(new Integer(V.getNome()));
}
aColoridas.add(a);
}
return subgrafo(grafo);
} else return "Escolha um subgrafo!";
}
public List<Zone> getWorld(String world) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List<Zone> zones = new ArrayList<Zone>();
try {
conn = getConnection();
st = conn.prepareStatement(SELECT_ZONES);
st.setString(1, world);
rs = st.executeQuery();
Zone z = null;
while (rs.next()) {
if (z == null || z.getId() != rs.getInt("id")) {
if (z != null) {
zones.add(z);
}
z = new Zone();
z.setId(rs.getInt("id"));
z.setName(rs.getString("name"));
z.setZonetype(rs.getString("zonetype"));
z.setFormtype(rs.getString("formtype"));
z.setWorld(rs.getString("world"));
z.setAdmins(rs.getString("admins"));
z.setUsers(rs.getString("users"));
z.setSettings(rs.getString("settings"));
z.setMinY(rs.getInt("minz"));
z.setMaxY(rs.getInt("maxz"));
z.setSize(rs.getInt("size"));
z.setConfig(rs.getString("config"));
}
z.addVertice(Vertice.from(z, rs));
}
if (z != null) {
zones.add(z);
}
} catch (Exception e) {
Zones.log.warning("[Zones]Error loading zones of world " + world + ":");
e.printStackTrace();
} finally {
try {
if (conn != null) conn.close();
if (st != null) st.close();
if (rs != null) rs.close();
} catch (Exception e) {
}
}
return zones;
}
protected boolean esHijoDerecho(Vertice vertice) {
if (!vertice.hayPadre()) return false;
return vertice.padre.derecho == vertice;
}
/**
* Metodo auxiliar que me indica si es un hijo izquierdo, comparando el vertice su padre el
* izquierdo (osea el mismo vertice), igual a el mismo
*
* @param vertice El vertice del cual se desea saber.
* @return <code>true</code> Si es hijo izquiero, <code>false</code> en otro caso.
*/
protected boolean esHijoIzquierdo(Vertice vertice) {
if (!vertice.hayPadre()) return false;
return vertice.padre.izquierdo == vertice;
}
protected boolean tieneAmbosHijos(Vertice vertice) {
return vertice.hayDerecho() && vertice.hayIzquierdo();
}
protected boolean soloTieneUnHijo(Vertice vertice) {
return !vertice.hayDerecho() && vertice.hayIzquierdo()
|| vertice.hayDerecho() && !vertice.hayDerecho();
}
public static List<Vertice> lerGrafo(String nomeArquivo) {
Grafo g = new Grafo();
Vertice v;
File f = new File(nomeArquivo);
String vertices[];
String linha;
ArrayList<String[]> s1 = new ArrayList<String[]>();
try {
BufferedReader br = new BufferedReader(new FileReader(f));
Map<String, Vertice> mapa = new HashMap<String, Vertice>();
while ((linha = br.readLine()) != null) {
if (linha.contains(",")) {
s1.add(linha.split("/"));
vertices = s1.get(0)[0].split(",");
v = (Vertice) mapa.get(vertices[0]);
if (v == null) v = new Vertice();
List<Vertice> vizinhosAtual = new ArrayList<Vertice>();
List<Aresta> arestasAtual = new ArrayList<Aresta>();
v.setDescricao(vertices[0]);
mapa.put(vertices[0], v);
if (linha.contains("/")) {
String pesoArestas[] = s1.get(0)[1].split(",");
for (int i = 1; i < vertices.length; i++) {
Vertice vit;
// vit = g.encontrarVertice(vertices[i]);
vit = mapa.get(vertices[i]);
if (vit == null) vit = new Vertice();
vit.setDescricao(vertices[i]);
vizinhosAtual.add(vit);
mapa.put(vertices[i], vit);
Aresta ait = new Aresta(v, vit);
ait.setPeso(Integer.parseInt(pesoArestas[i - 1]));
arestasAtual.add(ait);
}
v.setVizinhos(vizinhosAtual);
v.setArestas(arestasAtual);
}
}
// Vertices finais
else {
// v = g.encontrarVertice(linha);
v = (Vertice) mapa.get(linha);
if (v == null) v = new Vertice();
v.setDescricao(linha);
mapa.put(linha, v);
}
g.adicionarVertice(v);
s1.clear();
}
// catch do BufferedReader
} catch (FileNotFoundException e) {
System.out.println("Nao encontrou o arquivo");
e.printStackTrace();
}
// catch do readLine
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// Retornando os vertices
return g.getVertices();
}
protected boolean esHoja(Vertice vertice) {
return !vertice.hayDerecho() && !vertice.hayIzquierdo();
}
