package modelo;

import controlador.Utilidades;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Observable;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;





// <editor-fold defaultstate="collapsed" desc=" UML Marker ">
// #[regen=yes,id=DCE.A9A2021E-5760-8394-6C1F-F91564E9B66B]
// </editor-fold>
public class DocumentoRequisitos extends Observable {
    Utilidades utilidades = new Utilidades();

    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.38C4B9B5-EB36-0374-C07A-F1BB9260F167]
    // </editor-fold>
    private ElementosTrazas mElementosTrazas;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.FEEC93A7-EB6B-BDA3-5E77-F887AC2CACAE]
    // </editor-fold>
    private ArrayList<Participante> mParticipante;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.F49B9FED-4A1C-CB61-4189-BD11D796F569]
    // </editor-fold>
    private ArrayList<Apendice> mApendice;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.194F2976-9126-AEA6-B51E-1B04E1173689]
    // </editor-fold>
    private ArrayList<Seccion> mSeccion;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.98DC635C-686D-147B-39C2-EA9E927146A4]
    // </editor-fold>
    private ArrayList<Organizacion> mOrganizacion;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.FA0D553A-1C6F-47A4-3799-6D77FEBEBBE2]
    // </editor-fold>
    private ArrayList<MatrizRastreabilidad> mMatrizRastreabilidad;





    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,id=DCE.42B32357-46CB-B416-2253-F29792782C92]
    // </editor-fold>
    public DocumentoRequisitos () {
        mElementosTrazas = new ElementosTrazas();
        mParticipante = new ArrayList<Participante>();
        mApendice = new ArrayList<Apendice>();
        mSeccion = new ArrayList<Seccion>();
        mOrganizacion = new ArrayList<Organizacion>();
        mMatrizRastreabilidad = new ArrayList<MatrizRastreabilidad>();
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.8F5DB735-6192-CABC-1600-B9C3E64350FC]
    // </editor-fold>
    public ArrayList<Apendice> getApendice () {
        return mApendice;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.FD250CA0-8AA7-ACCF-FD64-D713E4F88437]
    // </editor-fold>
    public void setApendice (ArrayList<Apendice> val) {
        this.mApendice = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.A44E2539-F9A3-4A9E-1EAD-209CE106C5A5]
    // </editor-fold>
    public ElementosTrazas getElementosTrazas () {
        return mElementosTrazas;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.82171C08-A5B7-F7FC-DE34-AB349B93E9BB]
    // </editor-fold>
    public void setElementosTrazas (ElementosTrazas val) {
        this.mElementosTrazas = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.7C9DD66D-4DC0-5887-389B-117EE09E04B1]
    // </editor-fold>
    public ArrayList<MatrizRastreabilidad> getMatrizRastreabilidad () {
        return mMatrizRastreabilidad;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.6040A478-FC52-7167-190D-17EF2AB616C0]
    // </editor-fold>
    public void setMatrizRastreabilidad (ArrayList<MatrizRastreabilidad> val) {
        this.mMatrizRastreabilidad = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.313A4D18-F214-AD72-9100-71BE38DC6D5A]
    // </editor-fold>
    public ArrayList<Organizacion> getOrganizacion () {
        return mOrganizacion;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.BDA4E365-49AA-6534-B99E-A491F2A2D444]
    // </editor-fold>
    public void setOrganizacion (ArrayList<Organizacion> val) {
        this.mOrganizacion = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.4F753CF5-12DF-58DA-83EB-6B4162867A06]
    // </editor-fold>
    public ArrayList<Participante> getParticipante () {
        return mParticipante;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.5DDDF6E1-52BC-1B46-BB44-B7C945B5EEA8]
    // </editor-fold>
    public void setParticipante (ArrayList<Participante> val) {
        this.mParticipante = val;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.1E82EF5F-8F90-7BAD-8317-4A6B203084EB]
    // </editor-fold>
    public ArrayList<Seccion> getSeccion () {
        return mSeccion;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker ">
    // #[regen=yes,regenBody=yes,id=DCE.767B2FF7-D6F3-4EFE-8CA9-7AE1C2085357]
    // </editor-fold>
    public void setSeccion (ArrayList<Seccion> val) {
        this.mSeccion = val;
    }



    // Devuelve un ArrayList con los Casos de uso del documento
    public ArrayList<CasoUso> getCasosUso () {
        return this.getElementosTrazas().getCasoUso();
    }
    // Añade un nuevo Caso de uso al documento
    public void addCasoUso (CasoUso casoUso) {
        this.getElementosTrazas().getCasoUso().add(casoUso);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Caso de uso del documento
    public void removeCasoUso (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();

        // Busco el Caso de uso y lo elimino
        while (!encontrado && i < casosUso.size()) {
            if (casosUso.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getCasoUso().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Caso de uso del documento
    public void modifyCasoUso (CasoUso casoUso) {
        boolean encontrado = false;
        int i = 0;
        String ident = casoUso.getIdentificacion();
        ArrayList<CasoUso> casosUso = this.getCasosUso();

        // Busco y modifico
        while (!encontrado && i < casosUso.size()) {
            if (casosUso.get(i).getIdentificacion().equals(ident)) {

                casosUso.get(i).setIdentificacion(casoUso.getIdentificacion());
                casosUso.get(i).setNombre(casoUso.getNombre());
                casosUso.get(i).setVersion(casoUso.getVersion());
                casosUso.get(i).setFecha(casoUso.getFecha());
                casosUso.get(i).setAutores(casoUso.getAutores());
                casosUso.get(i).setFuentes(casoUso.getFuentes());
                casosUso.get(i).setEsAbstracto(casoUso.getEsAbstracto());
                casosUso.get(i).setEventoActivacion(casoUso.getEventoActivacion());
                casosUso.get(i).setVeces(casoUso.getVeces());
                casosUso.get(i).setUnidad(casoUso.getUnidad());
                casosUso.get(i).setPrecondicion(casoUso.getPrecondicion());
                casosUso.get(i).setPostcondicion(casoUso.getPostcondicion());
                casosUso.get(i).setImportancia(casoUso.getImportancia());
                casosUso.get(i).setUrgencia(casoUso.getUrgencia());
                casosUso.get(i).setEstadoDesarrollo(casoUso.getEstadoDesarrollo());
                casosUso.get(i).setEstabilidad(casoUso.getEstabilidad());
                casosUso.get(i).setDestino(casoUso.getDestino());
                casosUso.get(i).setOrigen(casoUso.getOrigen());
                casosUso.get(i).setComentario(casoUso.getComentario());
                casosUso.get(i).setCasoUso(casoUso.getCasoUso());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Paso a un Caso de uso
    public void addCasoUso_Paso (String identCasoUsoPadre, Paso nuevoPaso) {
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();

        // Busco el Caso de uso que le corresponde y le añado el nuevo Paso
        for (int i = 0; i < casosUso.size(); i++) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre))
                casosUso.get(i).getPaso().add(nuevoPaso);
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Paso de un Caso de uso
    public void removeCasoUso_Paso (String identCasoUsoPadre, String identPaso) {
        boolean encontCasoUso = false, encontPaso = false;
        int i = 0, j = 0;
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();

        // Busco el Caso de uso, busco su Paso y lo elimino
        while (!encontCasoUso && i < casosUso.size()) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre)) {
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                while (!encontPaso && j < pasos.size()) {
                    if (pasos.get(j).getIdentificacion().equals(identPaso)) {
                        this.getElementosTrazas().getCasoUso().get(i).getPaso().remove(j);
                        encontPaso = true;
                    }
                    j++;
                }
                encontCasoUso = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Excepción a un Paso de un Caso de uso
    public void addCasoUso_Excepcion (String identCasoUsoPadre, String identPasoPadre, Excepcion nuevaExcepcion) {
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();

        // Busco el Caso de uso que le corresponde y le añado el nuevo Paso
        for (int i = 0; i < casosUso.size(); i++) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre)) {
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                for (int j = 0; j < pasos.size(); j++) {
                    if (pasos.get(j).getIdentificacion().equals(identPasoPadre))
                        pasos.get(j).getExcepcion().add(nuevaExcepcion);
                }
            }
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina una Excepción de un Paso de un Caso de uso
    public void removeCasoUso_Excepcion (String identCasoUsoPadre, String identPasoPadre, String identExcepcion) {
        boolean encontCasoUso = false, encontPaso = false, encontExcepcion = false;
        int i = 0, j = 0, k = 0;
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();

        // Busco el Caso de uso, busco su Paso y lo elimino
        while (!encontCasoUso && i < casosUso.size()) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre)) {
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                while (!encontPaso && j < pasos.size()) {
                    if (pasos.get(j).getIdentificacion().equals(identPasoPadre)) {
                        ArrayList<Excepcion> excepciones = pasos.get(j).getExcepcion();
                        while (!encontExcepcion && k < excepciones.size()) {
                            if (excepciones.get(k).getIdentificacion().equals(identExcepcion)) {
                                this.getElementosTrazas().getCasoUso().get(i).getPaso().get(j).getExcepcion().remove(k);
                                encontExcepcion = true;
                            }
                        }
                        encontPaso = true;
                    }
                    j++;
                }
                encontCasoUso = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos Funcionales del documento
    public ArrayList<RequisitoFuncional> getRequisitosFuncionales () {
        return this.getElementosTrazas().getRequisitoFuncional();
    }
    // Añade un nuevo Requisito Funcional
    public void addReqFuncional (RequisitoFuncional reqFuncional) {
        this.getElementosTrazas().getRequisitoFuncional().add(reqFuncional);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito Funcional
    public void removeReqFuncional (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoFuncional> reqFuncionales = this.getElementosTrazas().getRequisitoFuncional();

        // Busco el Requisito Funcional y lo elimino
        while (!encontrado && i < reqFuncionales.size()) {
            if (reqFuncionales.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoFuncional().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqFuncional del documento
    public void modifyReqFuncional (RequisitoFuncional requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoFuncional> requisitos = this.getRequisitosFuncionales();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setTexto(requisito.getTexto());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos No Funcionales del documento
    public ArrayList<RequisitoNoFuncional> getRequisitosNoFuncionales () {
        return this.getElementosTrazas().getRequisitoNoFuncional();
    }
    // Añade un nuevo Requisito No Funcional
    public void addReqNoFuncional (RequisitoNoFuncional reqNoFuncional) {
        this.getElementosTrazas().getRequisitoNoFuncional().add(reqNoFuncional);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito No Funcional
    public void removeReqNoFuncional (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoNoFuncional> reqNoFuncionales = this.getElementosTrazas().getRequisitoNoFuncional();

        // Busco el Requisito No Funcional y lo elimino
        while (!encontrado && i < reqNoFuncionales.size()) {
            if (reqNoFuncionales.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoNoFuncional().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqNoFuncional del documento
    public void modifyReqNoFuncional (RequisitoNoFuncional requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoNoFuncional> requisitos = this.getRequisitosNoFuncionales();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setTexto(requisito.getTexto());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos de Información del documento
    public ArrayList<RequisitoInformacion> getRequisitosInformacion () {
        return this.getElementosTrazas().getRequisitoInformacion();
    }
    // Añade un nuevo Requisito de Informacion
    public void addReqInformacion (RequisitoInformacion reqInformacion) {
        this.getElementosTrazas().getRequisitoInformacion().add(reqInformacion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito de Informacion
    public void removeReqInformacion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoInformacion> reqsInformacion = this.getElementosTrazas().getRequisitoInformacion();

        // Busco el Requisito Funcional y lo elimino
        while (!encontrado && i < reqsInformacion.size()) {
            if (reqsInformacion.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoInformacion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqInformacion del documento
    public void modifyReqInformacion (RequisitoInformacion requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoInformacion> requisitos = this.getRequisitosInformacion();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setConceptoRelevante(requisito.getConceptoRelevante());
                requisitos.get(i).setValorMaxVida(requisito.getValorMaxVida());
                requisitos.get(i).setUnidadTiempoMaxVida(requisito.getUnidadTiempoMaxVida());
                requisitos.get(i).setValorMedioVida(requisito.getValorMedioVida());
                requisitos.get(i).setUnidadTiempoMedioVida(requisito.getUnidadTiempoMedioVida());
                requisitos.get(i).setOcurrenciasMaxima(requisito.getOcurrenciasMaxima());
                requisitos.get(i).setOcurrenciasMedia(requisito.getOcurrenciasMedia());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Requisitos de Restricción del documento
    public ArrayList<RequisitoRestriccion> getRequisitosRestriccion () {
        return this.getElementosTrazas().getRequisitoRestriccion();
    }
    // Añade un nuevo Requisito de Restriccion
    public void addReqRestriccion (RequisitoRestriccion reqRestriccion) {
        this.getElementosTrazas().getRequisitoRestriccion().add(reqRestriccion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Requisito de Restriccion
    public void removeReqRestriccion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<RequisitoRestriccion> reqsRestriccion = this.getElementosTrazas().getRequisitoRestriccion();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < reqsRestriccion.size()) {
            if (reqsRestriccion.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getRequisitoRestriccion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un ReqRestriccion del documento
    public void modifyReqRestriccion (RequisitoRestriccion requisito) {
        boolean encontrado = false;
        int i = 0;
        String ident = requisito.getIdentificacion();
        ArrayList<RequisitoRestriccion> requisitos = this.getRequisitosRestriccion();

        // Busco y modifico
        while (!encontrado && i < requisitos.size()) {
            if (requisitos.get(i).getIdentificacion().equals(ident)) {

                requisitos.get(i).setIdentificacion(requisito.getIdentificacion());
                requisitos.get(i).setNombre(requisito.getNombre());
                requisitos.get(i).setVersion(requisito.getVersion());
                requisitos.get(i).setFecha(requisito.getFecha());
                requisitos.get(i).setAutores(requisito.getAutores());
                requisitos.get(i).setFuentes(requisito.getFuentes());
                requisitos.get(i).setDescripcion(requisito.getDescripcion());
                requisitos.get(i).setImportancia(requisito.getImportancia());
                requisitos.get(i).setUrgencia(requisito.getUrgencia());
                requisitos.get(i).setEstadoDesarrollo(requisito.getEstadoDesarrollo());
                requisitos.get(i).setEstabilidad(requisito.getEstabilidad());
                requisitos.get(i).setDestino(requisito.getDestino());
                requisitos.get(i).setOrigen(requisito.getOrigen());
                requisitos.get(i).setComentario(requisito.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Participante al documento
    public void addParticipante(Participante participante) {
        this.getParticipante().add(participante);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Participante del documento
    public void removeParticipante (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Participante> participante = this.getParticipante();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < participante.size()) {
            if (participante.get(i).getIdentificacion().equals(identificador)) {
                this.getParticipante().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Participante del documento
    public void modifyParticipante (Participante participante) {
        boolean encontrado = false;
        int i = 0;
        String ident = participante.getIdentificacion();
        ArrayList<Participante> participantes = this.getParticipante();

        // Busco y modifico
        while (!encontrado && i < participantes.size()) {
            if (participantes.get(i).getIdentificacion().equals(ident)) {

                participantes.get(i).setIdentificacion(participante.getIdentificacion());
                participantes.get(i).setNombre(participante.getNombre());
                participantes.get(i).setVersion(participante.getVersion());
                participantes.get(i).setFecha(participante.getFecha());
                participantes.get(i).setAutores(participante.getAutores());
                participantes.get(i).setFuentes(participante.getFuentes());
                participantes.get(i).setRol(participante.getRol());
                participantes.get(i).setOrganizacion(participante.getOrganizacion());
                participantes.get(i).setEsCliente(participante.getEsCliente());
                participantes.get(i).setEsDesarrollador(participante.getEsDesarrollador());
                participantes.get(i).setEsUsuario(participante.getEsUsuario());
                participantes.get(i).setComentario(participante.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    
    // Devuelve un ArrayList con las Reuniones del documento
    public ArrayList<Reunion> getReuniones(){
        return this.getElementosTrazas().getReunion();
    }
    // Añade una nueva Reunion al documento
    public void addReunion(Reunion reunion) {
        this.getElementosTrazas().getReunion().add(reunion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Reunion del documento
    public void removeReunion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Reunion> reunion = this.getReuniones();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < reunion.size()) {
            if (reunion.get(i).getIdentificacion().equals(identificador)) {
                this.getReuniones().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Reunion del documento
    public void modifyReunion (Reunion reunion) {
        boolean encontrado = false;
        int i = 0;
        String ident = reunion.getIdentificacion();
        ArrayList<Reunion> reuniones = this.getReuniones();

        // Busco y modifico
        while (!encontrado && i < reuniones.size()) {
            if (reuniones.get(i).getIdentificacion().equals(ident)) {

                reuniones.get(i).setIdentificacion(reunion.getIdentificacion());
                reuniones.get(i).setNombre(reunion.getNombre());
                reuniones.get(i).setVersion(reunion.getVersion());
                reuniones.get(i).setFecha(reunion.getFecha());
                reuniones.get(i).setAutores(reunion.getAutores());
                reuniones.get(i).setFuentes(reunion.getFuentes());
                reuniones.get(i).setLugar(reunion.getLugar());
                reuniones.get(i).setFechaReunion(reunion.getFechaReunion());
                reuniones.get(i).setHora(reunion.getHora());
                reuniones.get(i).setAsistentes(reunion.getAsistentes());
                reuniones.get(i).setResultados(reunion.getResultados());
                reuniones.get(i).setDestino(reunion.getDestino());
                reuniones.get(i).setOrigen(reunion.getOrigen());
                reuniones.get(i).setComentario(reunion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Objetivos del documento
    public ArrayList<Objetivo> getObjetivos(){
        return this.getElementosTrazas().getObjetivo();
    }
    // Añade un nuevo Objetivo al documento
    public void addObjetivo(Objetivo objetivo) {
        this.getElementosTrazas().getObjetivo().add(objetivo);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Objetivo del documento
    public void removeObjetivo (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Objetivo> objetivo = this.getObjetivos();

        // Busco el Requisito Restriccion y lo elimino
        while (!encontrado && i < objetivo.size()) {
            if (objetivo.get(i).getIdentificacion().equals(identificador)) {
                this.getObjetivos().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Objetivo del documento
    public void modifyObjetivo (Objetivo objetivo) {
        boolean encontrado = false;
        int i = 0;
        String ident = objetivo.getIdentificacion();
        ArrayList<Objetivo> objetivos = this.getObjetivos();

        // Busco y modifico
        while (!encontrado && i < objetivos.size()) {
            if (objetivos.get(i).getIdentificacion().equals(ident)) {

                objetivos.get(i).setIdentificacion(objetivo.getIdentificacion());
                objetivos.get(i).setNombre(objetivo.getNombre());
                objetivos.get(i).setVersion(objetivo.getVersion());
                objetivos.get(i).setFecha(objetivo.getFecha());
                objetivos.get(i).setAutores(objetivo.getAutores());
                objetivos.get(i).setFuentes(objetivo.getFuentes());
                objetivos.get(i).setTexto(objetivo.getTexto());
                objetivos.get(i).setImportancia(objetivo.getImportancia());
                objetivos.get(i).setUrgencia(objetivo.getUrgencia());
                objetivos.get(i).setEstadoDesarrollo(objetivo.getEstadoDesarrollo());
                objetivos.get(i).setEstabilidad(objetivo.getEstabilidad());
                objetivos.get(i).setDestino(objetivo.getDestino());
                objetivos.get(i).setOrigen(objetivo.getOrigen());
                objetivos.get(i).setComentario(objetivo.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Actores del documento
    public ArrayList<Actor> getActores () {
        return this.getElementosTrazas().getActor();
    }
    // Añade un nuevo Actor
    public void addActor (Actor actor) {
        this.getElementosTrazas().getActor().add(actor);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Actor
    public void removeActor (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Actor> actor = this.getElementosTrazas().getActor();

        // Busco el Actor y lo elimino
        while (!encontrado && actor.size() < i) {
            if (actor.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getActor().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Actor del documento
    public void modifyActor (Actor actor) {
        boolean encontrado = false;
        int i = 0;
        String ident = actor.getIdentificacion();
        ArrayList<Actor> actores = this.getActores();

        // Busco y modifico
        while (!encontrado && i < actores.size()) {
            if (actores.get(i).getIdentificacion().equals(ident)) {

                actores.get(i).setIdentificacion(actor.getIdentificacion());
                actores.get(i).setNombre(actor.getNombre());
                actores.get(i).setVersion(actor.getVersion());
                actores.get(i).setFecha(actor.getFecha());
                actores.get(i).setAutores(actor.getAutores());
                actores.get(i).setFuentes(actor.getFuentes());
                actores.get(i).setTexto(actor.getTexto());
                actores.get(i).setDestino(actor.getDestino());
                actores.get(i).setOrigen(actor.getOrigen());
                actores.get(i).setComentario(actor.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Organizacion al documento
    public void addOrganizacion(Organizacion organizacion) {
        this.getOrganizacion().add(organizacion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Organización del documento
    public void removeOrganizacion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Organizacion> organizacion = this.getOrganizacion();

        // Busco la Organizacion y la elimino
        while (!encontrado && i < organizacion.size()) {
            if (organizacion.get(i).getIdentificacion().equals(identificador)) {
                this.getOrganizacion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Organización del documento
    public void modifyOrganizacion (Organizacion organizacion) {
        boolean encontrado = false;
        int i = 0;
        String ident = organizacion.getIdentificacion();
        ArrayList<Organizacion> organizaciones = this.getOrganizacion();

        // Busco la Organizacion y la modifico
        while (!encontrado && i < organizaciones.size()) {
            if (organizaciones.get(i).getIdentificacion().equals(ident)) {
                organizaciones.get(i).setIdentificacion(organizacion.getIdentificacion());
                organizaciones.get(i).setNombre(organizacion.getNombre());
                organizaciones.get(i).setVersion(organizacion.getVersion());
                organizaciones.get(i).setFecha(organizacion.getFecha());
                organizaciones.get(i).setAutores(organizacion.getAutores());
                organizaciones.get(i).setFuentes(organizacion.getFuentes());
                organizaciones.get(i).setDireccion(organizacion.getDireccion());
                organizaciones.get(i).setTelefono(organizacion.getTelefono());
                organizaciones.get(i).setFax(organizacion.getFax());
                organizaciones.get(i).setComentario(organizacion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }


    // Añade una nueva Sección al documento
    public void addSeccion(Seccion seccion) {
        this.getSeccion().add(seccion);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina una Sección del documento
    public void removeSeccion (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Seccion> seccion = this.getSeccion();

        // Busco la Organizacion y la elimino
        while (!encontrado && i < seccion.size()) {
            if (seccion.get(i).getIdentificacion().equals(identificador)) {
                this.getSeccion().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica una Seccion del documento
    public void modifySeccion (Seccion seccion) {
        boolean encontrado = false;
        int i = 0;
        String ident = seccion.getIdentificacion();
        ArrayList<Seccion> secciones = this.getSeccion();

        // Busco y modifico
        while (!encontrado && i < secciones.size()) {
            if (secciones.get(i).getIdentificacion().equals(ident)) {

                secciones.get(i).setIdentificacion(seccion.getIdentificacion());
                secciones.get(i).setNombre(seccion.getNombre());
                secciones.get(i).setNumeracion(seccion.getNumeracion());
                secciones.get(i).setVersion(seccion.getVersion());
                secciones.get(i).setFecha(seccion.getFecha());
                secciones.get(i).setAutores(seccion.getAutores());
                secciones.get(i).setFuentes(seccion.getFuentes());
                secciones.get(i).setOrdenar(seccion.getOrdenar());
                secciones.get(i).setComentario(seccion.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade un nuevo Apéndice al documento
    public void addApendice(Apendice apendice) {
        this.getApendice().add(apendice);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    //    Elimina un Apéndice del documento
    public void removeApendice (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Apendice> apendice = this.getApendice();

        // Busco la Organizacion y la elimino
        while (!encontrado && i < apendice.size()) {
            if (apendice.get(i).getIdentificacion().equals(identificador)) {
                this.getApendice().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica un Apendice del documento
    public void modifyApendice (Apendice apendice) {
        boolean encontrado = false;
        int i = 0;
        String ident = apendice.getIdentificacion();
        ArrayList<Apendice> apendices = this.getApendice();

        // Busco y modifico
        while (!encontrado && i < apendices.size()) {
            if (apendices.get(i).getIdentificacion().equals(ident)) {

                apendices.get(i).setIdentificacion(apendice.getIdentificacion());
                apendices.get(i).setNombre(apendice.getNombre());
                apendices.get(i).setNumeracion(apendice.getNumeracion());
                apendices.get(i).setVersion(apendice.getVersion());
                apendices.get(i).setFecha(apendice.getFecha());
                apendices.get(i).setAutores(apendice.getAutores());
                apendices.get(i).setFuentes(apendice.getFuentes());
                apendices.get(i).setOrdenar(apendice.getOrdenar());
                apendices.get(i).setComentario(apendice.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Devuelve un ArrayList con los Parrafos del documento
    public ArrayList<Parrafo> getParrafos () {
        return this.getElementosTrazas().getParrafo();
    }
    // Añade un nuevo Parrafo
    public void addParrafo (Parrafo parrafo) {
        this.getElementosTrazas().getParrafo().add(parrafo);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Parrafo
    public void removeParrafo (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Parrafo> parrafo = this.getElementosTrazas().getParrafo();

        // Busco el Parrafo y lo elimino
        while (!encontrado && i < parrafo.size()) {
            if (parrafo.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getParrafo().remove(i);
                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Modifica un Parrafo del documento
    public void modifyParrafo (Parrafo parrafo) {
        boolean encontrado = false;
        int i = 0;
        String ident = parrafo.getIdentificacion();
        ArrayList<Parrafo> parrafos = this.getParrafos();

        // Busco y modifico
        while (!encontrado && i < parrafos.size()) {
            if (parrafos.get(i).getIdentificacion().equals(ident)) {

                parrafos.get(i).setIdentificacion(parrafo.getIdentificacion());
                parrafos.get(i).setNombre(parrafo.getNombre());
                parrafos.get(i).setVersion(parrafo.getVersion());
                parrafos.get(i).setFecha(parrafo.getFecha());
                parrafos.get(i).setAutores(parrafo.getAutores());
                parrafos.get(i).setFuentes(parrafo.getFuentes());
                parrafos.get(i).setTexto(parrafo.getTexto());
                parrafos.get(i).setDestino(parrafo.getDestino());
                parrafos.get(i).setOrigen(parrafo.getOrigen());
                parrafos.get(i).setComentario(parrafo.getComentario());
                parrafos.get(i).setesElementoGlosario(parrafo.getesElementoGlosario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

     // Devuelve un ArrayList con los Ficheros Graficos del documento
    public ArrayList<Imagen> getImagenes () {
        return this.getElementosTrazas().getImagen();
    }
    // Añade un nuevo Fichero Grafico
    public void addImagen (Imagen imagen) {
        this.getElementosTrazas().getImagen().add(imagen);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina un Fichero Grafico
    public void removeImagen (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<Imagen> imagen = this.getElementosTrazas().getImagen();

        // Busco el Fichero Grafico y lo elimino
        while (!encontrado && i < imagen.size()) {
            if (imagen.get(i).getIdentificacion().equals(identificador)) {
                this.getElementosTrazas().getImagen().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica una Imagen del documento
    public void modifyImagen (Imagen imagen) {
        boolean encontrado = false;
        int i = 0;
        String ident = imagen.getIdentificacion();
        ArrayList<Imagen> imagenes = this.getImagenes();

        // Busco y modifico
        while (!encontrado && i < imagenes.size()) {
            if (imagenes.get(i).getIdentificacion().equals(ident)) {

                imagenes.get(i).setIdentificacion(imagen.getIdentificacion());
                imagenes.get(i).setNombre(imagen.getNombre());
                imagenes.get(i).setVersion(imagen.getVersion());
                imagenes.get(i).setFecha(imagen.getFecha());
                imagenes.get(i).setAutores(imagen.getAutores());
                imagenes.get(i).setFuentes(imagen.getFuentes());
                imagenes.get(i).setRutaImagen(imagen.getRutaImagen());
                imagenes.get(i).setDestino(imagen.getDestino());
                imagenes.get(i).setOrigen(imagen.getOrigen());
                imagenes.get(i).setComentario(imagen.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }

    // Añade una nueva Matriz de rastreabilidad
    public void addMatrizRastreabilidad (MatrizRastreabilidad matrizRastreabilidad) {
        this.getMatrizRastreabilidad().add(matrizRastreabilidad);

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }
    // Elimina una Matriz de rastreabilidad
    public void removeMatrizRastreabilidad (String identificador) {
        boolean encontrado = false;
        int i = 0;
        ArrayList<MatrizRastreabilidad> matrizRastreabilidad = this.getMatrizRastreabilidad();

        // Busco la Matriz de rastreabilidad y lo elimino
        while (!encontrado && i < matrizRastreabilidad.size()) {
            if (matrizRastreabilidad.get(i).getIdentificacion().equals(identificador)) {
                this.getMatrizRastreabilidad().remove(i);
                encontrado = true;
            }
            i++;
        }
    }
    // Modifica una MatrizRastreabilidad del documento
    public void modifyMatrizRastreabilidad (MatrizRastreabilidad matriz) {
        boolean encontrado = false;
        int i = 0;
        String ident = matriz.getIdentificacion();
        ArrayList<MatrizRastreabilidad> matrices = this.getMatrizRastreabilidad();

        // Busco y modifico
        while (!encontrado && i < matrices.size()) {
            if (matrices.get(i).getIdentificacion().equals(ident)) {

                matrices.get(i).setIdentificacion(matriz.getIdentificacion());
                matrices.get(i).setNombre(matriz.getNombre());
                matrices.get(i).setVersion(matriz.getVersion());
                matrices.get(i).setFecha(matriz.getFecha());
                matrices.get(i).setAutores(matriz.getAutores());
                matrices.get(i).setFuentes(matriz.getFuentes());
                matrices.get(i).setMatrizFila(matriz.getMatrizFila());
                matrices.get(i).setMatrizColumna(matriz.getMatrizColumna());
                matrices.get(i).setComentario(matriz.getComentario());

                encontrado = true;
            }
            i++;
        }

        // Notificar de los cambios en el Observer
        this.setChanged();
        this.notifyObservers();
    }





    // Devuelve el siguiente identificador numérico de un caso de uso (para su creación)
    public String getNuevoIdentificadorCasoUso () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getCasoUso().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getCasoUso().get(size-1).getIdentificacion();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(3)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un paso de un caso de uso (para su creación)
    public String getNuevoIdentificadorPaso (String identCasoUsoPadre) {
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();
        String nuevoIdentificador = "";
        int size = 0;

        for (int i = 0; i < casosUso.size(); i++) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre)) {
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                size = pasos.size();
                if (size != 0)
                    nuevoIdentificador = pasos.get(size-1).getIdentificacion();
            }
        }

        if (size == 0)                                                          // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {                                                                  // Si hay elementos...
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de una excepción de un paso de un caso de uso (para su creación)
    public String getNuevoIdentificadorExcepcion (String identCasoUsoPadre, String identPasoPadre) {
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();
        String nuevoIdentificador = "";
        int size = 0;

        for (int i = 0; i < casosUso.size(); i++) {
            if (casosUso.get(i).getIdentificacion().equals(identCasoUsoPadre)) {
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                for (int j = 0; j < pasos.size(); j++) {
                    if (pasos.get(j).getIdentificacion().equals(identPasoPadre)) {
                        ArrayList<Excepcion> excepciones = pasos.get(j).getExcepcion();
                        size = excepciones.size();
                        if (size != 0)
                            nuevoIdentificador = excepciones.get(size-1).getIdentificacion();
                    }
                }
            }
        }

        if (size == 0)                                                          // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {                                                                  // Si hay elementos...
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorReqFuncional () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoFuncional().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoFuncional().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito no funcional
    public String getNuevoIdentificadorReqNoFuncional () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoNoFuncional().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoNoFuncional().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito de información
    public String getNuevoIdentificadorReqInformacion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoInformacion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoInformacion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito de restricción
    public String getNuevoIdentificadorReqRestriccion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getRequisitoRestriccion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getRequisitoRestriccion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }


// Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorReunion () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getReunion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getReunion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }
    // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorObjetivo () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getObjetivo().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getObjetivo().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

        // Devuelve el siguiente identificador numérico de un requisito funcional
    public String getNuevoIdentificadorParticipante () {
        String nuevoIdentificador = "";
        int size = this.getParticipante().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getParticipante().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Actor
    public String getNuevoIdentificadorActor () {
        String nuevoIdentificador = "";
        int size = this.getElementosTrazas().getActor().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getElementosTrazas().getActor().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Organización
    public String getNuevoIdentificadorOrganizacion () {
        String nuevoIdentificador = "";

        int size = this.getOrganizacion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getOrganizacion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Sección
    public String getNuevoIdentificadorSeccion () {
        String nuevoIdentificador = "";

        int size = this.getSeccion().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";
        else {
            nuevoIdentificador = this.getSeccion().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Apéndice
    public String getNuevoIdentificadorApendice () {
        String nuevoIdentificador = "";

        int size = this.getApendice().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getApendice().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de un Apéndice
    public String getNuevoIdentificadorParrafo () {
        String nuevoIdentificador = "";

        int size = this.getElementosTrazas().getParrafo().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getElementosTrazas().getParrafo().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

        // Devuelve el siguiente identificador numérico de un Fichero Grafico
    public String getNuevoIdentificadorFicheroGrafico () {
        String nuevoIdentificador = "";

        int size = this.getElementosTrazas().getImagen().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getElementosTrazas().getImagen().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }

    // Devuelve el siguiente identificador numérico de una Matriz de Rastreabilidad
    public String getNuevoIdentificadorMatrizRastreabilidad () {
        String nuevoIdentificador = "";

        int size = this.getMatrizRastreabilidad().size();

        if (size == 0)                  // Si no hay elementos...
            nuevoIdentificador = "0001";

        else {
            nuevoIdentificador = this.getMatrizRastreabilidad().get(size-1).getIdentificacion();
            int sizeIdent = nuevoIdentificador.length();
            int identificadorInt = Integer.valueOf(nuevoIdentificador.substring(sizeIdent-4, sizeIdent)) + 1;

            if (identificadorInt < 10)
                nuevoIdentificador = "000" + Integer.toString(identificadorInt);
            else if (identificadorInt < 100)
                nuevoIdentificador = "00" + Integer.toString(identificadorInt);
            else if (identificadorInt < 1000)
                nuevoIdentificador = "0" + Integer.toString(identificadorInt);
            else if (identificadorInt < 10000)
                nuevoIdentificador = Integer.toString(identificadorInt);
        }

        return nuevoIdentificador;
    }




    


    
    // Crea el fichero XML del Documento de Requisitos
    public void toXML(){
       
        ArrayList<RequisitoInformacion> reqInformacion = this.getElementosTrazas().getRequisitoInformacion();
        ArrayList<RequisitoRestriccion> reqRestriccion = this.getElementosTrazas().getRequisitoRestriccion();
        ArrayList<RequisitoFuncional> reqFuncional = this.getElementosTrazas().getRequisitoFuncional();
        ArrayList<RequisitoNoFuncional> reqNoFuncional = this.getElementosTrazas().getRequisitoNoFuncional();
        ArrayList<CasoUso> casosUso = this.getElementosTrazas().getCasoUso();
        ArrayList<Seccion> seccion = this.getSeccion();
        ArrayList<Apendice> apendice = this.getApendice();
        ArrayList<Parrafo> parrafo = this.getElementosTrazas().getParrafo();
//        ArrayList<ElementoGlosario> glosario = this.getElementosTrazas().getElementoGlosario();
        ArrayList<Imagen> imagen = this.getElementosTrazas().getImagen();
        ArrayList<Organizacion> organizacion = this.getOrganizacion();
        ArrayList<Participante> participante = this.getParticipante();
        ArrayList<Reunion> reunion = this.getElementosTrazas().getReunion();
        ArrayList<Objetivo> objetivo = this.getElementosTrazas().getObjetivo();
        ArrayList<Actor> actor = this.getElementosTrazas().getActor();
        ArrayList<MatrizRastreabilidad> matrizRastreabilidad = this.getMatrizRastreabilidad();

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try{
            DocumentBuilder builder = factory.newDocumentBuilder();
            DOMImplementation implementation = builder.getDOMImplementation();

            Document document = implementation.createDocument(null, "xml", null);

            Element raiz = document.createElement("Documento");                 // Elemento raiz
            document.setXmlVersion("1.0");                                      // Versión de nuestro XML
            document.getDocumentElement().appendChild(raiz);                    // Pegamos la raiz al documento
            



            
//--> Inicio Seccion
            //Recorrer el arraylist de SECCION y creo los arboles.
            for (int i = 0; i < seccion.size(); i++) {
                Element elemSeccion = document.createElement("Seccion"); //creamos un nuevo elemento

                Element elemIdentificacionS = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionS = document.createTextNode(seccion.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionS.appendChild(textIdentificacionS);
                elemSeccion.appendChild(elemIdentificacionS);

                Element elemNombreS = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreS = document.createTextNode(seccion.get(i).getNombre()); //Ingresamos la info
                elemNombreS.appendChild(textNombreS);
                elemSeccion.appendChild(elemNombreS);
                
                Element elemNumeracionS = document.createElement("numeracion"); //creamos un nuevo elemento
                Text textNumeracionS = document.createTextNode(seccion.get(i).getNumeracion()); //Ingresamos la info
                elemNumeracionS.appendChild(textNumeracionS);
                elemSeccion.appendChild(elemNumeracionS);

                Element elemVersionS = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionS = document.createTextNode(seccion.get(i).getVersion()); //Ingresamos la info
                elemVersionS.appendChild(textVersionS);
                elemSeccion.appendChild(elemVersionS);

                Element elemFechaS = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaS = formatearFecha(seccion.get(i).getFecha());
                Text textFechaS = document.createTextNode(cadenaFechaS); //Ingresamos la info
                elemFechaS.appendChild(textFechaS);
                elemSeccion.appendChild(elemFechaS);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresSeccion = seccion.get(i).getAutores();
                for ( int j = 0; j < autoresSeccion.size(); j++){
                    Element elemAutoresSeccion = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresSeccion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresSeccion.appendChild(elemIdentificacionAutor);
                    
                    elemSeccion.appendChild(elemAutoresSeccion);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesSeccion = seccion.get(i).getFuentes();
                for ( int j = 0; j < fuentesSeccion.size(); j++){
                    Element elemFuentesSeccion = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesSeccion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesSeccion.appendChild(elemIdentificacionFuente);
                    
                    elemSeccion.appendChild(elemFuentesSeccion);
                }

                Element elemOrdenarS = document.createElement("ordenar"); //creamos un nuevo elemento
                Text textOrdenarS = document.createTextNode(seccion.get(i).getOrdenar().toString()); //Ingresamos la info
                elemOrdenarS.appendChild(textOrdenarS);
                elemSeccion.appendChild(elemOrdenarS);

                Element elemComentarioS = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioS = document.createTextNode(seccion.get(i).getComentario());//Ingresamos la info
                elemComentarioS.appendChild(textComentarioS);
                elemSeccion.appendChild(elemComentarioS);

                raiz.appendChild(elemSeccion); //pegamos el elemento hijo a la raiz
            }
//Fin Seccion


            
//--> Inicio Apendice
            //Recorrer el arraylist de APENDICE y creo los arboles.
            for (int i = 0; i < apendice.size(); i++) {
                Element elemApendice = document.createElement("Apendice"); //creamos un nuevo elemento

                Element elemIdentificacionApendice = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionApendice = document.createTextNode(apendice.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionApendice.appendChild(textIdentificacionApendice);
                elemApendice.appendChild(elemIdentificacionApendice);

                Element elemNombreApendice = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreApendice = document.createTextNode(apendice.get(i).getNombre()); //Ingresamos la info
                elemNombreApendice.appendChild(textNombreApendice);
                elemApendice.appendChild(elemNombreApendice);
                
                Element elemNumeracionApendice = document.createElement("numeracion"); //creamos un nuevo elemento
                Text textNumeracionApendice = document.createTextNode(apendice.get(i).getNumeracion()); //Ingresamos la info
                elemNumeracionApendice.appendChild(textNumeracionApendice);
                elemApendice.appendChild(elemNumeracionApendice);

                Element elemVersionApendice = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionApendice = document.createTextNode(apendice.get(i).getVersion()); //Ingresamos la info
                elemVersionApendice.appendChild(textVersionApendice);
                elemApendice.appendChild(elemVersionApendice);

                Element elemFechaApendice = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaApendice = formatearFecha(apendice.get(i).getFecha());
                Text textFechaApendice = document.createTextNode(cadenaFechaApendice); //Ingresamos la info
                elemFechaApendice.appendChild(textFechaApendice);
                elemApendice.appendChild(elemFechaApendice);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresApendice = apendice.get(i).getAutores();
                for ( int j = 0; j < autoresApendice.size(); j++){
                    Element elemAutoresApendice = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresApendice.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresApendice.appendChild(elemIdentificacionAutor);
                    
                    elemApendice.appendChild(elemAutoresApendice);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesApendice = apendice.get(i).getFuentes();
                for ( int j = 0; j < fuentesApendice.size(); j++){
                    Element elemFuentesApendice = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesApendice.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesApendice.appendChild(elemIdentificacionFuente);
                    
                    elemApendice.appendChild(elemFuentesApendice);
                }

                Element elemOrdenarApendice = document.createElement("ordenar"); //creamos un nuevo elemento
                Text textOrdenarApendice = document.createTextNode(apendice.get(i).getOrdenar().toString()); //Ingresamos la info
                elemOrdenarApendice.appendChild(textOrdenarApendice);
                elemApendice.appendChild(elemOrdenarApendice);

                Element elemComentarioApendice = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioApendice = document.createTextNode(apendice.get(i).getComentario()); //Ingresamos la info
                elemComentarioApendice.appendChild(textComentarioApendice);
                elemApendice.appendChild(elemComentarioApendice);

                raiz.appendChild(elemApendice); //pegamos el elemento hijo a la raiz
            }
//Fin Apendice



//--> Inicio Parrafo
            //Recorrer el arraylist de PARRAFO y creo los arboles.  Controlar que sea parrafo o elemento de glosario.
            for (int i = 0; i < parrafo.size(); i++) {
                Element elemParrafo;
                if (parrafo.get(i).getesElementoGlosario())
                    elemParrafo = document.createElement("ElementoGlosario"); //creamos un nuevo elemento
                else
                    elemParrafo = document.createElement("Parrafo"); //creamos un nuevo elemento
                
                Element elemIdentificacionParrafo = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionParrafo = document.createTextNode(parrafo.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionParrafo.appendChild(textIdentificacionParrafo);
                elemParrafo.appendChild(elemIdentificacionParrafo);

                Element elemNombreParrafo = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreParrafo = document.createTextNode(parrafo.get(i).getNombre()); //Ingresamos la info
                elemNombreParrafo.appendChild(textNombreParrafo);
                elemParrafo.appendChild(elemNombreParrafo);

                Element elemVersionParrafo = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionParrafo = document.createTextNode(parrafo.get(i).getVersion()); //Ingresamos la info
                elemVersionParrafo.appendChild(textVersionParrafo);
                elemParrafo.appendChild(elemVersionParrafo);

                Element elemFechaParrafo = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaParrafo = formatearFecha(parrafo.get(i).getFecha());
                Text textFechaParrafo = document.createTextNode(cadenaFechaParrafo); //Ingresamos la info
                elemFechaParrafo.appendChild(textFechaParrafo);
                elemParrafo.appendChild(elemFechaParrafo);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresParrafo = parrafo.get(i).getAutores();
                for ( int j = 0; j < autoresParrafo.size(); j++){
                    Element elemAutoresParrafo = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresParrafo.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresParrafo.appendChild(elemIdentificacionAutor);
                    
                    elemParrafo.appendChild(elemAutoresParrafo);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesParrafo = parrafo.get(i).getFuentes();
                for ( int j = 0; j < fuentesParrafo.size(); j++){
                    Element elemFuentesParrafo = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesParrafo.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesParrafo.appendChild(elemIdentificacionFuente);
                    
                    elemParrafo.appendChild(elemFuentesParrafo);
                }

                Element elemTextoParrafo = document.createElement("texto"); //creamos un nuevo elemento
                Text textTextoParrafo = document.createTextNode(parrafo.get(i).getTexto()); //Ingresamos la info
                elemTextoParrafo.appendChild(textTextoParrafo);
                elemParrafo.appendChild(elemTextoParrafo);

               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoParrafo = parrafo.get(i).getDestino();
                Element elemDestinoParrafo = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoParrafo.size(); j++){
                    Text textDestinoParrafo = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoParrafo.appendChild(textDestinoParrafo);
                    elemParrafo.appendChild(elemDestinoParrafo);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenParrafo = parrafo.get(i).getOrigen();
                Element elemOrigenParrafo = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenParrafo.size(); j++){
                    Text textOrigenParrafo = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenParrafo.appendChild(textOrigenParrafo);
                    elemParrafo.appendChild(elemOrigenParrafo);
                }

                Element elemComentarioParrafo = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioParrafo = document.createTextNode(parrafo.get(i).getComentario()); //Ingresamos la info
                elemComentarioParrafo.appendChild(textComentarioParrafo);
                elemParrafo.appendChild(elemComentarioParrafo);

                raiz.appendChild(elemParrafo); //pegamos el elemento hijo a la raiz
            }
//Fin Parrafo


//--> Inicio Imagen
            //Recorrer el arraylist de IMAGEN y creo los arboles.
            for (int i = 0; i < imagen.size(); i++) {
                Element elemImagen = document.createElement("Imagen"); //creamos un nuevo elemento

                Element elemIdentificacionImagen = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionImagen = document.createTextNode(imagen.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionImagen.appendChild(textIdentificacionImagen);
                elemImagen.appendChild(elemIdentificacionImagen);

                Element elemNombreImagen = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreImagen = document.createTextNode(imagen.get(i).getNombre()); //Ingresamos la info
                elemNombreImagen.appendChild(textNombreImagen);
                elemImagen.appendChild(elemNombreImagen);

                Element elemVersionImagen = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionImagen = document.createTextNode(imagen.get(i).getVersion()); //Ingresamos la info
                elemVersionImagen.appendChild(textVersionImagen);
                elemImagen.appendChild(elemVersionImagen);

                Element elemFechaImagen = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaImagen = formatearFecha(imagen.get(i).getFecha());
                Text textFechaImagen = document.createTextNode(cadenaFechaImagen); //Ingresamos la info
                elemFechaImagen.appendChild(textFechaImagen);
                elemImagen.appendChild(elemFechaImagen);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresImagen = imagen.get(i).getAutores();
                for ( int j = 0; j < autoresImagen.size(); j++){
                    Element elemAutoresImagen = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresImagen.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresImagen.appendChild(elemIdentificacionAutor);
                    
                    elemImagen.appendChild(elemAutoresImagen);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesParrafo = imagen.get(i).getFuentes();
                for ( int j = 0; j < fuentesParrafo.size(); j++){
                    Element elemFuentesImagen = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesParrafo.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesImagen.appendChild(elemIdentificacionFuente);
                    
                    elemImagen.appendChild(elemFuentesImagen);
                }

                Element elemRutaImagen = document.createElement("rutaImagen"); //creamos un nuevo elemento
                Text textRutaImagen = document.createTextNode(imagen.get(i).getRutaImagen()); //Ingresamos la info
                elemRutaImagen.appendChild(textRutaImagen);
                elemImagen.appendChild(elemRutaImagen);

               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoImagen = imagen.get(i).getDestino();
                Element elemDestinoImagen = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoImagen.size(); j++){
                    Text textDestinoImagen = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoImagen.appendChild(textDestinoImagen);
                    elemImagen.appendChild(elemDestinoImagen);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenImagen = imagen.get(i).getOrigen();
                Element elemOrigenImagen = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenImagen.size(); j++){
                    Text textOrigenImagen = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenImagen.appendChild(textOrigenImagen);
                    elemImagen.appendChild(elemOrigenImagen);
                }

                Element elemComentarioImagen = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioImagen = document.createTextNode(imagen.get(i).getComentario()); //Ingresamos la info
                elemComentarioImagen.appendChild(textComentarioImagen);
                elemImagen.appendChild(elemComentarioImagen);

                raiz.appendChild(elemImagen); //pegamos el elemento hijo a la raiz
            }
//Fin Imagen


            
//--> Inicio Organizacion
            //Recorrer el arraylist de ORGANIZACION y creo los arboles.
           for (int i = 0; i < organizacion.size(); i++) {
                Element elemOrganizacion = document.createElement("Organizacion"); //creamos un nuevo elemento

                Element elemIdentificacionOrganizacion = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionOrganizacion = document.createTextNode(organizacion.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionOrganizacion.appendChild(textIdentificacionOrganizacion);
                elemOrganizacion.appendChild(elemIdentificacionOrganizacion);

                Element elemNombreOrganizacion = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreOrganizacion = document.createTextNode(organizacion.get(i).getNombre()); //Ingresamos la info
                elemNombreOrganizacion.appendChild(textNombreOrganizacion);
                elemOrganizacion.appendChild(elemNombreOrganizacion);

                Element elemVersionOrganizacion = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionOrganizacion = document.createTextNode(organizacion.get(i).getVersion()); //Ingresamos la info
                elemVersionOrganizacion.appendChild(textVersionOrganizacion);
                elemOrganizacion.appendChild(elemVersionOrganizacion);

                Element elemFechaOrganizacion = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaOrganizacion = formatearFecha(organizacion.get(i).getFecha());
                Text textFechaOrganizacion = document.createTextNode(cadenaFechaOrganizacion); //Ingresamos la info
                elemFechaOrganizacion.appendChild(textFechaOrganizacion);
                elemOrganizacion.appendChild(elemFechaOrganizacion);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresOrganizacion = organizacion.get(i).getAutores();
                for ( int j = 0; j < autoresOrganizacion.size(); j++){
                    Element elemAutoresOrganizacion = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresOrganizacion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresOrganizacion.appendChild(elemIdentificacionAutor);
                    
                    elemOrganizacion.appendChild(elemAutoresOrganizacion);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesOrganizacion = organizacion.get(i).getFuentes();
                for ( int j = 0; j < fuentesOrganizacion.size(); j++){
                    Element elemFuentesOrganizacion = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesOrganizacion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesOrganizacion.appendChild(elemIdentificacionFuente);
                    
                    elemOrganizacion.appendChild(elemFuentesOrganizacion);
                }

                Element elemDireccionOrganizacion = document.createElement("direccion"); //creamos un nuevo elemento
                Text textDireccionOrganizacion = document.createTextNode(organizacion.get(i).getDireccion()); //Ingresamos la info
                elemDireccionOrganizacion.appendChild(textDireccionOrganizacion);
                elemOrganizacion.appendChild(elemDireccionOrganizacion);
                
                Element elemTelefonoOrganizacion = document.createElement("telefono"); //creamos un nuevo elemento
                Text textTelefonoOrganizacion = document.createTextNode(organizacion.get(i).getTelefono()); //Ingresamos la info
                elemTelefonoOrganizacion.appendChild(textTelefonoOrganizacion);
                elemOrganizacion.appendChild(elemTelefonoOrganizacion);

                Element elemFaxOrganizacion = document.createElement("fax"); //creamos un nuevo elemento
                Text textFaxOrganizacion = document.createTextNode(organizacion.get(i).getFax()); //Ingresamos la info
                elemFaxOrganizacion.appendChild(textFaxOrganizacion);
                elemOrganizacion.appendChild(elemFaxOrganizacion);
                
                Element elemComentarioOrganizacion = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioOrganizacion = document.createTextNode(organizacion.get(i).getComentario()); //Ingresamos la info
                elemComentarioOrganizacion.appendChild(textComentarioOrganizacion);
                elemOrganizacion.appendChild(elemComentarioOrganizacion);

                raiz.appendChild(elemOrganizacion); //pegamos el elemento hijo a la raiz
     }
//Fin Organizacion



//--> Inicio Participante
            //Recorrer el arraylist de PARTICIPANTE y creo los arboles.
            for (int i = 0; i < participante.size(); i++) {
                Element elemParticipante = document.createElement("Participante"); //creamos un nuevo elemento

                Element elemIdentificacionParticipante = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionParticipante = document.createTextNode(participante.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionParticipante.appendChild(textIdentificacionParticipante);
                elemParticipante.appendChild(elemIdentificacionParticipante);

                Element elemNombreParticipante = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreParticipante = document.createTextNode(participante.get(i).getNombre()); //Ingresamos la info
                elemNombreParticipante.appendChild(textNombreParticipante);
                elemParticipante.appendChild(elemNombreParticipante);

                Element elemVersionParticipante = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionParticipante = document.createTextNode(participante.get(i).getVersion()); //Ingresamos la info
                elemVersionParticipante.appendChild(textVersionParticipante);
                elemParticipante.appendChild(elemVersionParticipante);

                Element elemFechaParticipante = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaParticipante = formatearFecha(participante.get(i).getFecha());
                Text textFechaParticipante = document.createTextNode(cadenaFechaParticipante); //Ingresamos la info
                elemFechaParticipante.appendChild(textFechaParticipante);
                elemParticipante.appendChild(elemFechaParticipante);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresParticipante = participante.get(i).getAutores();
                for ( int j = 0; j < autoresParticipante.size(); j++){
                    Element elemAutoresParticipante = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresParticipante.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresParticipante.appendChild(elemIdentificacionAutor);
                    
                    elemParticipante.appendChild(elemAutoresParticipante);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesParticipante = participante.get(i).getFuentes();
                for ( int j = 0; j < fuentesParticipante.size(); j++){
                    Element elemFuentesParticipante = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesParticipante.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesParticipante.appendChild(elemIdentificacionFuente);
                    
                    elemParticipante.appendChild(elemFuentesParticipante);
                }

                Element elemRolParticipante = document.createElement("rol"); //creamos un nuevo elemento
                Text textRolParticipante = document.createTextNode(participante.get(i).getRol()); //Ingresamos la info
                elemRolParticipante.appendChild(textRolParticipante);
                elemParticipante.appendChild(elemRolParticipante);

                
                Element elemOrganizacionParticipante = document.createElement("organizacion"); //creamos un nuevo elemento
                if(participante.get(i).getOrganizacion().getIdentificacion() != null){
                    Text textOrganizacionParticipante = document.createTextNode(participante.get(i).getOrganizacion().getIdentificacion()); //Ingresamos la info
                    elemOrganizacionParticipante.appendChild(textOrganizacionParticipante);
                }
                elemParticipante.appendChild(elemOrganizacionParticipante);
                
                
                Element elemEsClienteParticipante = document.createElement("esCliente"); //creamos un nuevo elemento
                Text textEsClienteParticipante = document.createTextNode(participante.get(i).getEsCliente().toString()); //Ingresamos la info
                elemEsClienteParticipante.appendChild(textEsClienteParticipante);
                elemParticipante.appendChild(elemEsClienteParticipante);

                Element elemEsDesarrolladorParticipante = document.createElement("esDesarrollador"); //creamos un nuevo elemento
                Text textEsDesarrolladorParticipante = document.createTextNode(participante.get(i).getEsDesarrollador().toString()); //Ingresamos la info
                elemEsDesarrolladorParticipante.appendChild(textEsDesarrolladorParticipante);
                elemParticipante.appendChild(elemEsDesarrolladorParticipante);

                Element elemEsUsuarioParticipante = document.createElement("esUsuario"); //creamos un nuevo elemento
                Text textEsUsuarioParticipante = document.createTextNode(participante.get(i).getEsUsuario().toString()); //Ingresamos la info
                elemEsUsuarioParticipante.appendChild(textEsUsuarioParticipante);
                elemParticipante.appendChild(elemEsUsuarioParticipante);

                Element elemComentarioParticipante = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioParticipante = document.createTextNode(participante.get(i).getComentario()); //Ingresamos la info
                elemComentarioParticipante.appendChild(textComentarioParticipante);
                elemParticipante.appendChild(elemComentarioParticipante);

                raiz.appendChild(elemParticipante); //pegamos el elemento hijo a la raiz
            }
//Fin Participante



//--> Inicio Reunion
            //Recorrer el arraylist de REUNION y creo los arboles.
            for (int i = 0; i < reunion.size(); i++) {
                Element elemReunion = document.createElement("Reunion"); //creamos un nuevo elemento

                Element elemIdentificacionReunion = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionReunion = document.createTextNode(reunion.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionReunion.appendChild(textIdentificacionReunion);
                elemReunion.appendChild(elemIdentificacionReunion);

                Element elemNombreReunion = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreReunion = document.createTextNode(reunion.get(i).getNombre()); //Ingresamos la info
                elemNombreReunion.appendChild(textNombreReunion);
                elemReunion.appendChild(elemNombreReunion);

                Element elemVersionReunion = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionReunion = document.createTextNode(reunion.get(i).getVersion()); //Ingresamos la info
                elemVersionReunion.appendChild(textVersionReunion);
                elemReunion.appendChild(elemVersionReunion);

                Element elemFechaReunion = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaReunion = formatearFecha(reunion.get(i).getFecha());
                Text textFechaReunion = document.createTextNode(cadenaFechaReunion); //Ingresamos la info
                elemFechaReunion.appendChild(textFechaReunion);
                elemReunion.appendChild(elemFechaReunion);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresReunion = reunion.get(i).getAutores();
                for ( int j = 0; j < autoresReunion.size(); j++){
                    Element elemAutoresReunion = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresReunion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresReunion.appendChild(elemIdentificacionAutor);
                    
                    elemReunion.appendChild(elemAutoresReunion);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesReunion = reunion.get(i).getFuentes();
                for ( int j = 0; j < fuentesReunion.size(); j++){
                    Element elemFuentesReunion = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesReunion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesReunion.appendChild(elemIdentificacionFuente);
                    
                    elemReunion.appendChild(elemFuentesReunion);
                }

                Element elemLugarReunion = document.createElement("lugar"); //creamos un nuevo elemento
                Text textLugarReunion = document.createTextNode(reunion.get(i).getLugar()); //Ingresamos la info
                elemLugarReunion.appendChild(textLugarReunion);
                elemReunion.appendChild(elemLugarReunion);

                Element elemFechaReunionR = document.createElement("fechaReunion"); //creamos un nuevo elemento
                String cadenaFechaReunionR = formatearFecha(reunion.get(i).getFechaReunion());
                Text textFechaVidaReunionR = document.createTextNode(cadenaFechaReunionR); //Ingresamos la info
                elemFechaReunionR.appendChild(textFechaVidaReunionR);
                elemReunion.appendChild(elemFechaReunionR);

                Element elemHoraReunion = document.createElement("horaReunion"); //creamos un nuevo elemento
                Text textHoraReunion = document.createTextNode(reunion.get(i).getHora()); //Ingresamos la info
                elemHoraReunion.appendChild(textHoraReunion);
                elemReunion.appendChild(elemHoraReunion);

                //Hacer arbol de ASISTENTES
                ArrayList<Participante> asistentesReunion = reunion.get(i).getAsistentes();
                Element elemAsistentesReunion = document.createElement("asistentes"); //creamos un nuevo elemento
                for ( int j = 0; j < asistentesReunion.size(); j++){
                    Text textAsistenteReunion = document.createTextNode(asistentesReunion.get(j).getIdentificacion()); //Ingresamos la info
                    elemAsistentesReunion.appendChild(textAsistenteReunion);
                    elemReunion.appendChild(elemAsistentesReunion);
                }

                Element elemResultadosReunion = document.createElement("resultados"); //creamos un nuevo elemento
                Text textResultadosReunion = document.createTextNode(reunion.get(i).getResultados()); //Ingresamos la info
                elemResultadosReunion.appendChild(textResultadosReunion);
                elemReunion.appendChild(elemResultadosReunion);



                //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoReunion = reunion.get(i).getDestino();
                Element elemDestinoReunion = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoReunion.size(); j++){
                    Text textDestinoReunion = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoReunion.appendChild(textDestinoReunion);
                    elemReunion.appendChild(elemDestinoReunion);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenReunion = reunion.get(i).getOrigen();
                Element elemOrigenReunion = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenReunion.size(); j++){
                    Text textOrigenReunion = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenReunion.appendChild(textOrigenReunion);
                    elemReunion.appendChild(elemOrigenReunion);
                }

                Element elemComentarioReunion = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioReunion = document.createTextNode(reunion.get(i).getComentario()); //Ingresamos la info
                elemComentarioReunion.appendChild(textComentarioReunion);
                elemReunion.appendChild(elemComentarioReunion);

                raiz.appendChild(elemReunion); //pegamos el elemento hijo a la raiz
            }
//Fin Reunion

            

//--> Inicio Objetivo
            //Recorrer el arraylist de OBJETIVO y creo los arboles.
            for (int i = 0; i < objetivo.size(); i++) {
                Element elemObjetivo = document.createElement("Objetivo"); //creamos un nuevo elemento

                Element elemIdentificacionObjetivo = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionObjetivo = document.createTextNode(objetivo.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionObjetivo.appendChild(textIdentificacionObjetivo);
                elemObjetivo.appendChild(elemIdentificacionObjetivo);

                Element elemNombreObjetivo = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreObjetivo = document.createTextNode(objetivo.get(i).getNombre()); //Ingresamos la info
                elemNombreObjetivo.appendChild(textNombreObjetivo);
                elemObjetivo.appendChild(elemNombreObjetivo);

                Element elemVersionObjetivo = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionObjetivo = document.createTextNode(objetivo.get(i).getVersion()); //Ingresamos la info
                elemVersionObjetivo.appendChild(textVersionObjetivo);
                elemObjetivo.appendChild(elemVersionObjetivo);

                Element elemFechaObjetivo = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaObjetivo = formatearFecha(objetivo.get(i).getFecha());
                Text textFechaObjetivo = document.createTextNode(cadenaFechaObjetivo); //Ingresamos la info
                elemFechaObjetivo.appendChild(textFechaObjetivo);
                elemObjetivo.appendChild(elemFechaObjetivo);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresObjetivo = objetivo.get(i).getAutores();
                for ( int j = 0; j < autoresObjetivo.size(); j++){
                    Element elemAutoresObjetivo = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresObjetivo.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresObjetivo.appendChild(elemIdentificacionAutor);
                    
                    elemObjetivo.appendChild(elemAutoresObjetivo);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesObjetivo = objetivo.get(i).getFuentes();
                for ( int j = 0; j < fuentesObjetivo.size(); j++){
                    Element elemFuentesObjetivo = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesObjetivo.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesObjetivo.appendChild(elemIdentificacionFuente);
                    
                    elemFuentesObjetivo.appendChild(elemFuentesObjetivo);
                }

                Element elemTextoObjetivo = document.createElement("texto"); //creamos un nuevo elemento
                Text textTextoObjetivo = document.createTextNode(objetivo.get(i).getTexto()); //Ingresamos la info
                elemTextoObjetivo.appendChild(textTextoObjetivo);
                elemObjetivo.appendChild(elemTextoObjetivo);

                Element elemImportanciaObjetivo = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaObjetivo = document.createTextNode(objetivo.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaObjetivo.appendChild(textImportanciaObjetivo);
                elemObjetivo.appendChild(elemImportanciaObjetivo);

                Element elemUrgenciaObjetivo = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciasVidaObjetivo = document.createTextNode(objetivo.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaObjetivo.appendChild(textUrgenciasVidaObjetivo);
                elemObjetivo.appendChild(elemUrgenciaObjetivo);

                Element elemEstadoDesarrolloObjetivo = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloObjetivo = document.createTextNode(objetivo.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloObjetivo.appendChild(textEstadoDesarrolloObjetivo);
                elemObjetivo.appendChild(elemEstadoDesarrolloObjetivo);

                Element elemEstabilidadObjetivo = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadObjetivo = document.createTextNode(objetivo.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadObjetivo.appendChild(textEstabilidadObjetivo);
                elemObjetivo.appendChild(elemEstabilidadObjetivo);

               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoObjetivo = objetivo.get(i).getDestino();
                Element elemDestinoObjetivo = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoObjetivo.size(); j++){
                    Text textDestinoObjetivo = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoObjetivo.appendChild(textDestinoObjetivo);
                    elemObjetivo.appendChild(elemDestinoObjetivo);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenObjetivo = objetivo.get(i).getOrigen();
                Element elemOrigenObjetivo = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenObjetivo.size(); j++){
                    Text textOrigenObjetivo = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenObjetivo.appendChild(textOrigenObjetivo);
                    elemObjetivo.appendChild(elemOrigenObjetivo);
                }

                Element elemComentarioObjetivo = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioObjetivo = document.createTextNode(objetivo.get(i).getComentario()); //Ingresamos la info
                elemComentarioObjetivo.appendChild(textComentarioObjetivo);
                elemObjetivo.appendChild(elemComentarioObjetivo);

                raiz.appendChild(elemObjetivo); //pegamos el elemento hijo a la raiz
            }
//Fin Objetivo



//--> Inicio Actor
            //Recorrer el arraylist de ACTOR y creo los arboles.
            for (int i = 0; i < actor.size(); i++) {
                Element elemActor = document.createElement("Actor"); //creamos un nuevo elemento

                Element elemIdentificacionActor = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionActor = document.createTextNode(actor.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionActor.appendChild(textIdentificacionActor);
                elemActor.appendChild(elemIdentificacionActor);

                Element elemNombreActor = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreActor = document.createTextNode(actor.get(i).getNombre()); //Ingresamos la info
                elemNombreActor.appendChild(textNombreActor);
                elemActor.appendChild(elemNombreActor);

                Element elemVersionActor = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionActor = document.createTextNode(actor.get(i).getVersion()); //Ingresamos la info
                elemVersionActor.appendChild(textVersionActor);
                elemActor.appendChild(elemVersionActor);

                Element elemFechaActor = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaActor = formatearFecha(actor.get(i).getFecha());
                Text textFechaActor = document.createTextNode(cadenaFechaActor); //Ingresamos la info
                elemFechaActor.appendChild(textFechaActor);
                elemActor.appendChild(elemFechaActor);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresActor = actor.get(i).getAutores();
                for ( int j = 0; j < autoresActor.size(); j++){
                    Element elemAutoresActor = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresActor.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresActor.appendChild(elemIdentificacionAutor);
                    
                    elemActor.appendChild(elemAutoresActor);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesActor = actor.get(i).getFuentes();
                for ( int j = 0; j < fuentesActor.size(); j++){
                    Element elemFuentesActor = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesActor.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesActor.appendChild(elemIdentificacionFuente);
                    
                    elemActor.appendChild(elemFuentesActor);
                }

                Element elemTextoActor = document.createElement("texto"); //creamos un nuevo elemento
                Text textTextoActor = document.createTextNode(actor.get(i).getTexto()); //Ingresamos la info
                elemTextoActor.appendChild(textTextoActor);
                elemActor.appendChild(elemTextoActor);

               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoActor = actor.get(i).getDestino();
                Element elemDestinoActor = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoActor.size(); j++){
                    Text textDestinoActor = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoActor.appendChild(textDestinoActor);
                    elemActor.appendChild(elemDestinoActor);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenActor = actor.get(i).getOrigen();
                Element elemOrigenActor = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenActor.size(); j++){
                    Text textOrigenActor = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenActor.appendChild(textOrigenActor);
                    elemActor.appendChild(elemOrigenActor);
                }

                Element elemComentarioActor = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioActor = document.createTextNode(actor.get(i).getComentario()); //Ingresamos la info
                elemComentarioActor.appendChild(textComentarioActor);
                elemActor.appendChild(elemComentarioActor);

                raiz.appendChild(elemActor); //pegamos el elemento hijo a la raiz
            }
//Fin Actor



//--> Inicio Requisito Informacion
            //Recorrer el arraylist de REQUISITOS DE INFORMACION y creo los arboles.
            for (int i = 0; i < reqInformacion.size(); i++) {
                Element elemReqInformacion = document.createElement("ReqInformacion"); //creamos un nuevo elemento

                Element elemIdentificacionRI = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionRI = document.createTextNode(reqInformacion.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionRI.appendChild(textIdentificacionRI);
                elemReqInformacion.appendChild(elemIdentificacionRI);

                Element elemNombreRI = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreRI = document.createTextNode(reqInformacion.get(i).getNombre()); //Ingresamos la info
                elemNombreRI.appendChild(textNombreRI);
                elemReqInformacion.appendChild(elemNombreRI);

                Element elemVersionRI = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionRI = document.createTextNode(reqInformacion.get(i).getVersion()); //Ingresamos la info
                elemVersionRI.appendChild(textVersionRI);
                elemReqInformacion.appendChild(elemVersionRI);
 
                Element elemFechaRI = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaRI = formatearFecha(reqInformacion.get(i).getFecha());
                Text textFechaRI = document.createTextNode(cadenaFechaRI); //Ingresamos la info
                elemFechaRI.appendChild(textFechaRI);
                elemReqInformacion.appendChild(elemFechaRI);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresReqInformacion = reqInformacion.get(i).getAutores();
                for ( int j = 0; j < autoresReqInformacion.size(); j++){
                    Element elemAutoresReqInformacion = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresReqInformacion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresReqInformacion.appendChild(elemIdentificacionAutor);
                    
                    elemReqInformacion.appendChild(elemAutoresReqInformacion);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesReqInformacion = reqInformacion.get(i).getFuentes();
                for ( int j = 0; j < fuentesReqInformacion.size(); j++){
                    Element elemFuentesReqInformacion = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesReqInformacion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesReqInformacion.appendChild(elemIdentificacionFuente);
                    
                    elemReqInformacion.appendChild(elemFuentesReqInformacion);
                }

                Element elemConceptoRelevanteRI = document.createElement("conceptoRelevante"); //creamos un nuevo elemento
                Text textConceptoRelevanteRI = document.createTextNode(reqInformacion.get(i).getConceptoRelevante()); //Ingresamos la info
                elemConceptoRelevanteRI.appendChild(textConceptoRelevanteRI);
                elemReqInformacion.appendChild(elemConceptoRelevanteRI);

                Element elemValorMaxVidaRI = document.createElement("valorMaxVida"); //creamos un nuevo elemento
                Text textValorMaxVidaRI = document.createTextNode(String.valueOf(reqInformacion.get(i).getValorMaxVida())); //Ingresamos la info
                elemValorMaxVidaRI.appendChild(textValorMaxVidaRI);
                elemReqInformacion.appendChild(elemValorMaxVidaRI);

                Element elemUnidadTiempoMaxVidaRI = document.createElement("unidadTiempoMaxVida"); //creamos un nuevo elemento
                Text textUnidadTiempoMaxVidaRI = document.createTextNode(reqInformacion.get(i).getUnidadTiempoMaxVida()); //Ingresamos la info
                elemUnidadTiempoMaxVidaRI.appendChild(textUnidadTiempoMaxVidaRI);
                elemReqInformacion.appendChild(elemUnidadTiempoMaxVidaRI);

                Element elemValorMedioVidaRI = document.createElement("valorMedioVida"); //creamos un nuevo elemento
                Text textValorMedioVidaRI = document.createTextNode(String.valueOf(reqInformacion.get(i).getValorMedioVida())); //Ingresamos la info
                elemValorMedioVidaRI.appendChild(textValorMedioVidaRI);
                elemReqInformacion.appendChild(elemValorMedioVidaRI);

                Element elemUnidadTiempoMedioVidaRI = document.createElement("unidadTiempoMedioVida"); //creamos un nuevo elemento
                Text textUnidadTiempoMedioVidaRI = document.createTextNode(reqInformacion.get(i).getUnidadTiempoMedioVida()); //Ingresamos la info
                elemUnidadTiempoMedioVidaRI.appendChild(textUnidadTiempoMedioVidaRI);
                elemReqInformacion.appendChild(elemUnidadTiempoMedioVidaRI);

                Element elemOcurrenciasMaximaRI = document.createElement("ocurrenciasMaxima"); //creamos un nuevo elemento
                Text textOcurrenciasMaximasRI = document.createTextNode(String.valueOf(reqInformacion.get(i).getOcurrenciasMaxima())); //Ingresamos la info
                elemOcurrenciasMaximaRI.appendChild(textOcurrenciasMaximasRI);
                elemReqInformacion.appendChild(elemOcurrenciasMaximaRI);

                Element elemOcurrenciasMediaRI = document.createElement("ocurrenciasMedia"); //creamos un nuevo elemento
                Text textOcurrenciasMediaRI = document.createTextNode(String.valueOf(reqInformacion.get(i).getOcurrenciasMedia())); //Ingresamos la info
                elemOcurrenciasMediaRI.appendChild(textOcurrenciasMediaRI);
                elemReqInformacion.appendChild(elemOcurrenciasMediaRI);

                Element elemImportanciaRI = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaRI = document.createTextNode(reqInformacion.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaRI.appendChild(textImportanciaRI);
                elemReqInformacion.appendChild(elemImportanciaRI);

                Element elemUrgenciaRI = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaRI = document.createTextNode(reqInformacion.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaRI.appendChild(textUrgenciaRI);
                elemReqInformacion.appendChild(elemUrgenciaRI);

                Element elemEstadoDesarrolloRI = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloRI = document.createTextNode(reqInformacion.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloRI.appendChild(textEstadoDesarrolloRI);
                elemReqInformacion.appendChild(elemEstadoDesarrolloRI);

                Element elemEstabilidadRI = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadRI = document.createTextNode(reqInformacion.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadRI.appendChild(textEstabilidadRI);
                elemReqInformacion.appendChild(elemEstabilidadRI);
 
               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoRI = reqInformacion.get(i).getDestino();
                Element elemDestinoRI = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoRI.size(); j++){
                    Text textDestinoRI = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoRI.appendChild(textDestinoRI);
                    elemReqInformacion.appendChild(elemDestinoRI);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenRI = reqInformacion.get(i).getOrigen();
                Element elemOrigenRI = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenRI.size(); j++){
                    Text textOrigenRI = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenRI.appendChild(textOrigenRI);
                    elemReqInformacion.appendChild(elemOrigenRI);
                }
                
                Element elemComentarioRI = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioRI = document.createTextNode(reqInformacion.get(i).getComentario()); //Ingresamos la info
                elemComentarioRI.appendChild(textComentarioRI);
                elemReqInformacion.appendChild(elemComentarioRI);

                raiz.appendChild(elemReqInformacion); //pegamos el elemento hijo a la raiz
            }
//Fin Requisito Informacion



//--> Inicio Requisito Restriccion
            //Recorrer el arraylist de REQUISITOS DE RESTRICCION y creo los arboles.
            for (int i = 0; i < reqRestriccion.size(); i++) {
                Element elemReqRestriccion = document.createElement("ReqRestriccion"); //creamos un nuevo elemento

                Element elemIdentificacionRR = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionRR = document.createTextNode(reqRestriccion.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionRR.appendChild(textIdentificacionRR);
                elemReqRestriccion.appendChild(elemIdentificacionRR);

                Element elemNombreRR = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreRR = document.createTextNode(reqRestriccion.get(i).getNombre()); //Ingresamos la info
                elemNombreRR.appendChild(textNombreRR);
                elemReqRestriccion.appendChild(elemNombreRR);

                Element elemVersionRR = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionRR = document.createTextNode(reqRestriccion.get(i).getVersion()); //Ingresamos la info
                elemVersionRR.appendChild(textVersionRR);
                elemReqRestriccion.appendChild(elemVersionRR);

                Element elemFechaRR = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaRR = formatearFecha(reqRestriccion.get(i).getFecha());
                Text textFechaRR = document.createTextNode(cadenaFechaRR); //Ingresamos la info
                elemFechaRR.appendChild(textFechaRR);
                elemReqRestriccion.appendChild(elemFechaRR);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresReqRestriccion = reqRestriccion.get(i).getAutores();
                for ( int j = 0; j < autoresReqRestriccion.size(); j++){
                    Element elemAutoresReqRestriccion = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresReqRestriccion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresReqRestriccion.appendChild(elemIdentificacionAutor);
                    
                    elemReqRestriccion.appendChild(elemAutoresReqRestriccion);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesReqInformacion = reqInformacion.get(i).getFuentes();
                for ( int j = 0; j < fuentesReqInformacion.size(); j++){
                    Element elemFuentesReqInformacion = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesReqInformacion.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesReqInformacion.appendChild(elemIdentificacionFuente);
                    
                    elemReqRestriccion.appendChild(elemFuentesReqInformacion);
                }

                Element elemDescripcionRR = document.createElement("descripcion"); //creamos un nuevo elemento
                Text textDescripcionRR = document.createTextNode(reqRestriccion.get(i).getDescripcion()); //Ingresamos la info
                elemDescripcionRR.appendChild(textDescripcionRR);
                elemReqRestriccion.appendChild(elemDescripcionRR);

                Element elemImportanciaRR = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaRR = document.createTextNode(reqRestriccion.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaRR.appendChild(textImportanciaRR);
                elemReqRestriccion.appendChild(elemImportanciaRR);

                Element elemUrgenciaRR = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaRR = document.createTextNode(reqRestriccion.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaRR.appendChild(textUrgenciaRR);
                elemReqRestriccion.appendChild(elemUrgenciaRR);

                Element elemEstadoDesarrolloRR = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloRR = document.createTextNode(reqRestriccion.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloRR.appendChild(textEstadoDesarrolloRR);
                elemReqRestriccion.appendChild(elemEstadoDesarrolloRR);

                Element elemEstabilidadRR = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadRR = document.createTextNode(reqRestriccion.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadRR.appendChild(textEstabilidadRR);
                elemReqRestriccion.appendChild(elemEstabilidadRR);
                
               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoRR = reqRestriccion.get(i).getDestino();
                Element elemDestinoRR = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoRR.size(); j++){
                    Text textDestinoRR = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoRR.appendChild(textDestinoRR);
                    elemReqRestriccion.appendChild(elemDestinoRR);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenRR = reqRestriccion.get(i).getOrigen();
                Element elemOrigenRR = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenRR.size(); j++){
                    Text textOrigenRR = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenRR.appendChild(textOrigenRR);
                    elemReqRestriccion.appendChild(elemOrigenRR);
                }
                
                Element elemComentarioRR = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioRR = document.createTextNode(reqRestriccion.get(i).getComentario()); //Ingresamos la info
                elemComentarioRR.appendChild(textComentarioRR);
                elemReqRestriccion.appendChild(elemComentarioRR);

                raiz.appendChild(elemReqRestriccion); //pegamos el elemento hijo a la raiz
            }
//Fin Requisito Restriccion



//--> Inicio Caso de Uso
            //Recorrer el arraylist de Casos de Uso y creo los arboles.
            for (int i = 0; i < casosUso.size(); i++) {
                Element elemCasoUso = document.createElement("CasoUso"); //creamos un nuevo elemento

                Element elemIdentificacionCU = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionCU = document.createTextNode(casosUso.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionCU.appendChild(textIdentificacionCU);
                elemCasoUso.appendChild(elemIdentificacionCU);

                Element elemNombreCU = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreCU = document.createTextNode(casosUso.get(i).getNombre()); //Ingresamos la info
                elemNombreCU.appendChild(textNombreCU);
                elemCasoUso.appendChild(elemNombreCU);

                Element elemVersionCU = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionCU = document.createTextNode(casosUso.get(i).getVersion()); //Ingresamos la info
                elemVersionCU.appendChild(textVersionCU);
                elemCasoUso.appendChild(elemVersionCU);

                Element elemFechaCU = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaCU = formatearFecha(casosUso.get(i).getFecha());
                Text textFechaCU = document.createTextNode(cadenaFechaCU); //Ingresamos la info
                elemFechaCU.appendChild(textFechaCU);
                elemCasoUso.appendChild(elemFechaCU);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresCU = casosUso.get(i).getAutores();
                Element elemAutoresCU = document.createElement("autores"); //creamos un nuevo elemento
                for ( int j = 0; j < autoresCU.size(); j++){
                    Text textAutoresCU = document.createTextNode(autoresCU.get(j).getIdentificacion()); //Ingresamos la info
                    elemAutoresCU.appendChild(textAutoresCU);
                    elemCasoUso.appendChild(elemAutoresCU);
                }

               //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesCU = casosUso.get(i).getFuentes();
                Element elemFuentesCU = document.createElement("fuentes"); //creamos un nuevo elemento
                for ( int j = 0; j < fuentesCU.size(); j++){
                    Text textFuentesCU = document.createTextNode(fuentesCU.get(j).getIdentificacion()); //Ingresamos la info
                    elemFuentesCU.appendChild(textFuentesCU);
                    elemCasoUso.appendChild(elemFuentesCU);
                }

                Element elemEsAbstractoCU = document.createElement("esAbstracto"); //creamos un nuevo elemento
                Text textEsAbstractoCU = document.createTextNode(casosUso.get(i).getEsAbstracto().toString()); //Ingresamos la info
                elemEsAbstractoCU.appendChild(textEsAbstractoCU);
                elemCasoUso.appendChild(elemEsAbstractoCU);

                Element elemEventoActivacionCU = document.createElement("eventoActivacion"); //creamos un nuevo elemento
                Text textEventoActivacionCU = document.createTextNode(casosUso.get(i).getEventoActivacion()); //Ingresamos la info
                elemEventoActivacionCU.appendChild(textEventoActivacionCU);
                elemCasoUso.appendChild(elemEventoActivacionCU);

                Element elemVecesCU = document.createElement("veces"); //creamos un nuevo elemento
                Text textVecesCU = document.createTextNode(String.valueOf(casosUso.get(i).getVeces())); //Ingresamos la info
                elemVecesCU.appendChild(textVecesCU);
                elemCasoUso.appendChild(elemVecesCU);

                Element elemUnidadCU = document.createElement("unidad"); //creamos un nuevo elemento
                Text textUnidadCU = document.createTextNode(casosUso.get(i).getUnidad()); //Ingresamos la info
                elemUnidadCU.appendChild(textUnidadCU);
                elemCasoUso.appendChild(elemUnidadCU);

                Element elemPrecondicionCU = document.createElement("precondicion"); //creamos un nuevo elemento
                Text textPrecondicionCU = document.createTextNode(casosUso.get(i).getPrecondicion()); //Ingresamos la info
                elemPrecondicionCU.appendChild(textPrecondicionCU);
                elemCasoUso.appendChild(elemPrecondicionCU);

                Element elemPostcondicionCU = document.createElement("postcondicion"); //creamos un nuevo elemento
                Text textPostcondicionCU = document.createTextNode(casosUso.get(i).getPostcondicion()); //Ingresamos la info
                elemPostcondicionCU.appendChild(textPostcondicionCU);
                elemCasoUso.appendChild(elemPostcondicionCU);

                Element elemImportanciaCU = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaCU = document.createTextNode(casosUso.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaCU.appendChild(textImportanciaCU);
                elemCasoUso.appendChild(elemImportanciaCU);

                Element elemUrgenciaCU = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaCU = document.createTextNode(casosUso.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaCU.appendChild(textUrgenciaCU);
                elemCasoUso.appendChild(elemUrgenciaCU);

                Element elemEstadoDesarrolloCU = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloCU = document.createTextNode(casosUso.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloCU.appendChild(textEstadoDesarrolloCU);
                elemCasoUso.appendChild(elemEstadoDesarrolloCU);

                Element elemEstabilidadCU = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadCU = document.createTextNode(casosUso.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadCU.appendChild(textEstabilidadCU);
                elemCasoUso.appendChild(elemEstabilidadCU);

               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoCU = casosUso.get(i).getDestino();
                Element elemDestinoCU = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoCU.size(); j++){
                    Text textDestinoCU = document.createTextNode("Destino"); //Ingresamos la info
                    elemFuentesCU.appendChild(textDestinoCU);
                    elemCasoUso.appendChild(elemDestinoCU);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenCU = casosUso.get(i).getOrigen();
                Element elemOrigenCU = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenCU.size(); j++){
                    Text textOrigenCU = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenCU.appendChild(textOrigenCU);
                    elemCasoUso.appendChild(elemOrigenCU);
                }

                //Hacer arbol de PASOS
                ArrayList<Paso> pasos = casosUso.get(i).getPaso();
                for ( int j = 0; j < pasos.size(); j++){
                    //Saco información de los pasos.
                    Element elemPasos = document.createElement("Paso"); //creamos un nuevo elemento

                    Element elemIdentificacionPaso = document.createElement("identificacion"); //creamos un nuevo elemento
                    Text textPaso = document.createTextNode(pasos.get(j).getIdentificacion()); //Ingresamos la info
                    elemIdentificacionPaso.appendChild(textPaso);
                    elemPasos.appendChild(elemIdentificacionPaso);

                    Element elemNombrePaso = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textNombrePaso = document.createTextNode(pasos.get(j).getNombre()); //Ingresamos la info
                    elemNombrePaso.appendChild(textNombrePaso);
                    elemPasos.appendChild(elemNombrePaso);

                    Element elemesCondicionalP = document.createElement("esCondicional"); //creamos un nuevo elemento
                    Text textesCondicionalP = document.createTextNode(pasos.get(j).getEsCondicional().toString()); //Ingresamos la info
                    elemesCondicionalP.appendChild(textesCondicionalP);
                    elemPasos.appendChild(elemesCondicionalP);
                
                    Element elemCondicionPaso = document.createElement("condicion"); //creamos un nuevo elemento
                    Text textCondicionPaso = document.createTextNode(pasos.get(j).getCondicion()); //Ingresamos la info
                    elemCondicionPaso.appendChild(textCondicionPaso);
                    elemPasos.appendChild(elemCondicionPaso);

                    Element elemAccionSistemaPaso = document.createElement("accionSistema"); //creamos un nuevo elemento
                    Text textAccionSistemaPaso = document.createTextNode(pasos.get(j).getAccionSistema().toString()); //Ingresamos la info
                    elemAccionSistemaPaso.appendChild(textAccionSistemaPaso);
                    elemPasos.appendChild(elemAccionSistemaPaso);

                    Element elemAccionActorPaso = document.createElement("accionActor"); //creamos un nuevo elemento
                    Text textAccionActorPaso = document.createTextNode(pasos.get(j).getAccionActor().toString()); //Ingresamos la info
                    elemAccionActorPaso.appendChild(textAccionActorPaso);
                    elemPasos.appendChild(elemAccionActorPaso);

                    Element elemInclusionExtPaso = document.createElement("inclusionExtension"); //creamos un nuevo elemento
                    Text textInclusionExtPaso = document.createTextNode(pasos.get(j).getInclusionExtension().toString()); //Ingresamos la info
                    elemInclusionExtPaso.appendChild(textInclusionExtPaso);
                    elemPasos.appendChild(elemInclusionExtPaso);

                    Element elemAccionPaso = document.createElement("accion"); //creamos un nuevo elemento
                    Text textAccionPaso = document.createTextNode(pasos.get(j).getDescripcionAccion()); //Ingresamos la info
                    elemAccionPaso.appendChild(textAccionPaso);
                    elemPasos.appendChild(elemAccionPaso);

                    Element elemValorRendPaso = document.createElement("valorRendimiento"); //creamos un nuevo elemento
                    Text textValorRendPaso = document.createTextNode(String.valueOf(pasos.get(j).getValorRendimiento())); //Ingresamos la info
                    elemValorRendPaso.appendChild(textValorRendPaso);
                    elemPasos.appendChild(elemValorRendPaso);

                    Element elemUnidadRendPaso = document.createElement("unidadRendimiento"); //creamos un nuevo elemento
                    Text textUnidadRendPaso = document.createTextNode(pasos.get(j).getUnidadRendimiento()); //Ingresamos la info
                    elemUnidadRendPaso.appendChild(textUnidadRendPaso);
                    elemPasos.appendChild(elemUnidadRendPaso);

                    Element elemComentarioPaso = document.createElement("comentario"); //creamos un nuevo elemento
                    Text texComentarioPaso = document.createTextNode(pasos.get(j).getUnidadRendimiento()); //Ingresamos la info
                    elemComentarioPaso.appendChild(texComentarioPaso);
                    elemPasos.appendChild(elemComentarioPaso);

                   //Buscamos las excepciones
                    ArrayList<Excepcion> excepciones = casosUso.get(i).getPaso().get(j).getExcepcion();
                        for ( int k = 0; k < excepciones.size(); k++){
                            //Saco información de las excepciones
                            Element elemExcepcion = document.createElement("Excepcion"); //creamos un nuevo elemento

                            Element elemIdentificacionExcepcion = document.createElement("identificacion"); //creamos un nuevo elemento
                            Text textExcepcion = document.createTextNode(excepciones.get(k).getIdentificacion()); //Ingresamos la info
                            elemIdentificacionExcepcion.appendChild(textExcepcion);
                            elemExcepcion.appendChild(elemIdentificacionExcepcion);

                            Element elemNombreExcepcion = document.createElement("nombre"); //creamos un nuevo elemento
                            Text textNombreExcepcion = document.createTextNode(excepciones.get(k).getNombre()); //Ingresamos la info
                            elemNombreExcepcion.appendChild(textNombreExcepcion);
                            elemExcepcion.appendChild(elemNombreExcepcion);

                            Element elemCondicionExcepcion = document.createElement("condicion"); //creamos un nuevo elemento
                            Text textCondicionExcepcion = document.createTextNode(excepciones.get(k).getCondicion()); //Ingresamos la info
                            elemCondicionExcepcion.appendChild(textCondicionExcepcion);
                            elemExcepcion.appendChild(elemCondicionExcepcion);

                            Element elemAccionSistemaExcepcion = document.createElement("accionSistema"); //creamos un nuevo elemento
                            Text textAccionSistemaExcepcion = document.createTextNode(excepciones.get(k).getAccionSistema().toString()); //Ingresamos la info
                            elemAccionSistemaExcepcion.appendChild(textAccionSistemaExcepcion);
                            elemExcepcion.appendChild(elemAccionSistemaExcepcion);

                            Element elemAccionActorExcepcion = document.createElement("accionActor"); //creamos un nuevo elemento
                            Text textAccionActorExcepcion = document.createTextNode(excepciones.get(k).getAccionActor().toString()); //Ingresamos la info
                            elemAccionActorExcepcion.appendChild(textAccionActorExcepcion);
                            elemExcepcion.appendChild(elemAccionActorExcepcion);

                            Element elemInclusionExtExcepcion = document.createElement("inclusionExtension"); //creamos un nuevo elemento
                            Text textInclusionExtExcepcion = document.createTextNode(excepciones.get(k).getInclusionExtension().toString()); //Ingresamos la info
                            elemInclusionExtExcepcion.appendChild(textInclusionExtExcepcion);
                            elemExcepcion.appendChild(elemInclusionExtExcepcion);

                            Element elemAccionExcepcion = document.createElement("accion"); //creamos un nuevo elemento
                            Text textAccionExcepcion = document.createTextNode(excepciones.get(k).getDescripcionAccion());//Ingresamos la info
                            elemAccionExcepcion.appendChild(textAccionExcepcion);
                            elemExcepcion.appendChild(elemAccionExcepcion);

                            Element elemValorRendExcepcion = document.createElement("valorRendimiento"); //creamos un nuevo elemento
                            Text textValorRendExcepcion = document.createTextNode(String.valueOf(excepciones.get(k).getValorRendimiento())); //Ingresamos la info
                            elemValorRendExcepcion.appendChild(textValorRendExcepcion);
                            elemExcepcion.appendChild(elemValorRendExcepcion);

                            Element elemUnidadRendExcepcion = document.createElement("unidadRendimiento"); //creamos un nuevo elemento
                            Text textUnidadRendExcepcion = document.createTextNode(excepciones.get(k).getUnidadRendimiento()); //Ingresamos la info
                            elemUnidadRendExcepcion.appendChild(textUnidadRendExcepcion);
                            elemExcepcion.appendChild(elemUnidadRendExcepcion);

                            Element elemComentarioExcepcion = document.createElement("comentario"); //creamos un nuevo elemento
                            Text texComentarioExcepcion = document.createTextNode(excepciones.get(k).getUnidadRendimiento()); //Ingresamos la info
                            elemComentarioExcepcion.appendChild(texComentarioExcepcion);
                            elemExcepcion.appendChild(elemComentarioExcepcion);

                            elemPasos.appendChild(elemExcepcion);
                        }
                    elemCasoUso.appendChild(elemPasos);
                }
                Element elemComentarioCU = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioCU = document.createTextNode(casosUso.get(i).getComentario()); //Ingresamos la info
                elemComentarioCU.appendChild(textComentarioCU);
                elemCasoUso.appendChild(elemComentarioCU);

                raiz.appendChild(elemCasoUso); //pegamos el elemento hijo a la raiz
            }
//Fin Caso de Uso



//--> Inicio Requisito Funcional
            //Recorrer el arraylist de REQUISITOS FUNCIONAL y creo los arboles.
            for (int i = 0; i < reqFuncional.size(); i++) {
                Element elemreqFuncional = document.createElement("ReqFuncional"); //creamos un nuevo elemento

                Element elemIdentificacionRF = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionRF = document.createTextNode(reqFuncional.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionRF.appendChild(textIdentificacionRF);
                elemreqFuncional.appendChild(elemIdentificacionRF);

                Element elemNombreRF = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreRF = document.createTextNode(reqFuncional.get(i).getNombre()); //Ingresamos la info
                elemNombreRF.appendChild(textNombreRF);
                elemreqFuncional.appendChild(elemNombreRF);

                Element elemVersionRF = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionRF = document.createTextNode(reqFuncional.get(i).getVersion()); //Ingresamos la info
                elemVersionRF.appendChild(textVersionRF);
                elemreqFuncional.appendChild(elemVersionRF);

                Element elemFechaRF = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaRF = formatearFecha(reqFuncional.get(i).getFecha());
                Text textFechaRF = document.createTextNode(cadenaFechaRF); //Ingresamos la info
                elemFechaRF.appendChild(textFechaRF);
                elemreqFuncional.appendChild(elemFechaRF);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresReqFuncional = reqFuncional.get(i).getAutores();
                for ( int j = 0; j < autoresReqFuncional.size(); j++){
                    Element elemAutoresReqFuncional = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresReqFuncional.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresReqFuncional.appendChild(elemIdentificacionAutor);
                    
                    elemreqFuncional.appendChild(elemAutoresReqFuncional);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesReqFuncional = reqFuncional.get(i).getFuentes();
                for ( int j = 0; j < fuentesReqFuncional.size(); j++){
                    Element elemFuentesReqFuncional = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesReqFuncional.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesReqFuncional.appendChild(elemIdentificacionFuente);
                    
                    elemreqFuncional.appendChild(elemFuentesReqFuncional);
                }

                Element elemTextoRF = document.createElement("texto"); //creamos un nuevo elemento
                Text textTextoRF = document.createTextNode(reqFuncional.get(i).getTexto()); //Ingresamos la info
                elemTextoRF.appendChild(textTextoRF);
                elemreqFuncional.appendChild(elemTextoRF);

                Element elemImportanciaRF = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaRF = document.createTextNode(reqFuncional.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaRF.appendChild(textImportanciaRF);
                elemreqFuncional.appendChild(elemImportanciaRF);

                Element elemUrgenciaRF = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaRF = document.createTextNode(reqFuncional.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaRF.appendChild(textUrgenciaRF);
                elemreqFuncional.appendChild(elemUrgenciaRF);

                Element elemEstadoDesarrolloRF = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloRF = document.createTextNode(reqFuncional.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloRF.appendChild(textEstadoDesarrolloRF);
                elemreqFuncional.appendChild(elemEstadoDesarrolloRF);

                Element elemEstabilidadRF = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadRF = document.createTextNode(reqFuncional.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadRF.appendChild(textEstabilidadRF);
                elemreqFuncional.appendChild(elemEstabilidadRF);
        
               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoRF = reqFuncional.get(i).getDestino();
                Element elemDestinoRF = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoRF.size(); j++){
                    Text textDestinoRF = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoRF.appendChild(textDestinoRF);
                    elemreqFuncional.appendChild(elemDestinoRF);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenRF = reqFuncional.get(i).getOrigen();
                Element elemOrigenRF = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenRF.size(); j++){
                    Text textOrigenRF = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenRF.appendChild(textOrigenRF);
                    elemreqFuncional.appendChild(elemOrigenRF);
                }
                
                Element elemComentarioRF = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioRF = document.createTextNode(reqFuncional.get(i).getComentario()); //Ingresamos la info
                elemComentarioRF.appendChild(textComentarioRF);
                elemreqFuncional.appendChild(elemComentarioRF);

                raiz.appendChild(elemreqFuncional); //pegamos el elemento hijo a la raiz
            }
//Fin Requisito Funcional


            
//--> Inicio Requisito No Funcional
            //Recorrer el arraylist de REQUISITOS NO FUNCIONAL y creo los arboles.
            for (int i = 0; i < reqNoFuncional.size(); i++) {
                Element elemreqNoFuncional = document.createElement("ReqNoFuncional"); //creamos un nuevo elemento

                Element elemIdentificacionRNF = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionRNF = document.createTextNode(reqNoFuncional.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionRNF.appendChild(textIdentificacionRNF);
                elemreqNoFuncional.appendChild(elemIdentificacionRNF);

                Element elemNombreRNF = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreRNF = document.createTextNode(reqNoFuncional.get(i).getNombre()); //Ingresamos la info
                elemNombreRNF.appendChild(textNombreRNF);
                elemreqNoFuncional.appendChild(elemNombreRNF);

                Element elemVersionRNF = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionRNF = document.createTextNode(reqNoFuncional.get(i).getVersion()); //Ingresamos la info
                elemVersionRNF.appendChild(textVersionRNF);
                elemreqNoFuncional.appendChild(elemVersionRNF);

                Element elemFechaRNF = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaRNF = formatearFecha(reqNoFuncional.get(i).getFecha());
                Text textFechaRNF = document.createTextNode(cadenaFechaRNF); //Ingresamos la info
                elemFechaRNF.appendChild(textFechaRNF);
                elemreqNoFuncional.appendChild(elemFechaRNF);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresReqNoFuncional = reqNoFuncional.get(i).getAutores();
                for ( int j = 0; j < autoresReqNoFuncional.size(); j++){
                    Element elemAutoresReqNoFuncional = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresReqNoFuncional.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresReqNoFuncional.appendChild(elemIdentificacionAutor);
                    
                    elemreqNoFuncional.appendChild(elemAutoresReqNoFuncional);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesReqNoFuncional = reqNoFuncional.get(i).getFuentes();
                for ( int j = 0; j < fuentesReqNoFuncional.size(); j++){
                    Element elemFuentesReqNoFuncional = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesReqNoFuncional.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesReqNoFuncional.appendChild(elemIdentificacionFuente);
                    
                    elemreqNoFuncional.appendChild(elemFuentesReqNoFuncional);
                }

                Element elemTextoRNF = document.createElement("texto"); //creamos un nuevo elemento
                Text textTextoRNF = document.createTextNode(reqNoFuncional.get(i).getTexto()); //Ingresamos la info
                elemTextoRNF.appendChild(textTextoRNF);
                elemreqNoFuncional.appendChild(elemTextoRNF);

                Element elemImportanciaRNF = document.createElement("importancia"); //creamos un nuevo elemento
                Text textImportanciaRNF = document.createTextNode(reqNoFuncional.get(i).getImportancia()); //Ingresamos la info
                elemImportanciaRNF.appendChild(textImportanciaRNF);
                elemreqNoFuncional.appendChild(elemImportanciaRNF);

                Element elemUrgenciaRNF = document.createElement("urgencia"); //creamos un nuevo elemento
                Text textUrgenciaRNF = document.createTextNode(reqNoFuncional.get(i).getUrgencia()); //Ingresamos la info
                elemUrgenciaRNF.appendChild(textUrgenciaRNF);
                elemreqNoFuncional.appendChild(elemUrgenciaRNF);

                Element elemEstadoDesarrolloRNF = document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
                Text textEstadoDesarrolloRNF = document.createTextNode(reqNoFuncional.get(i).getEstadoDesarrollo()); //Ingresamos la info
                elemEstadoDesarrolloRNF.appendChild(textEstadoDesarrolloRNF);
                elemreqNoFuncional.appendChild(elemEstadoDesarrolloRNF);

                Element elemEstabilidadRNF = document.createElement("estabilidad"); //creamos un nuevo elemento
                Text textEstabilidadRNF = document.createTextNode(reqNoFuncional.get(i).getEstabilidad()); //Ingresamos la info
                elemEstabilidadRNF.appendChild(textEstabilidadRNF);
                elemreqNoFuncional.appendChild(elemEstabilidadRNF);

                
               //Hacer arbol de DESTINO
                ArrayList<ElementosTrazas> destinoRNF = reqNoFuncional.get(i).getDestino();
                Element elemDestinoRNF = document.createElement("destino"); //creamos un nuevo elemento
                for ( int j = 0; j < destinoRNF.size(); j++){
                    Text textDestinoRNF = document.createTextNode("Destino"); //Ingresamos la info
                    elemDestinoRNF.appendChild(textDestinoRNF);
                    elemreqNoFuncional.appendChild(elemDestinoRNF);
                }

                //Hacer arbol de ORIGEN
                ArrayList<ElementosTrazas> origenRNF = reqNoFuncional.get(i).getOrigen();
                Element elemOrigenRNF = document.createElement("origen"); //creamos un nuevo elemento
                for ( int j = 0; j < origenRNF.size(); j++){
                    Text textOrigenRNF = document.createTextNode("Origen"); //Ingresamos la info
                    elemOrigenRNF.appendChild(textOrigenRNF);
                    elemreqNoFuncional.appendChild(elemOrigenRNF);
                }
                

                Element elemComentarioRNF = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioRNF = document.createTextNode(reqNoFuncional.get(i).getComentario()); //Ingresamos la info
                elemComentarioRNF.appendChild(textComentarioRNF);
                elemreqNoFuncional.appendChild(elemComentarioRNF);

                raiz.appendChild(elemreqNoFuncional); //pegamos el elemento hijo a la raiz
            }
//Fin Requisito No Funcional


            
//--> Inicio Matriz Rastreabilidad
            //Recorrer el arraylist de MATRIZ DE RASTREABILIDAD y creo los arboles.
            for (int i = 0; i < matrizRastreabilidad.size(); i++) {
                Element elemMatrizRastreabilidad = document.createElement("MatrizRastreabilidad"); //creamos un nuevo elemento

                Element elemIdentificacionMatrizRastreabilidad = document.createElement("identificacion"); //creamos un nuevo elemento
                Text textIdentificacionMatrizRastreabilidad = document.createTextNode(matrizRastreabilidad.get(i).getIdentificacion()); //Ingresamos la identificacion
                elemIdentificacionMatrizRastreabilidad.appendChild(textIdentificacionMatrizRastreabilidad);
                elemMatrizRastreabilidad.appendChild(elemIdentificacionMatrizRastreabilidad);

                Element elemNombreMatrizRastreabilidad = document.createElement("nombre"); //creamos un nuevo elemento
                Text textNombreMatrizRastreabilidad = document.createTextNode(matrizRastreabilidad.get(i).getNombre()); //Ingresamos la info
                elemNombreMatrizRastreabilidad.appendChild(textNombreMatrizRastreabilidad);
                elemMatrizRastreabilidad.appendChild(elemNombreMatrizRastreabilidad);

                Element elemVersionMatrizRastreabilidad = document.createElement("version"); //creamos un nuevo elemento
                Text textVersionMatrizRastreabilidad = document.createTextNode(matrizRastreabilidad.get(i).getVersion()); //Ingresamos la info
                elemVersionMatrizRastreabilidad.appendChild(textVersionMatrizRastreabilidad);
                elemMatrizRastreabilidad.appendChild(elemVersionMatrizRastreabilidad);

                Element elemFechaMatrizRastreabilidad = document.createElement("fecha"); //creamos un nuevo elemento
                String cadenaFechaMatrizRastreabilidad = formatearFecha(matrizRastreabilidad.get(i).getFecha());
                Text textFechaMatrizRastreabilidad = document.createTextNode(cadenaFechaMatrizRastreabilidad); //Ingresamos la info
                elemFechaMatrizRastreabilidad.appendChild(textFechaMatrizRastreabilidad);
                elemMatrizRastreabilidad.appendChild(elemFechaMatrizRastreabilidad);

                //Hacer un arbol de AUTORES
                ArrayList<Participante> autoresMatrizRastreabilidad = matrizRastreabilidad.get(i).getAutores();
                for ( int j = 0; j < autoresMatrizRastreabilidad.size(); j++){
                    Element elemAutoresMatrizRastreabilidad = document.createElement("Autor"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionAutor = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionAutor = document.createTextNode(autoresMatrizRastreabilidad.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionAutor.appendChild(textIdentificacionAutor);
                    elemAutoresMatrizRastreabilidad.appendChild(elemIdentificacionAutor);
                    
                    elemMatrizRastreabilidad.appendChild(elemAutoresMatrizRastreabilidad);
                }

                //Hacer un arbol de FUENTES
                ArrayList<Participante> fuentesMatrizRastreabilidad = matrizRastreabilidad.get(i).getFuentes();
                for ( int j = 0; j < fuentesMatrizRastreabilidad.size(); j++){
                    Element elemFuentesMatrizRastreabilidad = document.createElement("Fuente"); //creamos un nuevo elemento
                    
                    Element elemIdentificacionFuente = document.createElement("nombre"); //creamos un nuevo elemento
                    Text textIdentificacionFuente = document.createTextNode(fuentesMatrizRastreabilidad.get(j).getNombre()); //Ingresamos la info
                    elemIdentificacionFuente.appendChild(textIdentificacionFuente);
                    elemFuentesMatrizRastreabilidad.appendChild(elemIdentificacionFuente);
                    
                    elemMatrizRastreabilidad.appendChild(elemFuentesMatrizRastreabilidad);
                }

               /* //Hacer un arbol de MATRIZ FILA    --  Esta por terminar.
                ArrayList<ElementosTrazas> matrizFilaMR = matrizRastreabilidad.get(i).getMatrizFila();
                Element elemMatrizFilaMR = document.createElement("matrizFila"); //creamos un nuevo elemento
                for ( int j = 0; j < matrizFilaMR.size(); j++){
                    Text textMatrizFilaMR = document.createTextNode();
                    elemMatrizFilaMR.appendChild(textMatrizFilaMR);
                    elemMatrizRastreabilidad.appendChild(elemFuentesMatrizRastreabilidad);
                }
               
                //Hacer un arbol de MATRIZ COLUMNA 
                ArrayList<ElementosTrazas> matrizColumnaMR = matrizRastreabilidad.get(i).getMatrizFila();
                Element elemMatrizColumnaMR = document.createElement("matrizColumna"); //creamos un nuevo elemento
                for ( int j = 0; j < matrizColumnaMR.size(); j++){
                    Text textMatrizColumnaMR = document.createTextNode(); //Ingresamos la info
                    elemMatrizColumnaMR.appendChild(textMatrizColumnaMR);
                    elemMatrizRastreabilidad.appendChild(elemMatrizColumnaMR);
                }
                */
                
                Element elemComentarioMatrizRastreabilidad = document.createElement("comentario"); //creamos un nuevo elemento
                Text textComentarioMatrizRastreabilidad = document.createTextNode(matrizRastreabilidad.get(i).getComentario()); //Ingresamos la info
                elemComentarioMatrizRastreabilidad.appendChild(textComentarioMatrizRastreabilidad);
                elemMatrizRastreabilidad.appendChild(elemComentarioMatrizRastreabilidad);

                raiz.appendChild(elemMatrizRastreabilidad); //pegamos el elemento hijo a la raiz
            }
//Fin Matriz Rastreabilidad




            
            Source source = new DOMSource(document);
            Result result = new StreamResult(new java.io.File("resultado.xml")); //nombre del archivo
            Result console = new StreamResult(System.out);

            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.transform(source, result);
            transformer.transform(source, console);

        } catch(Exception e) {
            System.err.println("Error: "+e);
        }
    }
    
    String formatearFecha (Date f) {
        //Pasamos la fecha a formato corto.
        SimpleDateFormat formatearFecha = new SimpleDateFormat("dd/MM/yyyy");
        String cadenaFecha = formatearFecha.format(f);
        return (cadenaFecha);
    }
    
}
