Newsgroup: it.comp.java
Titolo: come scrivere i NODI in un file

Salve a tutti,
sto utilizzando i DOM per fare una scansione di un file XML. A seconda dei
tag che sono presenti del file di input devo creare un file di output, con
la stessa struttura ad albero; solo che la funzione write non accetta come
argomento un oggetto Node. come posso fare??
spero che potete darmi un suggerimento.
vi ringrazio
PP

 argomento un oggetto Node. come posso fare??
Cioé vorresti scrivere nodo per nodo nell'output? Mi sa che non puoi... 
devi creare prima in memoria tutto il dom-documento e poi farlo scrivere 
tutto. Non posso dirti di più perché sono un pò arrugginito 
sull'argomento, l'ultima volta che ho dovuto trattare dell'xml ho usato 
jdom che, per quello che dovevo fare io (leggere dei dati e creare un 
xml al volo) mi è sembrato molto pratico.
bye
DKano

 ha scritto nel messaggio
news:6cvJd.9935$2h5....@tornado.fastwebnet.it...


 quindi devo creare un nuovo file xml con i nuovi tag
Hai provato XSLT?
http://www.w3schools.com/xsl/
-- 
Ciao, 
 Guido.

 ha scritto nel messaggio 
news:mZzJd.10190$5k5.2...@twister2.libero.it...

Sicuramente lo saprai già... :)) cmq puoi agevolmente scrivere OWL tramite 
le Jena API (scaricabili qui 
http://www.hpl.hp.com/semweb/jena.htm
). Io ho 
avuto un problema simile (traduzione XML -> OWL) e l'ho risolto abbastanza 
facilemnte con JDOM e JENA. ;)
Ciao ciao
Sergio 


Carissimo Sergio,
scusami se ti chiedo un ultiriore chiarimento.
io ho un variabile che dovrebbe essere il nodo corrente, ma ha me
corrisponde sempre a tutto il documento, come posso passare da un nodo di
tipo DOCUMENT a uno di tipo ELEMENT senza che la variabile si annulli??
ti ringrazio, probabilemente non sono stato molto chiaro, ma sto proprio in
crisi in questo periodo

 ha scritto nel messaggio 
news:N6RJd.514$lB4....@twister1.libero.it...

Stai parlando di leggere un file con JDOM immagino... aiutami se non ho 
capito bene il problema...
La variabile di tipo Document contiene la reference all'intero documento, in 
pratica è quella che ti restituisce il builder con una chiamate del tipo
  Document doc = builder.build(myFile);
...vero? Scusa le continue conferme ma sto immaginando come avresti potuto 
scrivere ;)
puoi facilmente ottenere il nodo root del documento tramite
  Element XMLroot = doc.getRootElement();
e poi ciclare tra i nodi dell'XML con chiamate ricorsive oppure con qualcosa 
del genere:
  XMLchildren = XMLroot.getChildren();
  ci = XMLchildren.iterator();
        while (ci.hasNext()) {
            Element node = (Element) ci.next();
            .....
         }
ok?
In doc continui sempre a referenziare l'intero documento, mentre i singoli 
nodi sono puntati dalla variabile Element del ciclo (o della ricorsione...).
In che senso si "annulla" la variabile? Forse non ho chiaro il problema.... 
sorry! :))
Ciao ciao
Sergio 

Si il problema č quello che hai descritto tu, io utilizzavo il metodo
"getNextSibling()" per passare al nodo successivo e non "next()", con
"getNextSibling()" la variabile mi andava null. ora proverň con next.
Anche se ancora non sto utilizzando il JDOM, ma sono rimansto ancora con i
DOM, ma credo che dovrň convertirmi presto.
Ti incollo il mio codice, non ti chiedo di fare il debug altrimenti ti
ruberei del tempo preziosissimo, ma se gli puoi dare uno sguardo e dirmi se
ci sono errori gravi.
grazie mille
PP
//JAVA
import java.io.*;
import java.util.*;
import java.lang.*;
import javax.swing.*;
//DOM
import org.w3c.dom.*;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.NamedNodeMap;
//JAXP
import org.xml.sax.*;
import javax.xml.parsers.*;
import com.sun.xml.tree.XmlDocument;
import com.*;
public class traduttore
{
    int valore;
    Node currentNode;
    String nome;
    File f1;
    private Document document, doc;
    BufferedWriter out = null;
        //creo delle costanti
        public static final int top = 0;
        public static final int bottom = 1;
        public static final int and = 2;
        public static final int or = 3;
        public static final int impliesc = 4;
        public static final int equalc = 5;
        public static final int disjoint = 6;
        public static final int domain = 7;
        public static final int range = 8;
        public static final int inverse = 9;
        public static final int defindividual = 10;
        public static final int defconcept = 11;
        public static final int all = 12;
        public static final int Instanceof = 13;
        public static final int atleast = 14;
        public static final int ratom = 15;
        public static final int catom = 16;
        public static final int tells = 17;
    /** Creates a new instance of traduttore */
    public traduttore( String nome )
    {
    try {
            //determina il parser di default
            DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
            factory.setValidating(false);
            DocumentBuilder parser = factory.newDocumentBuilder();
            //acquisisce l'oggetto document dal documento XML
            document = parser.parse(new FileInputStream(nome));
            System.out.println("il documento č:" + document);
            //definisco il file di output
            f1 = new File("file_out.xml");
            DocumentBuilder db = factory.newDocumentBuilder();
            doc = db.newDocument();
            out = new BufferedWriter(new FileWriter("file_out.xml"));
             process( document );
            out.write("ciao");
            //( (XmlDocument) doc).write(new FileWriter("file_out.xml"));
        }
        catch ( SAXParseException spe)
        {
            System.err.println ( "Parse error:" + spe.getMessage());
            System.exit(1);
        }
        catch ( SAXException se )
        {
            se.printStackTrace();
        }
        catch ( FileNotFoundException fne) {
            System.err.println( "file \'" + nome + "\'not found." );
            System.exit(1);
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
        }
     /*
     * +---------------------------------------------+
     * | METODO: processChidNodes                    |
     * +---------------------------------------------+
     */
     public void processChildNodes ( NodeList children) throws IOException
    {
        if (children.getLength()!=0)
            for ( int j=0; j<children.getLength(); j++ )
               process( children.item( j ) );
    }
     /*
     * +---------------------------------------------+
     * | METODO: process                             |
     * +---------------------------------------------+
     */
      public void process ( Node currentNode ) throws IOException
    {
      Vector v = new Vector(20);
      v.addElement( "top" );
      v.addElement("bottom");
      v.addElement("and");
      v.addElement("or");
      v.addElement("impliesc");
      v.addElement("equalc");
      v.addElement("disjoint");
      v.addElement("domain");
      v.addElement("range");
      v.addElement("inverse");
      v.addElement("defindividual");
      v.addElement("defconcept");
      v.addElement("all");
      v.addElement("Instanceof");
      v.addElement("atleast");
      v.addElement("ratom");
      v.addElement("catom");
       v.addElement("tells");
        switch ( currentNode.getNodeType() )
        {
            //elabora un nodo Document
           case Node.DOCUMENT_NODE:
             // currentNode = currentNode.getNextSibling();
               Document doc = ( Document ) currentNode;
System.out.println("Document node:" + doc.getNodeName() + "\nroot element:"
+ doc.getDocumentElement().getNodeName());
              //break;
                //elabora un nodo element
            case Node.ELEMENT_NODE:
          /*      // currentNode = currentNode.getNextSibling();
                System.out.println("\nElement node:" +
currentNode.getNodeName());
                processNode(currentNode);
                NamedNodeMap attributeNodes = currentNode.getAttributes();
                for ( int i=0; i<attributeNodes.getLength(); i++ ) {
               Attr attribute = ( Attr ) attributeNodes.item( i );
               System.out.println( "\tAttribute:" + "; Value= " +
attribute.getNodeValue());
                }
                processChildNodes( currentNode.getChildNodes());
                */
        /* crea una nuova sequenza vuota */
        NamedNodeMap attr;
       String name, xmlns, num;
       Element newNode;
      /* scandisce gli elementi di v */
      int i; // indice
      String s; // elemento corrente
    //if(currentNode == null) return;
  // if(Node.ELEMENT_NODE == currentNode.getNodeType())
      //process(currentNode);
      for (i=0; i<v.size(); i++)
      {
        /* accede l'i-esimo elemento */
        s = (String) v.elementAt(i);
       if(s.equalsIgnoreCase(currentNode.getNodeValue()))
       {
        switch (i)
        {
            case top :
            out.write("<owl:Thing>");
            //doc.appendChild (newTag);
            //out.write("<owl:Nothing>");
            System.out.println("stampa case top:" + currentNode );
            attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case bottom :
                out.write("<owl:Nothing>");
           // currentNode.setNodeValue("<owl:Nothing>");
            System.out.println("stampa case bottom:" + currentNode );
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case and :
                out.write("<owl:intersectionOf>");
            //currentNode.setNodeValue("<owl:intersectionOf>");
            System.out.println("stampa case and:" + currentNode );
            attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case all :
                out.write("<owl:allValuesFrom>");
            //currentNode.setNodeValue("<owl:allValuesFrom>");
            System.out.println("stampa case all:" + currentNode );
            attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case or :
                out.write("<owl:unionOf>");
          //  currentNode.setNodeValue("<owl:unionOf>");
            System.out.println("stampa case or:" + currentNode );
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case impliesc :
                out.write("<rdfs:subClassOf>");
            //currentNode.setNodeValue("<rdfs:subClassOf>");
            attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case equalc :
                out.write("<owl:equivalentClass>");
           // currentNode.setNodeValue("<owl:equivalentClass>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case disjoint :
                out.write("<owl:disjointWith>");
           // currentNode.setNodeValue("<owl:disjointWith>");
            processChildNodes( currentNode.getChildNodes());
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            break;
            case domain :
                out.write("<rdfs:domain>");
            //currentNode.setNodeValue("<rdfs:domain>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case range :
                out.write("<rdfs:range>");
            //currentNode.setNodeValue("<rdfs:range>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case inverse :
                out.write("<owl:inverseOf>");
            //currentNode.setNodeValue("<owl:inverseOf>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
         /*
            case Instanceof :
                out.write("<owl:Nothing>");
            currentNode.setNodeValue( currentNode.getAttributes() +
"<rdf:ID=" + currentNode.getAttributes() + ">");
            attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            */
            case defindividual :
                out.write("<owl:Individual>");
        //    currentNode.setNodeValue("<owls:Individual>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
              processChildNodes( currentNode.getChildNodes());
            break;
            case atleast:
                out.write("<owl:minCardinality>");
        //    currentNode.setNodeValue("<owl:minCardinality>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
            case ratom:
                out.write("<owl:ObjectProperty>");
    //        currentNode.setNodeValue("<owl:ObjectProperty>");
             attr = currentNode.getAttributes();
            System.out.println("stampa attributo:" + attr);
            processChildNodes( currentNode.getChildNodes());
            break;
       /*     case tells:
                out.write("<owl:Nothing>");
                attr = currentNode.getAttributes();
                System.out.println("stampa attributo:" + attr);
             System.out.println("stampa quello che sta nel CASE:" +
currentNode);
              processChildNodes( currentNode.getChildNodes());
             break;*/
        }
       }//end IF
       else {
            System.out.println("stampa il valore del currentNode:" +
currentNode);
            System.out.println("stampa il tipo di nodo:" +
currentNode.getNodeType());
       }
      }//end FOR
  break;
               //elabora un nodo di testo e una sezione CDATA
            case Node.CDATA_SECTION_NODE:
            case Node.TEXT_NODE:
                Text text = ( Text ) currentNode;
                if (!text.getNodeValue().trim().equals(""));
                System.out.println("\tText:" + text.getNodeValue());
                break;
        }
    }
     /*
     * +---------------------------------------------+
     * | MAIN                                        |
     * +---------------------------------------------+
     */
      public static void main( String args[])
      {
        //prende il nome del file in input
         traduttore nome = new
traduttore(JOptionPane.showInputDialog("Digita il nome del file"));
         System.exit(0);
       }
}

 ha scritto nel messaggio 
news:1X5Kd.1541$QG6....@twister2.libero.it...

Ciao Paolo,
ad una prima vista (e secondo quanto dice il mio IDE ;)) ):
- modificherei gli import; questi dovrebbero bastare:
imort org.w3c.dom.*;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.*;
import java.util.Vector;
import javax.swing.*;
- poi ci sono le variabili:
nome (nel main), name, xmlns, num, newNode (in traduttore) che sono state 
dichiarate ma mai usate
- e la variabile privata
doc (in traduttore) a cui hai assegnato un valore che non hai piů usato
Credo che queste variabili le userai in futuro ;), ma se cosě non fosse puoi 
tranquillamente eliminarle. ;)
scusa se sono stato un pň superficiale, ma non vorrei influenzarti con mie 
scelte implementative che alla fine, non conoscendo il tuo progetto, 
potrebbero portarti fuori strada!
Ciao ciao
Sergio

 ha scritto nel messaggio
news:RT6Kd.13547$2h5....@tornado.fastwebnet.it...
