Example usage for org.jdom2 Element getChildText

List of usage examples for org.jdom2 Element getChildText

Introduction

In this page you can find the example usage for org.jdom2 Element getChildText.

Prototype

public String getChildText(final String cname) 

Source Link

Document

Returns the textual content of the named child element, or null if there's no such child.

Usage

From source file:bg.LanguageManager.java

/**
 * @brief Read text from node msg in language xml file
 * @param lanTextList store values of leaf node in language xml file
 * @param msg_node internal node of language xml file
 * @marker If add any new element in xml, please check this function
 *//*from  ww  w .  j a v a  2 s .  c om*/
private void addMsgChildrenText(HashMap<String, String> lanTextList, Element msg_node) {
    Element valid_node = msg_node.getChild(NodeCategory.VALID.getText());
    lanTextList.put(LeafNodeLabel.SUCCESS.getText(), valid_node.getChildText(LeafNodeLabel.SUCCESS.getText()));

    Element warning_node = msg_node.getChild(NodeCategory.WARNING.getText());
    lanTextList.put(LeafNodeLabel.LINES_NULL.getText(),
            warning_node.getChildText(LeafNodeLabel.LINES_NULL.getText()));
    lanTextList.put(LeafNodeLabel.SIZE_NULL.getText(),
            warning_node.getChildText(LeafNodeLabel.SIZE_NULL.getText()));
    lanTextList.put(LeafNodeLabel.DELIMITER_NULL.getText(),
            warning_node.getChildText(LeafNodeLabel.DELIMITER_NULL.getText()));
    lanTextList.put(LeafNodeLabel.SPLIT_METHOD_NULL.getText(),
            warning_node.getChildText(LeafNodeLabel.SPLIT_METHOD_NULL.getText()));

    Element error_node = msg_node.getChild(NodeCategory.ERROR.getText());
    lanTextList.put(LeafNodeLabel.LINES_ERROR.getText(),
            error_node.getChildText(LeafNodeLabel.LINES_ERROR.getText()));
    lanTextList.put(LeafNodeLabel.SIZE_ERROR.getText(),
            error_node.getChildText(LeafNodeLabel.SIZE_ERROR.getText()));
    lanTextList.put(LeafNodeLabel.DELIMITER_ERROR.getText(),
            error_node.getChildText(LeafNodeLabel.DELIMITER_ERROR.getText()));
    lanTextList.put(LeafNodeLabel.FILE_WRITTING_FAILED.getText(),
            error_node.getChildText(LeafNodeLabel.FILE_WRITTING_FAILED.getText()));
    lanTextList.put(LeafNodeLabel.FILE_NOT_FOUND.getText(),
            error_node.getChildText(LeafNodeLabel.FILE_NOT_FOUND.getText()));
    lanTextList.put(LeafNodeLabel.UNKNOWN_ERROR.getText(),
            error_node.getChildText(LeafNodeLabel.UNKNOWN_ERROR.getText()));
}

From source file:bg.LanguageManager.java

/**
 * @brief Read text from node button in language xml file
 * @param lanTextList store values of leaf node in language xml file
 * @param btn_node internal node of language xml file
 * @marker If add any new element in xml, please check this function
 *///  w  w w .jav  a2s .c  o  m
private void addButtonChildrenText(HashMap<String, String> lanTextList, Element btn_node) {
    lanTextList.put(LeafNodeLabel.BROWSE.getText(), btn_node.getChildText(LeafNodeLabel.BROWSE.getText()));
    lanTextList.put(LeafNodeLabel.SAVE_AS.getText(), btn_node.getChildText(LeafNodeLabel.SAVE_AS.getText()));
    lanTextList.put(LeafNodeLabel.SPLIT.getText(), btn_node.getChildText(LeafNodeLabel.SPLIT.getText()));
}

From source file:BL.Servlets.AddNode.java

/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods./*from w w  w  .j av a2 s. co m*/
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    try (PrintWriter out = response.getWriter()) {
        /* TODO output your page here. You may use following sample code. */
        out.println("<!DOCTYPE html>");
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Servlet AddUser</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Servlet AddUser at " + request.getContextPath() + "</h1>");
        String NodeType = "residentialProperties";
        Boolean isFound = false;
        try {
            String note_id = keyin("Please Enter note id you need to search: ");
            SAXBuilder saxBuilder = new SAXBuilder();
            String xmlFile = "src\\database.xml";
            Document xmlDoc = saxBuilder.build(new File(xmlFile));
            Element rootElement = xmlDoc.getRootElement();
            //
            List<Element> ListNodeType = rootElement.getChildren(NodeType);
            //
            List<Element> lstNotes = rootElement.getChildren();
            for (int i = 0; i < lstNotes.size(); i++) {
                Element note = (Element) lstNotes.get(i);
                String n_id = note.getAttributeValue("id");
                System.out.println("Note id: " + n_id);
                if (note_id.equalsIgnoreCase(n_id)) {
                    isFound = true;
                    String name = note.getChildText("name");
                    String value = note.getAttributeValue("value");
                    System.out.println(
                            "We found a note with id " + note_id + "; name: " + name + "Value: " + value);
                    break;
                }

            }
            if (!isFound) {
                System.out.println("Sorry, we don't find out any note with id: " + note_id);
            }
            System.out.println("Finished search!");
        } catch (Exception e) {
            // TODO: handle exception
        }
        out.println("</body>");
        out.println("</html>");
    } finally {
        out.close();
    }
}

From source file:ca.nrc.cadc.uws.sample.HelloWorld.java

License:Open Source License

public void run() {
    log.debug("run: " + job.getID());
    try {//www  .  ja v a  2s .c  o m
        ExecutionPhase ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.QUEUED, ExecutionPhase.EXECUTING,
                new Date());
        if (!ExecutionPhase.EXECUTING.equals(ep)) {
            ep = jobUpdater.getPhase(job.getID());
            log.debug(job.getID() + ": QUEUED -> EXECUTING [FAILED] -- DONE");
            return;
        }
        log.info(job.getID() + ": QUEUED -> EXECUTING [OK]");

        String passValue = null;
        String streamValue = null;
        String runforValue = null;

        boolean pass = false;
        boolean stream = false;
        long runfor = 1;

        // JobInfo input (XML)
        if (job.getJobInfo() != null) {
            // TODO: content type/error handling here
            JobInfo ji = job.getJobInfo();
            if (ji.getValid() != null && ji.getValid()) {
                Document document = XmlUtil.buildDocument(ji.getContent());
                Element root = document.getRootElement();
                passValue = root.getChildText("pass");
                streamValue = root.getChildText("stream");
                runforValue = root.getChildText("runfor");
            }
        } else // parameter list input
        {
            passValue = ParameterUtil.findParameterValue(PASS, job.getParameterList());
            streamValue = ParameterUtil.findParameterValue(STREAM, job.getParameterList());
            runforValue = ParameterUtil.findParameterValue(RUNFOR, job.getParameterList());
        }

        if (passValue != null)
            try {
                pass = Boolean.parseBoolean(passValue);
            } catch (Exception ignore) {
                log.debug("invalid boolean value: " + PASS + "=" + passValue);
            }
        if (streamValue != null)
            try {
                stream = Boolean.parseBoolean(streamValue);
            } catch (Exception ignore) {
                log.debug("invalid boolean value: " + STREAM + "=" + streamValue);
            }
        if (runforValue != null)
            try {
                runfor = Long.parseLong(runforValue);
            } catch (Exception ignore) {
                log.debug("invalid long value: " + RUNFOR + "=" + runforValue);
            }

        // sanity check
        runfor *= 1000L; // convert to milliseconds
        if (runfor < MIN_RUNFOR)
            runfor = MIN_RUNFOR;
        else if (runfor > MAX_RUNFOR)
            runfor = MAX_RUNFOR;

        log.debug("pass: " + pass + ", stream: " + stream + ", duration: " + runfor);
        Thread.sleep(runfor);

        ExecutionPhase expected = null;
        ep = null;
        if (pass) {
            expected = ExecutionPhase.COMPLETED;
            List<Result> results = generateResults();
            if (syncOutput != null) {
                if (stream) {
                    syncOutput.setHeader("Content-Type", "text/plain");
                    PrintWriter w = new PrintWriter(syncOutput.getOutputStream());
                    w.println(RESULT);
                    w.close();
                    ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.COMPLETED,
                            new Date());
                } else {
                    syncOutput.setResponseCode(303);
                    syncOutput.setHeader("Location", results.get(0).getURI().toASCIIString());
                    ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.COMPLETED,
                            new Date());
                }
            } else // async
            {
                ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.COMPLETED,
                        results, new Date());
            }
        } else {
            expected = ExecutionPhase.ERROR;
            ErrorSummary error = generateError();
            if (syncOutput != null) {
                if (stream) {
                    syncOutput.setHeader("Content-Type", "text/plain");
                    PrintWriter w = new PrintWriter(syncOutput.getOutputStream());
                    w.println(ERROR);
                    w.close();
                    ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.COMPLETED,
                            new Date());
                } else {
                    syncOutput.setResponseCode(303);
                    syncOutput.setHeader("Location", error.getDocumentURL().toExternalForm());
                    ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.ERROR, error,
                            new Date());
                }
            } else // async
            {
                ep = jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.ERROR, error,
                        new Date());
            }
        }
        if (expected.equals(ep))
            log.info(job.getID() + ": EXECUTING -> " + expected.name() + " [OK]");
        else
            log.info(job.getID() + ": EXECUTING -> " + expected.name() + " [FAILED]");
    }
    //catch(JobNotFoundException ex) { } // either a bug or someone deleted the job after executing it
    //catch(JobPersistenceException ex) { } // back end persistence is failing
    catch (Throwable t) {
        log.error("unexpected failure", t);
        ErrorSummary error = new ErrorSummary(t.toString(), ErrorType.FATAL);
        if (syncOutput != null) {
            try {
                PrintWriter pw = new PrintWriter(syncOutput.getOutputStream());
                pw.println(t.getMessage());
                pw.close();
            } catch (IOException ex) {
                log.error("failed to write unexpected failure message to output", ex);
            }
        }
        try {
            jobUpdater.setPhase(job.getID(), ExecutionPhase.EXECUTING, ExecutionPhase.ERROR, error, new Date());
        } catch (Exception ex) {
            log.error("failed to set unexpected error state: " + ex);
        }
    }
}

From source file:Codigo.XMLReader.java

/**
 * Metodo utilizado para cargar todos los estadios del mundial Brasil 2014
 * desde un documento XML que contiene informacion de cada uno de ellos
 * @return Lista con los estadios del mundial
 *///w  ww.j a v a  2  s . c  om
public ListaEstadios cargarListaDeEstadios() {

    // Se crea la lista con los estadios que se va a retornar
    ListaEstadios listaEstadios = new ListaEstadios();
    //Se crea un SAXBuilder para poder parsear el archivo
    SAXBuilder builder = new SAXBuilder();

    try {
        File xmlFile = new File(getClass().getResource("/XML/Estadios.xml").toURI());
        //Se crea el documento a traves del archivo
        Document document = (Document) builder.build(xmlFile);
        //Se obtiene la raiz 'tables'
        Element raizXML = document.getRootElement();
        //Se obtiene la lista de hijos de la raiz 'Estadios'
        List list = raizXML.getChildren("Estadio");

        //Se recorre la lista de hijos de 'tables'
        for (int i = 0; i < list.size(); i++) {
            //Se obtiene el elemento 'Estadio'
            Element estadio = (Element) list.get(i);

            //Se obtiene el valor que esta entre los tags '<Nombre></Nombre>'
            String nombreEstadio = estadio.getChildText("Nombre");
            //Se obtiene el valor que esta entre los tags '<Ciudad></Ciudad>'
            String ciudadEstadio = estadio.getChildText("Ciudad");
            //Se obtiene el valor que esta entre los tags '<Capacidad></Capacidad>'
            int capacidadEstadio = Integer.parseInt(estadio.getChildTextTrim("Capacidad"));

            // Se crea un NodoEstadio con la informacion del estadio.
            NodoEstadio nuevoEstadio = new NodoEstadio(nombreEstadio, ciudadEstadio, capacidadEstadio);
            // Se inserta el nuevo estadio en la lista de estadios
            listaEstadios.insertarAlFinal(nuevoEstadio);
        }
        return listaEstadios;

    } catch (IOException | JDOMException | URISyntaxException io) {
        System.out.println(io.getMessage());
        return null;
    }
}

From source file:Codigo.XMLReader.java

/**
 * Metodo utilizado para cargar del XML la lisa de equipos que participan
 * en el mundial// w  ww .j  av  a 2  s. c o m
 * @return Lista con los equipos participantes
 */
public ListaEquipos cargarListaEquipos() {

    // Se crea la lista con los equipos que se va a retornar
    ListaEquipos listaEquipos = new ListaEquipos();
    //Se crea un SAXBuilder para poder parsear el archivo
    SAXBuilder builder = new SAXBuilder();

    try {
        File xmlFile = new File(getClass().getResource("/XML/Equipos.xml").toURI());
        //Se crea el documento a traves del archivo
        Document document = (Document) builder.build(xmlFile);
        //Se obtiene la raiz 'Equipos'
        Element raizXML = document.getRootElement();

        //Se obtiene la lista de hijos de la raiz 'Equipos' (Todos los equipos del mundial)
        List listEquipos = raizXML.getChildren("Equipo");

        //Se recorre la lista de hijos de 'Equipos'
        for (int i = 0; i < listEquipos.size(); i++) {
            //Se obtiene el elemento 'equipo'
            Element equipo = (Element) listEquipos.get(i);
            // Se obtienen los datos del equipo actual
            String nombreEquipo = equipo.getChildText("Nombre");
            String nombreEntrenador = equipo.getChildText("Entrenador");
            int partidosJugados = Integer.parseInt(equipo.getChildTextTrim("PartidosJugados"));
            int partidosGanados = Integer.parseInt(equipo.getChildTextTrim("PartidosGanados"));
            int partidosEmpatados = Integer.parseInt(equipo.getChildTextTrim("PartidosEmpatados"));
            int partidosPerdidos = Integer.parseInt(equipo.getChildTextTrim("PartidosPerdidos"));
            int golesAFavor = Integer.parseInt(equipo.getChildTextTrim("GolesAFavor"));
            int golesEnContra = Integer.parseInt(equipo.getChildTextTrim("GolesEnContra"));
            int golDiferencia = Integer.parseInt(equipo.getChildTextTrim("GolDiferencia"));
            int puntos = Integer.parseInt(equipo.getChildTextTrim("Puntos"));
            // Se obtiene la lista de jugadores con su informacion del XML
            List listJugadores = equipo.getChild("Jugadores").getChildren("Jugador");

            // Se crea la lista de jugadores que va a contener el equipo actual
            ListaJugadores jugadores = new ListaJugadores();

            // Se recorre la lista de jugadores
            for (int j = 0; j < listJugadores.size(); j++) {
                // Se obtiene el jugador 'j' de la lista de Jugadores
                Element jugador = (Element) listJugadores.get(j);
                // Se obtienen los datos del jugador 'j'
                String nombreJugador = jugador.getChildText("Nombre");
                int numeroCamiseta = Integer.parseInt(jugador.getChildTextTrim("NumeroCamiseta"));
                String posicion = jugador.getChildTextTrim("Posicion");
                int edad = Integer.parseInt(jugador.getChildTextTrim("Edad"));
                int estatura = Integer.parseInt(jugador.getChildTextTrim("Estatura"));
                int goles = Integer.parseInt(jugador.getChildTextTrim("Goles"));

                //Se crea un nuevo NodoJugador donde se va a almacenar el jugador
                NodoJugador jugadorNuevo = new NodoJugador(nombreJugador, posicion, edad, estatura,
                        numeroCamiseta, goles);

                // Se inserta el nuevo NodoJugador en la lista de jugadores
                jugadores.insertarOrdenadoPorEdad(jugadorNuevo);
            }

            // Se crea un nuevo NodoEquipo que almacena la informacion del equipo actual
            NodoEquipo equipoActual = new NodoEquipo(nombreEquipo, nombreEntrenador, jugadores, partidosJugados,
                    partidosGanados, partidosEmpatados, partidosPerdidos, golesAFavor, golesEnContra,
                    golDiferencia, puntos);

            // Se inserta el NodoEquipo actual en la lista de equipos
            listaEquipos.insertarOrdenado(equipoActual);
        }
        // Retorna la lista de todos los equipos
        return listaEquipos;

    } catch (IOException | JDOMException | URISyntaxException io) {
        System.out.println(io.getMessage());
        return null;
    }
}

From source file:Codigo.XMLReader.java

/**
 * Metodo utilizado para crear los grupos del mundial con la informacion de todos
 * los encuentros por grupo/*from w w w  . ja  v  a2 s  .  c o m*/
 * @param pEquipos equipos participantes del mundial
 * @param pEstadios estadio del mundial
 * @return lista de los grupos del mundial
 */
public ListaGrupos cargarCalendarioYGrupos(ListaEquipos pEquipos, ListaEstadios pEstadios) {

    // Formato que se va a establecer en la creacion de cada fecha
    SimpleDateFormat formatoFecha = new SimpleDateFormat("d/M/yy h:mm a");
    // Se crea la lista de los Grupos del mundial, que se va a retornar
    ListaGrupos listaDeGrupos = new ListaGrupos();
    //Se crea un SAXBuilder para poder parsear el archivo
    SAXBuilder builder = new SAXBuilder();

    try {
        File xmlFile = new File(getClass().getResource("/XML/CalendarioGrupos.xml").toURI());
        //Se crea el documento a traves del archivo
        Document document = (Document) builder.build(xmlFile);
        //Se obtiene la raiz 'Grupos'
        Element raizXML = document.getRootElement();

        //Se obtiene la lista de hijos de la raiz 'Grupos' (Todos los grupos del mundial)
        List listaGruposXML = raizXML.getChildren("Grupo");

        // RECORRE LA LISTA DE GRUPOS DEL MUNDIAL
        for (int i = 0; i < listaGruposXML.size(); i++) {
            //Se obtiene el elemento 'Grupo' en la posicion i de la lista
            Element grupo = (Element) listaGruposXML.get(i);

            // Obtengo el atributo con la letra del grupo
            char letraDelGrupo = grupo.getAttributeValue("letra").charAt(0);

            // Se obtine la lista de los equipos que conforma el grupo
            List selecciones = grupo.getChild("Equipos").getChildren("Equipo");
            // Se crea un arreglo que almacenara las selecciones integrantes
            NodoEquipo[] equiposDelGrupo = new NodoEquipo[selecciones.size()];
            // RECORRE LA LISTA DE EQUIPOS PERTENECIENTES A ESTE GRUPO
            for (int j = 0; j < selecciones.size(); j++) {
                Element equipo = (Element) selecciones.get(j);
                // Obtiene el nombre del equipo 'j'
                NodoEquipo nombreDelEquipo = pEquipos.getNodoEquipo(equipo.getText());
                // Inserta nombre del equipo, en el arreglo de equiposDelGrupo
                equiposDelGrupo[j] = nombreDelEquipo;
            }

            // SE CREA LA LISTA QUE ALMACENARA LOS ENCUENTROS DEL GRUPO                
            ListaCalendario calendarioDelGrupo = new ListaCalendario();
            // Se obtiene la lista de todo los Encuentros correspondientes al grupo
            List listaDeEncuentros = grupo.getChild("Encuentros").getChildren("Partido");
            // RECORRE LA LISTA DE PARTIDOS CORRESPONDIENTES A LOS EQUIPOS DEL GRUPO ACTUAL
            for (int j = 0; j < listaDeEncuentros.size(); j++) {
                Element partido = (Element) listaDeEncuentros.get(j);

                // Obtiene los datos de fecha y hora del encuentro
                String fechaDelPartido = partido.getChildText("Fecha");
                String horaDelPartido = partido.getChildText("Hora");
                Date fechaYHora = formatoFecha.parse(fechaDelPartido + " " + horaDelPartido);

                // Obtiene los datos de condiciones climaticas del encuentro
                String humedad = partido.getChildText("Humedad");
                String velocidadViento = partido.getChildText("VelocidadViento");
                String temperatura = partido.getChildText("Temperatura");
                String condicionClimatica = partido.getChildText("CondicionClimatica");

                // Obtiene el estadio sede del encuentro
                String nombreEstadioSede = partido.getChildText("Sede");
                NodoEstadio estadioSede = pEstadios.getNodoEstadio(nombreEstadioSede);

                // Obtiene los equipos casa y visita que se enfrentan en el encuentro
                String nombreEquipoCasa = partido.getChildText("EquipoCasa");
                NodoEquipo equipoCasa = pEquipos.getNodoEquipo(nombreEquipoCasa);
                String nombreEquipoVisita = partido.getChildText("EquipoVisita");
                NodoEquipo equipoVisita = pEquipos.getNodoEquipo(nombreEquipoVisita);

                // Obtiene la cantidad de goles por equipo, en el encuentro
                int golesCasa = Integer.parseInt(partido.getChild("GolesCasa").getAttributeValue("goles"));
                String anotadoresCasa = "";
                int golesVisita = Integer.parseInt(partido.getChild("GolesVisita").getAttributeValue("goles"));
                String anotadoresVisita = "";

                // COMPRUEBA SI HUBIERON ANOTACIONES, DE LOS LOCALES, PARA OBTENER LOS ANOTADORES
                if (golesCasa > 0) {
                    List anotadores = partido.getChild("GolesCasa").getChild("Anotadores")
                            .getChildren("Anotador");
                    // RECORRE LA LISTA PARA OBTENER LOS ANOTADORES Y EL MINUTO DEL GOL
                    for (int k = 0; k < anotadores.size(); k++) {
                        Element anotador = (Element) anotadores.get(k);
                        // OBTENGO LOS DATOS DEL ANOTADOR 'k'
                        String nombre = anotador.getChildText("Nombre");
                        String minuto = anotador.getChildText("Minuto");
                        if (k < (anotadores.size() - 1)) {
                            anotadoresCasa += minuto + '\'' + "  " + nombre + '\n';
                        } else {
                            anotadoresCasa += minuto + '\'' + "  " + nombre;
                        }
                    }
                }
                // COMPRUEBA SI HUBIERON ANOTACIONES, DE LA VISITA, PARA OBTENER LOS ANOTADORES
                if (golesVisita > 0) {
                    List anotadores = partido.getChild("GolesVisita").getChild("Anotadores")
                            .getChildren("Anotador");
                    // RECORRE LA LISTA PARA OBTENER LOS ANOTADORES Y EL MINUTO DEL GOL
                    for (int k = 0; k < anotadores.size(); k++) {
                        Element anotador = (Element) anotadores.get(k);
                        // OBTENGO LOS DATOS DEL ANOTADOR 'k'
                        String nombre = anotador.getChildText("Nombre");
                        String minuto = anotador.getChildText("Minuto");
                        if (k < (anotadores.size() - 1)) {
                            anotadoresVisita += minuto + '\'' + "  " + nombre + '\n';
                        } else {
                            anotadoresVisita += minuto + '\'' + "  " + nombre;
                        }
                    }
                }
                // Crea un nuevo nodo Encuentro y lo inserta en la lista de Calendario
                NodoEncuentro encuentro = new NodoEncuentro(fechaYHora, humedad, velocidadViento, temperatura,
                        estadioSede, equipoCasa, equipoVisita, golesCasa, golesVisita, anotadoresCasa,
                        anotadoresVisita, condicionClimatica);

                // Inserta el nuevo nodo en la lista de Encuentros
                calendarioDelGrupo.insertarOrdenadoPorFecha(encuentro);
            }
            // Crea un nodo Grupo con toda la informacion del grupo actual
            NodoGrupo grupoDelMundial = new NodoGrupo(letraDelGrupo, equiposDelGrupo, calendarioDelGrupo);
            // Inserta el grupo a la lista de grupos
            listaDeGrupos.insertarOrdenado(grupoDelMundial);
        }
        // Retorna la lista de todos los equipos
        return listaDeGrupos;

    } catch (IOException | JDOMException | URISyntaxException | ParseException io) {
        System.out.println(io.getMessage());
        return null;
    }
}

From source file:com.aurum.whitehole.ObjectDB.java

License:Open Source License

public static void init() {
    fallback = true;/*from  w  ww.ja va 2s . c  om*/
    timestamp = 0;

    categories = new LinkedHashMap();
    objects = new LinkedHashMap();

    File odbfile = new File("objectdb.xml");
    if (!(odbfile.exists() && odbfile.isFile()))
        return;

    try {
        Element root = new SAXBuilder().build(odbfile).getRootElement();
        timestamp = root.getAttribute("timestamp").getLongValue();

        List<Element> catelems = root.getChild("categories").getChildren("category");
        for (Element catelem : catelems)
            categories.put(catelem.getAttribute("id").getIntValue(), catelem.getText());

        List<Element> objelems = root.getChildren("object");
        for (Element objelem : objelems) {
            Object entry = new Object();
            entry.ID = objelem.getAttributeValue("id");
            entry.name = objelem.getChildText("name");
            entry.category = objelem.getChild("category").getAttribute("id").getIntValue();
            entry.type = objelem.getChild("preferredfile").getAttributeValue("name");
            entry.notes = objelem.getChildText("notes");

            Element flags = objelem.getChild("flags");
            entry.games = flags.getAttribute("games").getIntValue();
            entry.known = flags.getAttribute("known").getIntValue();
            entry.complete = flags.getAttribute("complete").getIntValue();

            if (entry.notes.isEmpty() || entry.notes.equals(""))
                entry.notes = "(No description found for this objects.)";
            if (entry.type.isEmpty() || entry.notes.equals(""))
                entry.type = "Unknown";

            entry.files = new ArrayList();
            String files = objelem.getChildText("files");
            for (String file : files.split("\n")) {
                entry.files.add(file);
            }

            List<Element> fields = objelem.getChildren("field");
            entry.fields = new HashMap(fields.size());
            if (!fields.isEmpty()) {
                for (Element field : fields) {
                    Object.Field fielddata = new Object.Field();

                    fielddata.ID = field.getAttribute("id").getIntValue();
                    fielddata.type = field.getAttributeValue("type");
                    fielddata.name = field.getAttributeValue("name");
                    fielddata.values = field.getAttributeValue("values");
                    fielddata.notes = field.getAttributeValue("notes");

                    entry.fields.put(fielddata.ID, fielddata);
                }
            }

            objects.put(entry.ID, entry);
        }
    } catch (IOException | JDOMException ex) {
        timestamp = 0;
        return;
    }

    fallback = false;
}

From source file:com.bio4j.neo4jdb.programs.ImportGeneOntology.java

License:Open Source License

public static void main(String[] args) {

    if (args.length != 3) {
        System.out.println(//from   w w w. j  ava2s.  c  om
                "This program expects the following parameters: \n" + "1. Gene ontology xml filename \n"
                        + "2. Bio4j DB folder \n" + "3. Batch inserter .properties file");

    } else {

        long initTime = System.nanoTime();

        File inFile = new File(args[0]);

        BatchInserter inserter = null;
        BatchInserterIndexProvider indexProvider = null;

        BatchInserterIndex goTermIdIndex;
        BatchInserterIndex isAGoRelIndex;
        BatchInserterIndex nodeTypeIndex;

        BufferedWriter statsBuff = null;

        int termCounter = 0;
        int limitForPrintingOut = 10000;

        try {

            // This block configures the logger with handler and formatter
            fh = new FileHandler("ImportGeneOntology.log", true);
            SimpleFormatter formatter = new SimpleFormatter();
            fh.setFormatter(formatter);
            logger.addHandler(fh);
            logger.setLevel(Level.ALL);

            //---creating writer for stats file-----
            statsBuff = new BufferedWriter(new FileWriter(new File("ImportGeneOntologyStats.txt")));

            // create the batch inserter
            inserter = BatchInserters.inserter(args[1], MapUtil.load(new File(args[2])));

            // create the batch index service
            indexProvider = new LuceneBatchInserterIndexProvider(inserter);
            Map<String, String> indexProps = MapUtil.stringMap("provider", "lucene", "type", "exact");

            goTermIdIndex = indexProvider.nodeIndex(GoTermNode.GO_TERM_ID_INDEX, indexProps);
            isAGoRelIndex = indexProvider.relationshipIndex(IsAGoRel.IS_A_REL_INDEX, indexProps);
            nodeTypeIndex = indexProvider.nodeIndex(Bio4jManager.NODE_TYPE_INDEX_NAME, indexProps);

            //------------------nodes properties maps-----------------------------------
            Map<String, Object> goProperties = new HashMap<String, Object>();
            goProperties.put(GoTermNode.NODE_TYPE_PROPERTY, GoTermNode.NODE_TYPE);
            //--------------------------------------------------------------------------

            //--------------------------------relationships------------------------------------------
            IsAGoRel isAGoRel = new IsAGoRel(null);
            RegulatesGoRel regulatesGoRel = new RegulatesGoRel(null);
            NegativelyRegulatesGoRel negativelyRegulatesGoRel = new NegativelyRegulatesGoRel(null);
            PositivelyRegulatesGoRel positivelyRegulatesGoRel = new PositivelyRegulatesGoRel(null);
            PartOfGoRel partOfGoRel = new PartOfGoRel(null);
            HasPartOfGoRel hasPartGoRel = new HasPartOfGoRel(null);
            //--------------------------------------------------------------------------

            Map<String, ArrayList<String>> termParentsMap = new HashMap<String, ArrayList<String>>();
            Map<String, ArrayList<String>> regulatesMap = new HashMap<String, ArrayList<String>>();
            Map<String, ArrayList<String>> negativelyRegulatesMap = new HashMap<String, ArrayList<String>>();
            Map<String, ArrayList<String>> positivelyRegulatesMap = new HashMap<String, ArrayList<String>>();
            Map<String, ArrayList<String>> partOfMap = new HashMap<String, ArrayList<String>>();
            Map<String, ArrayList<String>> hasPartMap = new HashMap<String, ArrayList<String>>();

            BufferedReader reader = new BufferedReader(new FileReader(inFile));
            String line;
            StringBuilder termStBuilder = new StringBuilder();

            logger.log(Level.INFO, "inserting nodes....");

            //-----first I create all the elements whitout their relationships-------------

            while ((line = reader.readLine()) != null) {
                if (line.trim().startsWith("<" + TERM_TAG_NAME)) {

                    while (!line.trim().startsWith("</" + TERM_TAG_NAME + ">")) {
                        termStBuilder.append(line);
                        line = reader.readLine();
                    }
                    //linea final del organism
                    termStBuilder.append(line);
                    //System.out.println("organismStBuilder.toString() = " + organismStBuilder.toString());
                    XMLElement termXMLElement = new XMLElement(termStBuilder.toString());
                    termStBuilder.delete(0, termStBuilder.length());

                    String goId = termXMLElement.asJDomElement().getChildText(ID_TAG_NAME);
                    String goName = termXMLElement.asJDomElement().getChildText(NAME_TAG_NAME);
                    if (goName == null) {
                        goName = "";
                    }
                    String goNamespace = termXMLElement.asJDomElement().getChildText(NAMESPACE_TAG_NAME);
                    if (goNamespace == null) {
                        goNamespace = "";
                    }
                    String goDefinition = "";
                    Element defElem = termXMLElement.asJDomElement().getChild(DEF_TAG_NAME);
                    if (defElem != null) {
                        Element defstrElem = defElem.getChild(DEFSTR_TAG_NAME);
                        if (defstrElem != null) {
                            goDefinition = defstrElem.getText();
                        }
                    }
                    String goComment = termXMLElement.asJDomElement().getChildText(COMMENT_TAG_NAME);
                    if (goComment == null) {
                        goComment = "";
                    }
                    String goIsObsolete = termXMLElement.asJDomElement().getChildText(IS_OBSOLETE_TAG_NAME);
                    if (goIsObsolete == null) {
                        goIsObsolete = "";
                    } else {
                        if (goIsObsolete.equals("1")) {
                            goIsObsolete = "true";
                        } else {
                            goIsObsolete = "false";
                        }
                    }

                    List<Element> altIdElems = termXMLElement.asJDomElement().getChildren("alt_id");
                    String[] alternativeIds = new String[altIdElems.size()];
                    for (int i = 0; i < altIdElems.size(); i++) {
                        alternativeIds[i] = altIdElems.get(i).getText();
                    }

                    //----term parents----
                    List<Element> termParentTerms = termXMLElement.asJDomElement()
                            .getChildren(IsAGoRel.OBOXML_RELATIONSHIP_NAME);
                    ArrayList<String> array = new ArrayList<String>();
                    for (Element elem : termParentTerms) {
                        array.add(elem.getText().trim());
                    }
                    termParentsMap.put(goId, array);
                    //---------------------

                    //-------relationship tags-----------
                    List<Element> relationshipTags = termXMLElement.asJDomElement()
                            .getChildren(RELATIONSHIP_TAG_NAME);

                    for (Element relationshipTag : relationshipTags) {

                        String relType = relationshipTag.getChildText("type");
                        String toSt = relationshipTag.getChildText("to");

                        if (relType.equals(RegulatesGoRel.OBOXML_RELATIONSHIP_NAME)) {

                            ArrayList<String> tempArray = regulatesMap.get(goId);
                            if (tempArray == null) {
                                tempArray = new ArrayList<String>();
                                regulatesMap.put(goId, tempArray);
                            }
                            tempArray.add(toSt);

                        } else if (relType.equals(PositivelyRegulatesGoRel.OBOXML_RELATIONSHIP_NAME)) {

                            ArrayList<String> tempArray = positivelyRegulatesMap.get(goId);
                            if (tempArray == null) {
                                tempArray = new ArrayList<String>();
                                positivelyRegulatesMap.put(goId, tempArray);
                            }
                            tempArray.add(toSt);

                        } else if (relType.equals(NegativelyRegulatesGoRel.OBOXML_RELATIONSHIP_NAME)) {

                            ArrayList<String> tempArray = negativelyRegulatesMap.get(goId);
                            if (tempArray == null) {
                                tempArray = new ArrayList<String>();
                                negativelyRegulatesMap.put(goId, tempArray);
                            }
                            tempArray.add(toSt);

                        } else if (relType.equals(PartOfGoRel.OBOXML_RELATIONSHIP_NAME)) {

                            ArrayList<String> tempArray = partOfMap.get(goId);
                            if (tempArray == null) {
                                tempArray = new ArrayList<String>();
                                partOfMap.put(goId, tempArray);
                            }
                            tempArray.add(toSt);

                        } else if (relType.equals(HasPartOfGoRel.OBOXML_RELATIONSHIP_NAME)) {

                            ArrayList<String> tempArray = hasPartMap.get(goId);
                            if (tempArray == null) {
                                tempArray = new ArrayList<String>();
                                hasPartMap.put(goId, tempArray);
                            }
                            tempArray.add(toSt);

                        }
                    }
                    //-------------------------------------

                    goProperties.put(GoTermNode.ID_PROPERTY, goId);
                    goProperties.put(GoTermNode.NAME_PROPERTY, goName);
                    goProperties.put(GoTermNode.DEFINITION_PROPERTY, goDefinition);
                    goProperties.put(GoTermNode.NAMESPACE_PROPERTY, goNamespace);
                    goProperties.put(GoTermNode.ALTERNATIVE_IDS_PROPERTY, alternativeIds);
                    goProperties.put(GoTermNode.OBSOLETE_PROPERTY, goIsObsolete);
                    goProperties.put(GoTermNode.COMMENT_PROPERTY, goComment);
                    long currentGoTermId = inserter.createNode(goProperties);
                    //--------indexing term by id (and alternative ids)----------
                    goTermIdIndex.add(currentGoTermId, MapUtil.map(GoTermNode.GO_TERM_ID_INDEX, goId));
                    for (int i = 0; i < alternativeIds.length; i++) {
                        goTermIdIndex.add(currentGoTermId,
                                MapUtil.map(GoTermNode.GO_TERM_ID_INDEX, alternativeIds[i]));
                    }
                    //--------indexing node by node_type index----------
                    nodeTypeIndex.add(currentGoTermId,
                            MapUtil.map(Bio4jManager.NODE_TYPE_INDEX_NAME, GoTermNode.NODE_TYPE));

                }
                termCounter++;
                if ((termCounter % limitForPrintingOut) == 0) {
                    logger.log(Level.INFO, (termCounter + " terms inserted!!"));
                }
            }
            reader.close();

            //flushing index
            goTermIdIndex.flush();

            //-----------------------------------------------------------------------

            logger.log(Level.INFO, "Inserting relationships....");

            logger.log(Level.INFO, "'is_a' relationships....");

            //-------------------'is_a' relationships-----------------
            Set<String> keys = termParentsMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = termParentsMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    long isAGorelId = inserter.createRelationship(currentNodeId, tempNodeId, isAGoRel, null);
                    //System.out.println("key = " + key);
                    isAGoRelIndex.add(isAGorelId,
                            MapUtil.map(IsAGoRel.IS_A_REL_INDEX, String.valueOf(currentNodeId)));
                    //System.out.println("indexing key = " + key);
                }
            }

            logger.log(Level.INFO, "'regulates' relationships....");
            //-------------------'regulates' relationships----------------------
            keys = regulatesMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = regulatesMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    inserter.createRelationship(currentNodeId, tempNodeId, regulatesGoRel, null);
                }
            }

            logger.log(Level.INFO, "'negatively_regulates' relationships....");
            //-------------------'regulates' relationships----------------------
            keys = negativelyRegulatesMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = negativelyRegulatesMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    inserter.createRelationship(currentNodeId, tempNodeId, negativelyRegulatesGoRel, null);
                }
            }

            logger.log(Level.INFO, "'positively_regulates' relationships....");
            //-------------------'regulates' relationships----------------------
            keys = positivelyRegulatesMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = positivelyRegulatesMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    inserter.createRelationship(currentNodeId, tempNodeId, positivelyRegulatesGoRel, null);
                }
            }

            logger.log(Level.INFO, "'part_of' relationships....");
            //-------------------'regulates' relationships----------------------
            keys = partOfMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = partOfMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    inserter.createRelationship(currentNodeId, tempNodeId, partOfGoRel, null);
                }
            }

            logger.log(Level.INFO, "'has_part' relationships....");
            //-------------------'regulates' relationships----------------------
            keys = hasPartMap.keySet();
            for (String key : keys) {
                long currentNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, key).getSingle();
                ArrayList<String> tempArray = hasPartMap.get(key);
                for (String string : tempArray) {
                    long tempNodeId = goTermIdIndex.get(GoTermNode.GO_TERM_ID_INDEX, string).getSingle();
                    inserter.createRelationship(currentNodeId, tempNodeId, hasPartGoRel, null);
                }
            }

            logger.log(Level.INFO, "Done! :)");

        } catch (Exception e) {
            logger.log(Level.SEVERE, e.getMessage());
            StackTraceElement[] trace = e.getStackTrace();
            for (StackTraceElement stackTraceElement : trace) {
                logger.log(Level.SEVERE, stackTraceElement.toString());
            }
        } finally {

            try {
                //closing logger file handler
                fh.close();
                logger.log(Level.INFO, "Closing up inserter and index service....");
                // shutdown, makes sure all changes are written to disk
                indexProvider.shutdown();
                inserter.shutdown();

                //-----------------writing stats file---------------------
                long elapsedTime = System.nanoTime() - initTime;
                long elapsedSeconds = Math.round((elapsedTime / 1000000000.0));
                long hours = elapsedSeconds / 3600;
                long minutes = (elapsedSeconds % 3600) / 60;
                long seconds = (elapsedSeconds % 3600) % 60;

                statsBuff.write("Statistics for program ImportGeneOntology:\nInput file: " + inFile.getName()
                        + "\nThere were " + termCounter + " terms inserted.\n" + "The elapsed time was: "
                        + hours + "h " + minutes + "m " + seconds + "s\n");

                //---closing stats writer---
                statsBuff.close();

            } catch (Exception e) {
                logger.log(Level.SEVERE, e.getMessage());
                StackTraceElement[] trace = e.getStackTrace();
                for (StackTraceElement stackTraceElement : trace) {
                    logger.log(Level.SEVERE, stackTraceElement.toString());
                }
            }

        }
    }
}

From source file:com.bio4j.neo4jdb.programs.ImportProteinInteractions.java

License:Open Source License

public static void main(String[] args) throws IOException {

    if (args.length != 3) {
        System.out.println("This program expects the following parameters: \n" + "1. Uniprot xml filename \n"
                + "2. Bio4j DB folder\n" + "3. Batch inserter .properties file");
    } else {//from   ww w .  ja  v a 2 s  . c om

        long initTime = System.nanoTime();

        File inFile = new File(args[0]);

        BatchInserter inserter = null;
        BatchInserterIndexProvider indexProvider = null;
        String accessionSt = "";

        BufferedWriter statsBuff = null;

        int proteinCounter = 0;
        int limitForPrintingOut = 10000;

        try {

            // This block configure the logger with handler and formatter
            fh = new FileHandler("ImportProteinInteractions" + args[0].split("\\.")[0] + ".log", false);
            SimpleFormatter formatter = new SimpleFormatter();
            fh.setFormatter(formatter);
            logger.addHandler(fh);
            logger.setLevel(Level.ALL);
            //---------------------------------

            //---creating writer for stats file-----
            statsBuff = new BufferedWriter(new FileWriter(
                    new File("ImportProteinInteractionsStats_" + inFile.getName().split("\\.")[0] + ".txt")));

            // create the batch inserter
            inserter = BatchInserters.inserter(args[1], MapUtil.load(new File(args[2])));

            // create the batch index service
            indexProvider = new LuceneBatchInserterIndexProvider(inserter);

            //------------------nodes properties maps-----------------------------------
            //---------------------------------------------------------------------

            //-------------------relationships properties maps--------------------------
            Map<String, Object> proteinProteinInteractionProperties = new HashMap<String, Object>();
            Map<String, Object> proteinIsoformInteractionProperties = new HashMap<String, Object>();
            //----------------------------------------------------------------------------

            //--------------------------------relationships------------------------------------------
            ProteinProteinInteractionRel proteinProteinInteractionRel = new ProteinProteinInteractionRel(null);
            ProteinIsoformInteractionRel proteinIsoformInteractionRel = new ProteinIsoformInteractionRel(null);
            //------------------------------------------------------------------------------------------------

            //------------------indexes creation----------------------------------
            BatchInserterIndex proteinAccessionIndex = indexProvider.nodeIndex(
                    ProteinNode.PROTEIN_ACCESSION_INDEX,
                    MapUtil.stringMap(PROVIDER_ST, LUCENE_ST, TYPE_ST, EXACT_ST));
            BatchInserterIndex isoformIdIndex = indexProvider.nodeIndex(IsoformNode.ISOFORM_ID_INDEX,
                    MapUtil.stringMap(PROVIDER_ST, LUCENE_ST, TYPE_ST, EXACT_ST));
            //--------------------------------------------------------------------

            BufferedReader reader = new BufferedReader(new FileReader(inFile));
            String line;
            StringBuilder entryStBuilder = new StringBuilder();

            while ((line = reader.readLine()) != null) {
                if (line.trim().startsWith("<" + UniprotStuff.ENTRY_TAG_NAME)) {

                    while (!line.trim().startsWith("</" + UniprotStuff.ENTRY_TAG_NAME + ">")) {
                        entryStBuilder.append(line);
                        line = reader.readLine();
                    }
                    //linea final del organism
                    entryStBuilder.append(line);
                    //System.out.println("organismStBuilder.toString() = " + organismStBuilder.toString());
                    XMLElement entryXMLElem = new XMLElement(entryStBuilder.toString());
                    entryStBuilder.delete(0, entryStBuilder.length());

                    accessionSt = entryXMLElem.asJDomElement()
                            .getChildText(UniprotStuff.ENTRY_ACCESSION_TAG_NAME);

                    long currentProteinId = proteinAccessionIndex
                            .get(ProteinNode.PROTEIN_ACCESSION_INDEX, accessionSt).getSingle();

                    List<Element> comments = entryXMLElem.asJDomElement()
                            .getChildren(UniprotStuff.COMMENT_TAG_NAME);

                    for (Element commentElem : comments) {

                        String commentTypeSt = commentElem
                                .getAttributeValue(UniprotStuff.COMMENT_TYPE_ATTRIBUTE);

                        //----------interaction----------------
                        if (commentTypeSt.equals(ProteinProteinInteractionRel.UNIPROT_ATTRIBUTE_TYPE_VALUE)) {
                            List<Element> interactants = commentElem.getChildren("interactant");
                            Element interactant1 = interactants.get(0);
                            Element interactant2 = interactants.get(1);
                            Element organismsDiffer = commentElem.getChild("organismsDiffer");
                            Element experiments = commentElem.getChild("experiments");
                            String intactId1St = interactant1.getAttributeValue("intactId");
                            String intactId2St = interactant2.getAttributeValue("intactId");
                            String organismsDifferSt = "";
                            String experimentsSt = "";
                            if (intactId1St == null) {
                                intactId1St = "";
                            }
                            if (intactId2St == null) {
                                intactId2St = "";
                            }
                            if (organismsDiffer != null) {
                                organismsDifferSt = organismsDiffer.getText();
                            }
                            if (experiments != null) {
                                experimentsSt = experiments.getText();
                            }

                            //----now we try to retrieve the interactant 2 accession--
                            String interactant2AccessionSt = interactant2.getChildText("id");
                            long protein2Id = -1;
                            if (interactant2AccessionSt != null) {

                                IndexHits<Long> protein2IdIndexHits = proteinAccessionIndex
                                        .get(ProteinNode.PROTEIN_ACCESSION_INDEX, interactant2AccessionSt);
                                if (protein2IdIndexHits.hasNext()) {
                                    if (protein2IdIndexHits.size() == 1) {
                                        protein2Id = protein2IdIndexHits.getSingle();
                                    }
                                }

                                if (protein2Id < 0) {
                                    //Since we did not find the protein we try to find a isoform instead
                                    long isoformId = -1;
                                    IndexHits<Long> isoformIdIndexHits = isoformIdIndex
                                            .get(IsoformNode.ISOFORM_ID_INDEX, interactant2AccessionSt);
                                    if (isoformIdIndexHits.hasNext()) {
                                        if (isoformIdIndexHits.size() == 1) {
                                            isoformId = isoformIdIndexHits.getSingle();
                                        }
                                    }
                                    if (isoformId >= 0) {

                                        proteinIsoformInteractionProperties.put(
                                                ProteinIsoformInteractionRel.EXPERIMENTS_PROPERTY,
                                                experimentsSt);
                                        proteinIsoformInteractionProperties.put(
                                                ProteinIsoformInteractionRel.ORGANISMS_DIFFER_PROPERTY,
                                                organismsDifferSt);
                                        proteinIsoformInteractionProperties.put(
                                                ProteinIsoformInteractionRel.INTACT_ID_1_PROPERTY, intactId1St);
                                        proteinIsoformInteractionProperties.put(
                                                ProteinIsoformInteractionRel.INTACT_ID_2_PROPERTY, intactId2St);

                                        inserter.createRelationship(currentProteinId, isoformId,
                                                proteinIsoformInteractionRel,
                                                proteinIsoformInteractionProperties);

                                    }
                                } else {

                                    proteinProteinInteractionProperties.put(
                                            ProteinProteinInteractionRel.EXPERIMENTS_PROPERTY, experimentsSt);
                                    proteinProteinInteractionProperties.put(
                                            ProteinProteinInteractionRel.ORGANISMS_DIFFER_PROPERTY,
                                            organismsDifferSt);
                                    proteinProteinInteractionProperties.put(
                                            ProteinProteinInteractionRel.INTACT_ID_1_PROPERTY, intactId1St);
                                    proteinProteinInteractionProperties.put(
                                            ProteinProteinInteractionRel.INTACT_ID_2_PROPERTY, intactId2St);

                                    inserter.createRelationship(currentProteinId, protein2Id,
                                            proteinProteinInteractionRel, proteinProteinInteractionProperties);

                                }

                            }

                        }

                    }

                    proteinCounter++;
                    if ((proteinCounter % limitForPrintingOut) == 0) {
                        logger.log(Level.INFO, (proteinCounter + " proteins updated with interactions!!"));
                    }

                }
            }

            reader.close();

        } catch (Exception e) {
            logger.log(Level.SEVERE, ("Exception retrieving protein " + accessionSt));
            logger.log(Level.SEVERE, e.getMessage());
            StackTraceElement[] trace = e.getStackTrace();
            for (StackTraceElement stackTraceElement : trace) {
                logger.log(Level.SEVERE, stackTraceElement.toString());
            }

        } finally {
            //outbBuff.close();

            try {

                // shutdown, makes sure all changes are written to disk
                indexProvider.shutdown();
                inserter.shutdown();

                //closing logger file handler
                fh.close();

                //-----------------writing stats file---------------------
                long elapsedTime = System.nanoTime() - initTime;
                long elapsedSeconds = Math.round((elapsedTime / 1000000000.0));
                long hours = elapsedSeconds / 3600;
                long minutes = (elapsedSeconds % 3600) / 60;
                long seconds = (elapsedSeconds % 3600) % 60;

                statsBuff.write("Statistics for program ImportProteinInteractions:\nInput file: "
                        + inFile.getName() + "\nThere were " + proteinCounter + " proteins analyzed.\n"
                        + "The elapsed time was: " + hours + "h " + minutes + "m " + seconds + "s\n");

                //---closing stats writer---
                statsBuff.close();

            } catch (Exception e) {

                logger.log(Level.SEVERE, ("Exception retrieving protein " + accessionSt));
                logger.log(Level.SEVERE, e.getMessage());
                StackTraceElement[] trace = e.getStackTrace();
                for (StackTraceElement stackTraceElement : trace) {
                    logger.log(Level.SEVERE, stackTraceElement.toString());
                }
                //closing logger file handler
                fh.close();
            }

        }
    }

}