package modelo;

import java.util.ArrayList; 
import java.util.List;
import java.util.Observable;
import java.util.Vector;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
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;

/**
 *Clase que guarda el proyecto
 */
public class DocumentoReq extends Observable{

    /**
     * Listado de casosdeuso
     */
    private List<CasodeUso> mCasodeUso=new ArrayList();
    /**
     * Listado de requisitos
     */
    private ArrayList<Requisito> mRequisito=new ArrayList();
    /**
     * Listado de reuniones
     */
    private ArrayList<Reunion> mReunion=new ArrayList();
    /**
     * Listado de organizaciones
     */
    private ArrayList<Organizacion> mOrganizacion=new ArrayList();
    /**
     * Listado de Objetivos
     */
    private ArrayList<Objetivo> mObjetivo=new ArrayList();
    /**
     * Listado de párrafos
     */
    private ArrayList<Parrafo> mParrafo=new ArrayList();
    /**
     * Listado de secciones
     */
    private ArrayList<Seccion> mSeccion=new ArrayList();
    /**
     * Listado de actores
     */
    private ArrayList<Actor> mActor=new ArrayList();
    /**
     * Listado de imágenes
     */
    private ArrayList<Imagen> mImagen=new ArrayList();
    /**
     * Listado de Matrices
     */
    private ArrayList<Matriz> mMatriz=new ArrayList();
    /**
     * Boolean para decidcir que hoja de estilos usar
     */
    private boolean jerarquia;
    /**
     * Constructor
     */
    public DocumentoReq () {
        jerarquia=true;
    }
    /**
     * 
     * @return CasodeUso
     */
    public List<CasodeUso> getmCasodeUso () {
        return mCasodeUso;
    }

    /**
     * 
     * @return Reuniones 
     */
    public ArrayList<Reunion> getmReunion () {
        return mReunion;
    }
    /**
     * Método que crea y guarda un objetivo
     * @param Nombre
     * @param Concepto
     * @param Importancia
     * @param Urgencia
     * @param EstadoDesarrollo
     * @param Estabilidad
     * @return Objetivo
     */
    public Objetivo newObj( String Nombre, String Concepto, String Importancia, String Urgencia, String EstadoDesarrollo, String Estabilidad ) {
        Objetivo auxObj = new Objetivo();

        auxObj.setNombre(Nombre);
        auxObj.setDescripcion(Concepto);
        auxObj.setImportancia(Importancia);
        auxObj.setUrgencia(Urgencia);
        auxObj.setEstado_desarrollo(EstadoDesarrollo);
        auxObj.setEstabilidad(Estabilidad);

        this.getmObjetivo().add(auxObj);
        return auxObj;
    }
    /**
     * Método que crea y guarda una organizacion
     * @param NombreOrg
     * @param Direccion
     * @param Telefono
     * @param Fax
     * @param Participante
     * @return Organizacion
     */
    public Organizacion newOrg(String NombreOrg, String Direccion, String Telefono, String Fax, String Participante) {
        ////Creo la instancia
        Organizacion auxOrg=new Organizacion();
        //// Asigno los valores a los atributos
        auxOrg.setNombre(NombreOrg);
        auxOrg.setDireccion(Direccion);
        auxOrg.setTelefono(Telefono);
        auxOrg.setFax(Fax);
        //auxOrg.setParticipantes(Participantes);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmOrganizacion().add(auxOrg);
        return auxOrg;
    }
    /**
     * Método que guarda y crea una reunion
     * @param Nombre
     * @param Lugar
     * @param Fecha
     * @param Hora
     * @param Asistentes
     * @param Resultados
     * @return Reunion
     */
    public Reunion newReunion(String Nombre, String Lugar, String Fecha, String Hora, String Asistentes, String Resultados) {

        ////Creo la instancia
        Reunion auxReu=new Reunion();
        //// Asigno los valores a los atributos
        auxReu.setNombre(Nombre);
        auxReu.setLugar(Lugar);
        auxReu.setFecha(Fecha);
        auxReu.setHora(Hora);
        auxReu.setParticipantes_asistentes(Asistentes);
        auxReu.setResultados(Resultados);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmReunion().add(auxReu);
        return auxReu;
    }
    /**
     * Método que crea y guarda un párrafo
     * @param nombre
     * @param parrafo
     * @return párrafo
     */
    public Parrafo newParrafo(String nombre, String parrafo) {

        ////Creo la instancia
        Parrafo auxParrafo=new Parrafo();
        //// Asigno los valores a los atributos
        auxParrafo.setNombre(nombre);
        auxParrafo.setParrafo(parrafo);
        
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmParrafo().add(auxParrafo);
        return auxParrafo;
    }
    /**
     * Método que crea y guarda un actor
     * @param nombre
     * @param descripcion
     * @return Actor
     */
    public Actor newActor(String nombre, String descripcion) {

        ////Creo la instancia
        Actor auxActor=new Actor();
        //// Asigno los valores a los atributos
        auxActor.setNombre(nombre);
        auxActor.setDescripcion(descripcion);
        
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmActor().add(auxActor);
        return auxActor;
    }
    /**
     * Método que crea y guarda una sección
     * @param nombre
     * @return sección
     */
    public Seccion newSeccion(String nombre) {

        ////Creo la instancia
        Seccion auxSeccion=new Seccion();
        //// Asigno los valores a los atributos
        auxSeccion.setNombre(nombre);
        
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmSeccion().add(auxSeccion);
        return auxSeccion;
    }
    /**
    * Método que crea y guarda una imagen
     * @param nombre
     * @param ruta
     * @return imagen
     */
    public Imagen newImg(String nombre, String ruta) {

        ////Creo la instancia
        Imagen auxImagen=new Imagen();
        //// Asigno los valores a los atributos
        auxImagen.setNombre(nombre);
        auxImagen.setRuta(ruta);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmImagen().add(auxImagen);
        return auxImagen;
    }
    /**
      * Método que crea y guarda una matriz
     * @param nombre
     * @param fila
     * @param columna
     * @return matriz
     */
    public Matriz newMatriz(String nombre, ArrayList<String> fila, ArrayList<String> columna) {

        ////Creo la instancia
        Matriz auxMatriz=new Matriz();
        //// Asigno los valores a los atributos
        auxMatriz.setNombre(nombre);
        auxMatriz.setMfila(fila);
        auxMatriz.setMcolumna(columna);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmMatriz().add(auxMatriz);
        return auxMatriz;
    }
    /**
     * 
     * @param val 
     */
    public void setmCasodeUso (ArrayList<CasodeUso> val) {
        this.mCasodeUso = val;
    }

    /**
     * Método que crea y guarda un caso de uso
     * @param nombreCU
     * @param esAbstracto
     * @param eventoActivacion
     * @param frecuencia
     * @param unidadFrecuencia
     * @param precondicion
     * @param postcondicion
     * @param importancia
     * @param urgencia
     * @param estadodesarrollo
     * @param estabilidad
     * @return Caso de Uso
     */
    public CasodeUso nuevoCU (String nombreCU, boolean esAbstracto,String eventoActivacion, int frecuencia, String unidadFrecuencia, String precondicion, String postcondicion, String importancia, String urgencia, String estadodesarrollo, String estabilidad) {

        //// Creo la instancia
        CasodeUso auxCU=new CasodeUso();
        //// Asigno los valores a los atributos
        auxCU.setNombre(nombreCU);
        auxCU.setEsAbstracto(esAbstracto);
        auxCU.setEventoActivacion(eventoActivacion);
        auxCU.setFrecuencia(frecuencia);
        auxCU.setUnidadFrecuencia(unidadFrecuencia);
        auxCU.setPrecondicion(precondicion);
        auxCU.setPostcondicion(postcondicion);
        auxCU.setImportancia(importancia);
        auxCU.setUrgencia(urgencia);
        auxCU.setEstadodeDesarrollo(estadodesarrollo);
        auxCU.setEstabilidad(estabilidad);
        
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmCasodeUso().add(auxCU);
        persist(auxCU);
        return auxCU;
    }
    
    /**
     * Método que actualiza gracias al patron observer observable
     */
    public void actualizar() {
        setChanged();
        notifyObservers();
    }
    /**
     * Método que crea y guarda un requisito de restriccion
     * @param nombreRRes
     * @param descripcionRRes
     * @param importancia
     * @param urgencia
     * @param estadodesarrollo
     * @param estabilidad
     * @return ReqRestriccion
     */
    public ReqRestriccion newRRes(String nombreRRes, String descripcionRRes, String importancia, String urgencia, String estadodesarrollo, String estabilidad) {
        ReqRestriccion auxRRes = new ReqRestriccion();
        
        auxRRes.setNombre(nombreRRes);
        auxRRes.setDescripcion(descripcionRRes);
        auxRRes.setImportancia(importancia);
        auxRRes.setUrgencia(urgencia);
        auxRRes.setEstado_desarrollo(estadodesarrollo);
        auxRRes.setEstabilidad(estabilidad);
//        auxRRes.setId(String.valueOf(mRequisito.size()));
        this.getmRequisito().add(auxRRes);
        return auxRRes;
    }

    /**
     * @return the mRequisito
     */
    public ArrayList<Requisito> getmRequisito() {
        return mRequisito;
    }

    /**
     * @param mRequisito the mRequisito to set
     */
    public void setmRequisito(ArrayList<Requisito> mRequisito) {
        this.mRequisito = mRequisito;
    }
    /**
     * Método que crea y guarda un requisito de información
     * @param nombre
     * @param concepto
     * @param vmax
     * @param vmedio
     * @param importancia
     * @param urgencia
     * @param estadodesarrollo
     * @param estabilidad
     * @param unimax
     * @param unimedio
     * @return ReqInformacion
     */
    public ReqInformacion newRInf(String nombre, String concepto, int vmax, int vmedio, String importancia, String urgencia, String estadodesarrollo, String estabilidad, String unimax, String unimedio) {
        ReqInformacion auxRInf = new ReqInformacion();
        
        auxRInf.setNombre(nombre);
        auxRInf.setConcepto(concepto);
        auxRInf.setValor_maximo(vmax);
        auxRInf.setValor_medio(vmedio);
        auxRInf.setImportancia(importancia);
        auxRInf.setUrgencia(urgencia);
        auxRInf.setEstado_desarrollo(estadodesarrollo);
        auxRInf.setEstabilidad(estabilidad);
        auxRInf.setUnidad_maximo(unimax);
        auxRInf.setUnidad_medio(unimedio);
        
        this.getmRequisito().add(auxRInf);
        return auxRInf;
    }
    /**
     * Método que crea y guarda un requisito funcional
     * @param nombre
     * @param descripcion
     * @param importancia
     * @param urgencia
     * @param estadodesarrollo
     * @param estabilidad
     * @return ReqFuncional 
     */
    public ReqFuncional newRFun(String nombre, String descripcion, String importancia, String urgencia, String estadodesarrollo, String estabilidad) {
        ReqFuncional auxRFun = new ReqFuncional();
        
        auxRFun.setNombre(nombre);
        auxRFun.setDescripcion(descripcion);
        auxRFun.setImportancia(importancia);
        auxRFun.setUrgencia(urgencia);
        auxRFun.setEstado_desarrollo(estadodesarrollo);
        auxRFun.setEstabilidad(estabilidad);
        
        this.getmRequisito().add(auxRFun);
        return auxRFun;
    }
    

    public ReqNoFuncional newRNoFun(String nombre, String descripcion, String importancia, String urgencia, String estadodesarrollo, String estabilidad) {
        ReqNoFuncional auxRNoFun = new ReqNoFuncional();
        
        auxRNoFun.setNombre(nombre);
        auxRNoFun.setDescripcion(descripcion);
        auxRNoFun.setImportancia(importancia);
        auxRNoFun.setUrgencia(urgencia);
        auxRNoFun.setEstado_desarrollo(estadodesarrollo);
        auxRNoFun.setEstabilidad(estabilidad);
        
        this.getmRequisito().add(auxRNoFun);
        return auxRNoFun;
    }
    /**
     * Pasa de Caso de Uso a documento xml
     * @param cu
     * @param result
     * @param document
     * @param raiz 
     */
    public void CasodeUsotoXML(CasodeUso cu, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_CasodeUso"); //creamos un nuevo elemento 
        }
        
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("CasodeUso") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(cu.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("esAbstracto"); //creamos un nuevo elemento
        if(cu.getEsAbstracto()==false) {
            abstracto="NO";
        }
        else {
            abstracto="SI";
        }
        Text text2 = document.createTextNode(abstracto); //Ingresamos la info
        Element elemento3= document.createElement("eventoActivacion"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(cu.getEventoActivacion()); //Ingresamos la info
        Element elemento4= document.createElement("frecuencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(String.valueOf(cu.getFrecuencia())); //Ingresamos la info
        Element elemento5= document.createElement("unidadFrecuencia"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(cu.getUnidadFrecuencia()); //Ingresamos la info
        Element elemento6= document.createElement("precondicion"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(cu.getPrecondicion()); //Ingresamos la info
        Element elemento7= document.createElement("postcondicion"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(cu.getPostcondicion()); //Ingresamos la info
        Element id= document.createElement("id"); //creamos un nuevo elemento
        Text txtid = document.createTextNode(String.valueOf(cu.getNumero_id())); //Ingresamos la info
        Element elemento8= document.createElement("importancia"); //creamos un nuevo elemento
        Text text8 = document.createTextNode(cu.getImportancia()); //Ingresamos la info
        Element elemento9= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text9 = document.createTextNode(cu.getUrgencia()); //Ingresamos la info
        Element elemento10= document.createElement("estadoDesarrollo"); //creamos un nuevo elemento
        Text text10 = document.createTextNode(cu.getEstadodeDesarrollo()); //Ingresamos la info
        Element elemento11= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text11 = document.createTextNode(cu.getEstabilidad()); //Ingresamos la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elemento8.appendChild(text8);
        elemento9.appendChild(text9);
        elemento10.appendChild(text10);
        elemento11.appendChild(text11);
        id.appendChild(txtid);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(elemento8);
        elementoA.appendChild(elemento9);
        elementoA.appendChild(elemento10);
        elementoA.appendChild(elemento11);
        elementoA.appendChild(id);
        elementoA.appendChild(tipo);
        
        Vector<Element> paso = new Vector<Element>(cu.getPasoCU().size(),1);
        
        for(int i=0; i<cu.getPasoCU().size(); i++){
             paso.add(document.createElement("paso"));
             String sele1 = new String();
             String sele2 = new String();
             Element acc = document.createElement("accion");
             Text accion= document.createTextNode(cu.getPasoCU().get(i).getAccion());
             Element cond = document.createElement("condicion");
             Text condicion= document.createTextNode(cu.getPasoCU().get(i).getCondicion());
             Element ele1 = document.createElement("esCondicional");
             if(cu.getPasoCU().get(i).isEsCondicional()==false) {
                sele1="NO";
             }
             else {
                sele1="SI";
             }
             Text txt1 = document.createTextNode(sele1); //Ingresamos la info
             Element ele2 = document.createElement("tipoAccion");
             if(cu.getPasoCU().get(i).isAccion_actor()==true) {
                sele2="El actor "+cu.getPasoCU().get(i).getActor()+" realiza la acción ";
             }
             else if (cu.getPasoCU().get(i).isAccion_sistema()==true){
                sele2="El sistema realiza la acción ";
             }
             else {
             }
             Text txt2 = document.createTextNode(sele2); //Ingresamos la info
             Element id_pas= document.createElement("id_pas"); //creamos un nuevo elemento
             Text txtid_pas = document.createTextNode(String.valueOf(cu.getPasoCU().get(i).getNumero_id())); //Ingresamos la info
             Element npaso= document.createElement("npaso"); //creamos un nuevo elemento
             Text txt_npaso = document.createTextNode(i+1 + ". ");
             
             acc.appendChild(accion);
             cond.appendChild(condicion);
             ele1.appendChild(txt1);
             ele2.appendChild(txt2);
             id_pas.appendChild(txtid_pas);
             npaso.appendChild(txt_npaso);
             paso.elementAt(i).appendChild(acc);
             paso.elementAt(i).appendChild(cond);
             paso.elementAt(i).appendChild(ele1);
             paso.elementAt(i).appendChild(ele2);
             paso.elementAt(i).appendChild(id_pas);
             paso.elementAt(i).appendChild(npaso);
             
             Vector<Element> excepcion = new Vector<Element>(cu.getPasoCU().get(i).getExcepcionCU().size(),1);
             
             for (int j=0; j<cu.getPasoCU().get(i).getExcepcionCU().size(); j++ ) {
                 String selec1 = new String();
                 excepcion.add(document.createElement("excepcion"));
                 Element e_acc = document.createElement("e_accion");
                 Text e_accion= document.createTextNode(cu.getPasoCU().get(i).getExcepcionCU().get(j).getAccion());
                 Element e_cond = document.createElement("e_condicion");
                 Text e_condicion= document.createTextNode(cu.getPasoCU().get(i).getExcepcionCU().get(j).getCondicion());
                 Element e_term = document.createElement("e_terminacion");
                 Text e_terminacion= document.createTextNode(cu.getPasoCU().get(i).getExcepcionCU().get(j).getTerminacion());
                 Element e_tipo = document.createElement("e_tipoAccion");
                 if(cu.getPasoCU().get(i).getExcepcionCU().get(j).isAccion_actor()==true) {
                    selec1="El actor "+cu.getPasoCU().get(i).getExcepcionCU().get(j).getActor()+" realiza la acción, ";
                 }
                 else if (cu.getPasoCU().get(i).getExcepcionCU().get(j).isAccion_sistema()==true){
                    selec1="El sistema realiza la acción, ";
                 }
                 else {
                 }
                 Text e_txt1 = document.createTextNode(selec1); //Ingresamos la info
                 Element id_exc= document.createElement("id_exc"); //creamos un nuevo elemento
                 Text txtid_exc = document.createTextNode(String.valueOf(cu.getPasoCU().get(i).getExcepcionCU().get(j).getNumero_id())); //Ingresamos la info
                 Element npaso2= document.createElement("npaso2"); //creamos un nuevo elemento
                 Text txt_npaso2 = document.createTextNode(i+1 + ". ");
             
                 e_acc.appendChild(e_accion);
                 e_cond.appendChild(e_condicion);
                 e_term.appendChild(e_terminacion);
                 e_tipo.appendChild(e_txt1);
                 id_exc.appendChild(txtid_exc);
                 npaso2.appendChild(txt_npaso2);
                 excepcion.elementAt(j).appendChild(e_acc);
                 excepcion.elementAt(j).appendChild(e_cond);
                 excepcion.elementAt(j).appendChild(e_term);
                 excepcion.elementAt(j).appendChild(e_tipo);
                 excepcion.elementAt(j).appendChild(id_exc);
                 excepcion.elementAt(j).appendChild(npaso2);
                 //paso.elementAt(i).appendChild(excepcion.get(j));
                 elementoA.appendChild(excepcion.get(j));
             }
             
             elementoA.appendChild(paso.elementAt(i));
             
             
        }
        
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Objetivo a documento xml 
     * @param obj
     * @param result
     * @param document
     * @param raiz 
     */
    public void ObjetivotoXML(Objetivo obj, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Objetivo"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Objetivo") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(obj.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("descripcion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(obj.getDescripcion()); //Ingresamos la info
        Element elemento3= document.createElement("importancia"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(obj.getImportancia()); //Ingresamos la info
        Element elemento4= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(obj.getUrgencia()); //Ingresamos la info
        Element elemento5= document.createElement("estado_desarrollo"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(obj.getEstado_desarrollo()); //Ingresamos la info
        Element elemento6= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(obj.getEstabilidad()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(obj.getNumero_id())); //Ingresamos la info
        
        //SUBOBJETIVOS
        Vector<Element> subobjetivo = new Vector<Element>(obj.getSubobjetivo().size(),1);
        
        for (int i=0; i<obj.getSubobjetivo().size(); i++ ) {
            subobjetivo.add(document.createElement("subobjetivo"));
            Element e_nombre = document.createElement("nombre");
            Text txte_nombre = document.createTextNode(obj.getSubobjetivo().get(i).toString());
            Element e_desc = document.createElement("descripcion");
            Text txte_desc = document.createTextNode(obj.getSubobjetivo().get(i).getDescripcion());
            
            e_nombre.appendChild(txte_nombre);
            e_desc.appendChild(txte_desc);
            subobjetivo.elementAt(i).appendChild(e_nombre);
            subobjetivo.elementAt(i).appendChild(e_desc);
            elementoA.appendChild(subobjetivo.elementAt(i));
        }
        
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    
    public void ReuniontoXML(Reunion reu, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Reunion"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Reunion") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(reu.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("lugar"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(reu.getLugar()); //Ingresamos la info
        Element elemento3= document.createElement("fecha"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(reu.getFecha()); //Ingresamos la info
        Element elemento4= document.createElement("hora"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(reu.getHora()); //Ingresamos la info
        Element elemento5= document.createElement("participantes"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(reu.getParticipantes_asistentes()); //Ingresamos la info
        Element elemento6= document.createElement("resultados"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(reu.getResultados()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(reu.getNumero_id())); //Ingresamos la info
        
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Organización a documento xml
     * @param org
     * @param result
     * @param document
     * @param raiz 
     */
    
    public void OrganizaciontoXML(Organizacion org, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Organizacion"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Organizacion") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(org.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("direccion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(org.getDireccion()); //Ingresamos la info
        Element elemento3= document.createElement("telefono"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(org.getTelefono()); //Ingresamos la info
        Element elemento4= document.createElement("fax"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(org.getFax()); //Ingresamos la info
        Element elemento5= document.createElement("id"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(String.valueOf(org.getNumero_id())); //Ingresamos la info
        
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(tipo);
        
        
        Vector<Element> participante = new Vector<Element>(org.getParticipantes().size(),1);
        
        for(int i=0; i<org.getParticipantes().size(); i++){
             String s_cliente = new String();
             String s_desarrollador = new String();
             String s_usuario = new String();
             participante.add(document.createElement("participante"));
             Element nombre = document.createElement("PAR_nombre");
             Text nombre2 = document.createTextNode(org.getParticipantes().get(i).getNombre());
             Element rol = document.createElement("rol");
             Text txtrol = document.createTextNode(org.getParticipantes().get(i).getRol());
             Element id= document.createElement("id"); //creamos un nuevo elemento
             Text txtid = document.createTextNode(String.valueOf(org.getParticipantes().get(i).getNumero_id())); //Ingresamos la info
             Element cliente = document.createElement("esCliente");
             if(org.getParticipantes().get(i).isEsCliente()==false) {
                s_cliente="NO";
             }
             else {
                s_cliente="SI";
             }
             Text txtesCliente = document.createTextNode(s_cliente); //Ingresamos la info

             Element desarrollador = document.createElement("esDesarrollador");
             if(org.getParticipantes().get(i).isEsDesarrollador()==false) {
                s_desarrollador="NO";
             }
             else {
                s_desarrollador="SI";
             }
             Text txtesDesarrollador = document.createTextNode(s_desarrollador); //Ingresamos la info

             Element usuario = document.createElement("esUsuario");
             if(org.getParticipantes().get(i).isEsUsuario()==false) {
                s_usuario="NO";
             }
             else {
                s_usuario="SI";
             }
             Text txtesUsuario = document.createTextNode(s_usuario); //Ingresamos la info

             
             nombre.appendChild(nombre2);
             rol.appendChild(txtrol);
             cliente.appendChild(txtesCliente);
             desarrollador.appendChild(txtesDesarrollador);
             usuario.appendChild(txtesUsuario);
             id.appendChild(txtid);

             participante.elementAt(i).appendChild(nombre);
             participante.elementAt(i).appendChild(rol);
             participante.elementAt(i).appendChild(cliente);
             participante.elementAt(i).appendChild(desarrollador);
             participante.elementAt(i).appendChild(usuario);
             participante.elementAt(i).appendChild(txtid);
             
             elementoA.appendChild(participante.elementAt(i));
             
             
        }
        
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de paso a documento xml
     * @param pas
     * @param result
     * @param document
     * @param raiz 
     */
    public void PasotoXML(PasoCU pas, Result result, Document document, Element raiz){
        try {
        Element elementoA = document.createElement("Objeto"); //creamos un nuevo elemento
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Paso") );
        Element elemento1= document.createElement("condicion"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(pas.getCondicion()); //Ingresamos la info
        Element elemento2= document.createElement("accion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(pas.getAccion()); //Ingresamos la info
        Element elemento3= document.createElement("id"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(String.valueOf(pas.getNumero_id())); //Ingresamos la info
        Element elemento4= document.createElement("realizador"); //creamos un nuevo elemento
        String realizador=new String();
        if(pas.isAccion_actor()==true){
            realizador="el actor";
        }else if(pas.isAccion_sistema()==true){
            realizador="el sistema";
        }
        Text text4 = document.createTextNode(realizador);

        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    
    /**
     * Pasa de Excepcion a documento xml
     * @param exc
     * @param result
     * @param document
     * @param raiz 
     */
    public void ExcepciontoXML(ExcepcionCU exc, Result result, Document document, Element raiz){
        try {
        Element elementoA = document.createElement("Objeto"); //creamos un nuevo elemento
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Excepcion") );
        Element elemento1= document.createElement("condicion"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(exc.getCondicion()); //Ingresamos la info
        Element elemento2= document.createElement("accion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(exc.getAccion()); //Ingresamos la info
        Element elemento3= document.createElement("id"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(String.valueOf(exc.getNumero_id())); //Ingresamos la info
        Element elemento4= document.createElement("realizador"); //creamos un nuevo elemento
        String realizador=new String();
        if(exc.isAccion_actor()==true){
            realizador="el actor";
        }else if(exc.isAccion_sistema()==true){
            realizador="el sistema";
        }
        Text text4 = document.createTextNode(realizador);


        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de participante a documento xml
     * @param par
     * @param result
     * @param document
     * @param raiz 
     */
    public void ParticipantetoXML(Participante par, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Participante"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Participante") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(par.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("rol"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(par.getRol()); //Ingresamos la info
        Element elemento3= document.createElement("id"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(String.valueOf(par.getNumero_id())); //Ingresamos la info
        String desarrollador=new String();
        if(par.isEsDesarrollador())
        {desarrollador="SI";}
        else
        {desarrollador="NO";}
        Element elemento4= document.createElement("desarrollador"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(desarrollador); //Ingresamos la info
        String cliente=new String();
        if(par.isEsCliente())
        {cliente="SI";}
        else
        {cliente="NO";}
        Element elemento5= document.createElement("cliente"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(cliente); //Ingresamos la info
        String usuario=new String();
        if(par.isEsUsuario())
        {usuario="SI";}
        else
        {usuario="NO";}
        Element elemento6= document.createElement("usuario"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(usuario); //Ingresamos la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Requisito Funcional a documento xml
     * @param rfu
     * @param result
     * @param document
     * @param raiz 
     */
    public void RFuncionaltoXML(ReqFuncional rfu, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_RFuncional"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("RFuncional") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(rfu.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("descripcion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(rfu.getDescripcion()); //Ingresamos la info
        Element elemento3= document.createElement("importancia"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(rfu.getImportancia()); //Ingresamos la info
        Element elemento4= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(rfu.getUrgencia()); //Ingresamos la info
        Element elemento5= document.createElement("estado_desarrollo"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(rfu.getEstado_desarrollo()); //Ingresamos la info
        Element elemento6= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(rfu.getEstabilidad()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(rfu.getNumero_id())); //Ingresamos la info la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Requisito no Funcional a documento xml
     * @param rnf
     * @param result
     * @param document
     * @param raiz 
     */
    public void RNoFuncionaltoXML(ReqNoFuncional rnf, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_RNoFuncional"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("RNoFuncional") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(rnf.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("descripcion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(rnf.getDescripcion()); //Ingresamos la info
        Element elemento3= document.createElement("importancia"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(rnf.getImportancia()); //Ingresamos la info
        Element elemento4= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(rnf.getUrgencia()); //Ingresamos la info
        Element elemento5= document.createElement("estado_desarrollo"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(rnf.getEstado_desarrollo()); //Ingresamos la info
        Element elemento6= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(rnf.getEstabilidad()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(rnf.getNumero_id())); //Ingresamos la info la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Requisito de Informacion a documento xml
     * @param rin
     * @param result
     * @param document
     * @param raiz 
     */
    public void RInformaciontoXML(ReqInformacion rin, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_RInformacion"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("RInformacion") );
        Element elemento1= document.createElement("concepto"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(rin.getConcepto()); //Ingresamos la info
        Element elemento2= document.createElement("valor_maximo"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(String.valueOf(rin.getValor_maximo())); //Ingresamos la info
        Element elemento3= document.createElement("importancia"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(rin.getImportancia()); //Ingresamos la info
        Element elemento4= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(rin.getUrgencia()); //Ingresamos la info
        Element elemento5= document.createElement("estado_desarrollo"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(rin.getEstado_desarrollo()); //Ingresamos la info
        Element elemento6= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(rin.getEstabilidad()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(rin.getNumero_id())); //Ingresamos la info la info
        Element elemento8= document.createElement("valor_medio"); //creamos un nuevo elemento
        Text text8 = document.createTextNode(String.valueOf(rin.getValor_medio())); //Ingresamos la info
        Element elemento9= document.createElement("unidad_maximo"); //creamos un nuevo elemento
        Text text9 = document.createTextNode(String.valueOf(rin.getUnidad_maximo())); //Ingresamos la info
        Element elemento10= document.createElement("unidad_medio"); //creamos un nuevo elemento
        Text text10 = document.createTextNode(String.valueOf(rin.getUnidad_medio())); //Ingresamos la info
        Element elemento11= document.createElement("nombre"); //creamos un nuevo elemento
        Text text11 = document.createTextNode(rin.getNombre()); //Ingresamos la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elemento8.appendChild(text8);
        elemento9.appendChild(text9);
        elemento10.appendChild(text10);
        elemento11.appendChild(text11);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(elemento8);
        elementoA.appendChild(elemento9);
        elementoA.appendChild(elemento10);
        elementoA.appendChild(elemento11);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Requisito de Restrccion a documento xml
     * @param rre
     * @param result
     * @param document
     * @param raiz 
     */
    public void RRestricciontoXML(ReqRestriccion rre, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_RRestriccion"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("RRestriccion") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(rre.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("descripcion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(rre.getDescripcion()); //Ingresamos la info
        Element elemento3= document.createElement("importancia"); //creamos un nuevo elemento
        Text text3 = document.createTextNode(rre.getImportancia()); //Ingresamos la info
        Element elemento4= document.createElement("urgencia"); //creamos un nuevo elemento
        Text text4 = document.createTextNode(rre.getUrgencia()); //Ingresamos la info
        Element elemento5= document.createElement("estado_desarrollo"); //creamos un nuevo elemento
        Text text5 = document.createTextNode(rre.getEstado_desarrollo()); //Ingresamos la info
        Element elemento6= document.createElement("estabilidad"); //creamos un nuevo elemento
        Text text6 = document.createTextNode(rre.getEstabilidad()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(rre.getNumero_id())); //Ingresamos la info la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento3.appendChild(text3);
        elemento4.appendChild(text4);
        elemento5.appendChild(text5);
        elemento6.appendChild(text6);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento3);
        elementoA.appendChild(elemento4);
        elementoA.appendChild(elemento5);
        elementoA.appendChild(elemento6);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de seccón a documento xml
     * @param sec
     * @param result
     * @param document
     * @param raiz 
     */
    public void SecciontoXML(Seccion sec, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Seccion"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Seccion") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(sec.getNombre()); //Ingresamos la info
        
        elemento1.appendChild(text1);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa a xml el título del proyecto
     * @param result
     * @param document
     * @param raiz 
     */
    public void DocumentotoXML(Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Documento"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Documento") );
        
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Párrafo a documento xml
     * @param prf
     * @param result
     * @param document
     * @param raiz 
     */
    public void ParrafotoXML(Parrafo prf, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Parrafo"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Parrafo") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(prf.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("parrafo"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(prf.getParrafo()); //Ingresamos la info

        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Actor a documento xml
     * @param act
     * @param result
     * @param document
     * @param raiz 
     */
    public void ActortoXML(Actor act, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Actor"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Actor") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(act.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("descripcion"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(act.getDescripcion()); //Ingresamos la info
        Element id= document.createElement("id"); //creamos un nuevo elemento
        Text txtid = document.createTextNode(String.valueOf(act.getNumero_id())); //Ingresamos la info la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        id.appendChild(txtid);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(id);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Matrix de rastreabilidad a documento xml
     * @param mat
     * @param result
     * @param document
     * @param raiz 
     */
    public void MatriztoXML(Matriz mat, Result result, Document document, Element raiz){
        try {
        //Elementos que formaran las filas y columnas de la matriz
        ArrayList<Rastreable> fila= listado(mat.getMfila());
        ArrayList<Rastreable> columna= listado(mat.getMcolumna());
        
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Matriz"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Matriz") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(mat.toString()); //Ingresamos la info
        Element id= document.createElement("id"); //creamos un nuevo elemento
        Text txtid = document.createTextNode(String.valueOf(mat.getNumero_id())); //Ingresamos la info la info
        
        Vector<Element> vfila = new Vector<Element>(fila.size(),1);
        
        //FILAS DE LA MATRIZ
        for(int i=0; i<fila.size(); i++){
                vfila.add(document.createElement("fila"));
                
                Element e_nfila=document.createElement("nom_fila");
                Text txte_nfila= document.createTextNode(fila.get(i).toString());
                
                for(int j=0; j<columna.size(); j++){
                    Element e_rastreabilidad=document.createElement("rastreabilidad");
                    Element e_rastreable=document.createElement("rastreable");
                    if(columna.get(j).buscarOrigen(fila.get(i).toString())){
                        Text txte_rastreable= document.createTextNode("SI");
                        e_rastreable.appendChild(txte_rastreable);
                    }
                    else {
                        Text txte_rastreable= document.createTextNode("NO");
                        e_rastreable.appendChild(txte_rastreable);
                    }
                    e_rastreabilidad.appendChild(e_rastreable);
                    vfila.elementAt(i).appendChild(e_rastreabilidad);
                }
                e_nfila.appendChild(txte_nfila);
                
                vfila.elementAt(i).appendChild(e_nfila);
                
                elementoA.appendChild(vfila.elementAt(i));
        }
        
        Vector<Element> vcolumna = new Vector<Element>(columna.size(),1);
        
        //COLUMNAS DE LA MATRIZ
        for(int i=0; i<columna.size();i++){
                vcolumna.add(document.createElement("columna"));
                Element e_ncolum=document.createElement("nom_colum");
                Text txte_ncolum= document.createTextNode(columna.get(i).toString());
                e_ncolum.appendChild(txte_ncolum);
                
                vcolumna.elementAt(i).appendChild(e_ncolum);
                
                elementoA.appendChild(vcolumna.elementAt(i));
        }
        
        
        elemento1.appendChild(text1);
        id.appendChild(txtid);
        
        elementoA.appendChild(elemento1);
        elementoA.appendChild(id);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    /**
     * Pasa de Imagen a documento xml
     * @param img
     * @param result
     * @param document
     * @param raiz 
     */
    public void ImagentoXML(Imagen img, Result result, Document document, Element raiz){
        try {
        Element elementoA;
        String abstracto=new String();
        if (jerarquia==true) {
           elementoA = document.createElement("Objeto"); //creamos un nuevo elemento   
        }
        else {
           elementoA = document.createElement("G_Imagen"); //creamos un nuevo elemento 
        }
        Element tipo = document.createElement("tipo");
        tipo.appendChild( document.createTextNode("Imagen") );
        Element elemento1= document.createElement("nombre"); //creamos un nuevo elemento
        Text text1 = document.createTextNode(img.getNombre()); //Ingresamos la info
        Element elemento2= document.createElement("ruta"); //creamos un nuevo elemento
        Text text2 = document.createTextNode(img.getRuta()); //Ingresamos la info
        Element elemento7= document.createElement("id"); //creamos un nuevo elemento
        Text text7 = document.createTextNode(String.valueOf(img.getNumero_id())); //Ingresamos la info la info
        elemento1.appendChild(text1);
        elemento2.appendChild(text2);
        elemento7.appendChild(text7);
        elementoA.appendChild(elemento1);
        elementoA.appendChild(elemento2);
        elementoA.appendChild(elemento7);
        elementoA.appendChild(tipo);
        raiz.appendChild(elementoA);
        Source source = new DOMSource(document);
        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);
        }
    }
    
    /**
     * Método que busca un Caso de uso y lo devuelve
     * @param ident
     * @return CAsodeUso
     */
    public CasodeUso BuscarCU (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      CasodeUso cu = null;
      while((!encontrado)&&(i<mCasodeUso.size())) {
          if(mCasodeUso.get(i).getNumero_id()==id) {
               encontrado=true;
               cu=mCasodeUso.get(i);
          } 
          i++;
         }
      return cu;
    }
    /**
     * Método que busca una Reunión y la devuelve
     * @param ident
     * @return Reunion
     */
    public Reunion BuscarREU (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      Reunion reu = null;
      while((!encontrado)&&(i<mReunion.size())) {
          if(mReunion.get(i).getNumero_id()==id) {
               encontrado=true;
               reu=mReunion.get(i);
          } 
          i++;
         }
      return reu;
    }
    /**
     * Método que busca una Organización y la devuelve
     * @param ident
     * @return Organización
     */
    public Organizacion BuscarORG (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      Organizacion org = null;
      while((!encontrado)&&(i<mOrganizacion.size())) {
          if(mOrganizacion.get(i).getNumero_id()==id) {
               encontrado=true;
               org=mOrganizacion.get(i);
          } 
          i++;
         }
      return org;
    }
    /**
     * Método que busca un Paso y lo devuelve
     * @param ident
     * @return Paso
     */
    public PasoCU BuscarPAS (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      int j=0;
      PasoCU pas = null;
      while((!encontrado)&&(i<mCasodeUso.size())) {
          while((!encontrado)&&(j<mCasodeUso.get(i).getPasoCU().size())) {
              if(mCasodeUso.get(i).getPasoCU().get(j).getNumero_id()==id) {
                   encontrado=true;
                   pas=mCasodeUso.get(i).getPasoCU().get(j);
              }
              j++;
          }
          i++;
      }
      return pas;
    }
    /**
     * Método que busca una Excepcion y la devuelve
     * @param ident
     * @return Excepcion
     */
    public ExcepcionCU BuscarEXC (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      int j=0;
      int z=0;
      ExcepcionCU exc = null;
      while((!encontrado)&&(i<mCasodeUso.size())) {
          while((!encontrado)&&(j<mCasodeUso.get(i).getPasoCU().size())) {
              while((!encontrado)&&(z<mCasodeUso.get(i).getPasoCU().get(j).getExcepcionCU().size())) {
                  if(mCasodeUso.get(i).getPasoCU().get(j).getExcepcionCU().get(z).getNumero_id()==id) {
                       encontrado=true;
                       exc=mCasodeUso.get(i).getPasoCU().get(j).getExcepcionCU().get(z);
                  }
                  z++;
              }
              j++;
          }
          i++;
      }
      return exc;
    }
    /**
     * Método que busca un Participante y lo devuelve
     * @param ident
     * @return Participante
     */
    public Participante BuscarPAR (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      int j=0;
      Participante par = null;
      while((!encontrado)&&(i<mOrganizacion.size())) {
          while((!encontrado)&&(j<mOrganizacion.get(i).getParticipantes().size())) {
              if(mOrganizacion.get(i).getParticipantes().get(j).getNumero_id()==id) {
                   encontrado=true;
                   par=mOrganizacion.get(i).getParticipantes().get(j);
              }
              j++;
          }
          i++;
      }
      return par;
    }
    /**
     * Método que busca un Objetivo y lo devuelve
     * @param ident
     * @return Objetivo
     */
    public Objetivo BuscarOBJ (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      Objetivo obj = null;
      while((!encontrado)&&(i<mObjetivo.size())) {
          if(mObjetivo.get(i).getNumero_id()==id) {
               encontrado=true;
               obj=mObjetivo.get(i);
          } 
          i++;
         }
      return obj;
    }
    /**
     * Método que busca un Requisito Funcional y lo devuelve
     * @param ident
     * @return ReqFuncional
     */
    public ReqFuncional BuscarRFU (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      ReqFuncional rfu = null;
      while((!encontrado)&&(i<mRequisito.size())) {
          if(mRequisito.get(i) instanceof ReqFuncional) {
               rfu = (ReqFuncional) mRequisito.get(i);
               if(rfu.getNumero_id()==id){
                   encontrado=true;
               }
          } 
          i++;
      }
      if(encontrado==false){
          rfu=null;
      }
      return rfu;
    }
    /**
     * Método que busca un Requisito no Funcional y lo devuelve
     * @param ident
     * @return ReqNoFuncional
     */
    public ReqNoFuncional BuscarRNF (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      ReqNoFuncional rnf = null;
      while((!encontrado)&&(i<mRequisito.size())) {
          if(mRequisito.get(i) instanceof ReqNoFuncional) {
               rnf = (ReqNoFuncional) mRequisito.get(i);
               if(rnf.getNumero_id()==id){
                   encontrado=true;
               }
          } 
          i++;
      }
      if(encontrado==false){
          rnf=null;
      }
      return rnf;
    }
    /**
     * Método que busca un Requiisto de Información y lo devuelve
     * @param ident
     * @return ReqInformación
     */
    public ReqInformacion BuscarRIN (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      ReqInformacion rin = null;
      while((!encontrado)&&(i<mRequisito.size())) {
          if(mRequisito.get(i) instanceof ReqInformacion) {
               rin = (ReqInformacion) mRequisito.get(i);
               if(rin.getNumero_id()==id){
                   encontrado=true;
               }
          } 
          i++;
      }
      if(encontrado==false){
          rin=null;
      }
      return rin;
    }
    
    /**
     * Método que busca un Requisito de Restrccion y lo devuelve
     * @param ident
     * @return ResRestriccion
     */
    public ReqRestriccion BuscarRRE (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      ReqRestriccion rre = null;
      while((!encontrado)&&(i<mRequisito.size())) {
          if(mRequisito.get(i) instanceof ReqRestriccion) {
               rre = (ReqRestriccion) mRequisito.get(i);
               if(rre.getNumero_id()==id){
                   encontrado=true;
               }
          } 
          i++;
      }
      if(encontrado==false){
          rre=null;
      }
      return rre;
    }
    /**
     * Método que busca una Imagen y la devuelve
     * @param ident
     * @return Imagen
     */
    public Imagen BuscarIMG (String ident) {
      int id = Integer.parseInt(ident);  
      boolean encontrado=false;
      int i=0;
      Imagen img = null;
      while((!encontrado)&&(i<mImagen.size())) {
          if(mImagen.get(i).getNumero_id()==id) {
               encontrado=true;
               img=mImagen.get(i);
          } 
          i++;
         }
      return img;
    }
    /**
     * Método que busca una Seccion y la devuelve
     * @param ident
     * @return Seccion
     */
    public Seccion BuscarSEC (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      Seccion sec = null;
      while((!encontrado)&&(i<mSeccion.size())) {
          if(mSeccion.get(i).getNumero_id()==id) {
               encontrado=true;
               sec=mSeccion.get(i);
          }
          i++;
         }
      return sec;
    }
    /**
     * Método que busca un Parrafo y lo devuelve
     * @param ident
     * @return Parrafo
     */
    public Parrafo BuscarPRF (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      Parrafo prf = null;
      while((!encontrado)&&(i<mParrafo.size())) {
          if(mParrafo.get(i).getNumero_id()==id) {
               encontrado=true;
               prf=mParrafo.get(i);
          }
          i++;
         }
      return prf;
    }
    /**
     * Método que busca un Actor y lo devuelve
     * @param ident
     * @return Actor
     */
    public Actor BuscarACT (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      Actor act = null;
      while((!encontrado)&&(i<mActor.size())) {
          if(mActor.get(i).getNumero_id()==id) {
               encontrado=true;
               act=mActor.get(i);
          }
          i++;
         }
      return act;
    }
    /**
     * Método que busca una Matriz y la devuelve
     * @param ident
     * @return Matriz
     */
    public Matriz BuscarMAT (String ident) {
      int id = Integer.parseInt(ident);
      boolean encontrado=false;
      int i=0;
      Matriz mat = null;
      while((!encontrado)&&(i<getmMatriz().size())) {
          if(getmMatriz().get(i).getNumero_id()==id) {
               encontrado=true;
               mat=getmMatriz().get(i);
          }
          i++;
         }
      return mat;
    }
    /**
     * @param mReunion the mReunion to set
     */
    public void setmReunion(ArrayList<Reunion> mReunion) {
        this.mReunion = mReunion;
    }

    /**
     * @return the mOrganizacion
     */
    public ArrayList<Organizacion> getmOrganizacion() {
        return mOrganizacion;
    }

    /**
     * @param mOrganizacion the mOrganizacion to set
     */
    public void setmOrganizacion(ArrayList<Organizacion> mOrganizacion) {
        this.mOrganizacion = mOrganizacion;
    }

    /**
     * @return the mObjetivo
     */
    public ArrayList<Objetivo> getmObjetivo() {
        return mObjetivo;
    }

    /**
     * @param mObjetivo the mObjetivo to set
     */
    public void setMObjetivo(ArrayList<Objetivo> mObjetivo) {
        this.mObjetivo = mObjetivo;
    }

    /**
     * @return the mParrafo
     */
    public ArrayList<Parrafo> getmParrafo() {
        return mParrafo;
    }

    /**
     * @return the mSeccion
     */
    public ArrayList<Seccion> getmSeccion() {
        return mSeccion;
    }

    /**
     * @return the mActor
     */
    public ArrayList<Actor> getmActor() {
        return mActor;
    }

    /**
     * @return the mImagen
     */
    public ArrayList<Imagen> getmImagen() {
        return mImagen;
    }

    public void persist(Object object) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("HGRequisitosPU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        try {
            em.persist(object);
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }
    /**
     * Método que recibe los nombres de los elementos que deben formar parte de las filas y 
     * de las columnas de la matriz de rastreabilidad.Se encarga de devolver un Array 
     * con los objetos que forman cada tipo de elemento.
     * @param nombre_elementos
     * @return Listado de elemento rastreables
     */
    public ArrayList<Rastreable> listado(ArrayList<String> nombre_elementos) {
          ArrayList<Rastreable> resultado= new ArrayList();
          
          for(int i=0;i<nombre_elementos.size();i++) {
                if(nombre_elementos.get(i).contains("Objetivo")) {
                    for(int j=0; j<this.getmObjetivo().size(); j++){
                            resultado.add(this.getmObjetivo().get(j));
                    }
                }
                else if(nombre_elementos.get(i).contains("Requisito de información")) {
                    for(int j=0; j<this.getmRequisito().size(); j++){
                            if (this.getmRequisito().get(j) instanceof ReqInformacion) {
                                resultado.add(this.getmRequisito().get(j));
                            }
                    }
                }
                else if(nombre_elementos.get(i).contains("Requisito de restricción")) {
                    for(int j=0; j<this.getmRequisito().size(); j++){
                            if (this.getmRequisito().get(j) instanceof ReqRestriccion) {
                                resultado.add(this.getmRequisito().get(j));
                            }
                    }
                }
                else if(nombre_elementos.get(i).contains("Requisito funcional")) {
                    for(int j=0; j<this.getmRequisito().size(); j++){
                            if (this.getmRequisito().get(j) instanceof ReqFuncional) {
                                resultado.add(this.getmRequisito().get(j));
                            }
                    }
                }
                else if(nombre_elementos.get(i).contains("Requisito no funcional")) {
                    for(int j=0; j<this.getmRequisito().size(); j++){
                            if (this.getmRequisito().get(j) instanceof ReqNoFuncional) {
                                resultado.add(this.getmRequisito().get(j));
                            }
                    }
                }
//                else if(nombre_elementos.get(i).contains("Caso de Uso")) {
//                    for(int j=0; j<this.getmCasodeUso().size(); j++){
//                            resultado.add(this.getmCasodeUso().get(j));
//                    }
//                }
                else if(nombre_elementos.get(i).contains("Actor")) {
                    for(int j=0; j<this.getmActor().size(); j++){
                            resultado.add(this.getmActor().get(j));
                    }
                }
                else if(nombre_elementos.get(i).contains("Imagen")) {
                    for(int j=0; j<this.getmImagen().size(); j++){
                            resultado.add(this.getmImagen().get(j));
                    }
                }
                else if(nombre_elementos.get(i).contains("Párrafo")) {
                    for(int j=0; j<this.getmParrafo().size(); j++){
                            resultado.add(this.getmParrafo().get(j));
                    }
                }
          }
          return resultado;
     }

    /**
     * @return the mMatriz
     */
    public ArrayList<Matriz> getmMatriz() {
        return mMatriz;
    }

    /**
     * @param mMatriz the mMatriz to set
     */
    public void setmMatriz(ArrayList<Matriz> mMatriz) {
        this.mMatriz = mMatriz;
    }
    /**
     * Método que enlaza un objeto rastreable que es destino con su corespondiente origen
     * @param origen
     * @param destino 
     */
    public void enlace_rastrea_destino(Object origen, String destino) {
        //Buscar el objeto que pertenece al identificador del destino
        //Obtienes el objeto de destino y a su matriz de origen el toString del objeto Origen
        String identificador = destino;
        int inicio = identificador.indexOf("-");
        int fin = identificador.indexOf(" ");
        String id=identificador.substring(inicio +1, fin);
        
        
        if (identificador.startsWith("[OBJ]")) {
            Objetivo obj = BuscarOBJ(id);
            obj.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[RFU]")) {
            ReqFuncional rfu = BuscarRFU(id);
            rfu.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[RNF]")) {
            ReqNoFuncional rnf = BuscarRNF(id);
            rnf.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[RIN]")) {
            ReqInformacion rin = BuscarRIN(id);
            rin.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[RRE]")) {
            ReqRestriccion rre = BuscarRRE(id);
            rre.getmOrigen().add(origen.toString());
        }
//        else if (identificador.startsWith("[CDU]")) {
//            CasodeUso cdu = BuscarCU(id);
//            cdu.getmOrigen().add(origen.toString());
//        }
        else if (identificador.startsWith("[ACT]")) {
            Actor act = BuscarACT(id);
            act.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[IMG]")) {
            Imagen img = BuscarIMG(id);
            img.getmOrigen().add(origen.toString());
        }
        else if (identificador.startsWith("[PRF]")) {
            Parrafo prf = BuscarPRF(id);
            prf.getmOrigen().add(origen.toString());
        }
        
     }
    /**
     * Método que enlaza un objeto rastreable destino con su correspondiente origen
     * @param origen
     * @param destino 
     */
    public void enlace_rastrea_origen(String origen, Object destino) {
        String identificador = origen;
        int inicio = identificador.indexOf("-");
        int fin = identificador.indexOf(" ");
        String id=identificador.substring(inicio +1, fin);
        
        
        if (identificador.startsWith("[OBJ]")) {
            Objetivo obj = BuscarOBJ(id);
            obj.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[RFU]")) {
            ReqFuncional rfu = BuscarRFU(id);
            rfu.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[RNF]")) {
            ReqNoFuncional rnf = BuscarRNF(id);
            rnf.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[RIN]")) {
            ReqInformacion rin = BuscarRIN(id);
            rin.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[RRE]")) {
            ReqRestriccion rre = BuscarRRE(id);
            rre.getmDestino().add(destino.toString());
        }
//        else if (identificador.startsWith("[CDU]")) {
//            CasodeUso cdu = BuscarCU(id);
//            cdu.getmDestino().add(destino.toString());
//        }
        else if (identificador.startsWith("[ACT]")) {
            Actor act = BuscarACT(id);
            act.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[IMG]")) {
            Imagen img = BuscarIMG(id);
            img.getmDestino().add(destino.toString());
        }
        else if (identificador.startsWith("[PRF]")) {
            Parrafo prf = BuscarPRF(id);
            prf.getmDestino().add(destino.toString());
        }
     }

    /**
     * @return the jerarquia
     */
    public boolean isJerarquia() {
        return jerarquia;
    }

    /**
     * @param jerarquia the jerarquia to set
     */
    public void setJerarquia(boolean jerarquia) {
        this.jerarquia = jerarquia;
    }

}

