Changeset 7859 for mauRepo


Ignore:
Timestamp:
28/01/11 14:54:56 (9 years ago)
Author:
mnagni
Message:

Implemented the SesameOntSupport?
Small refactoring on the test class

Location:
mauRepo/xml2owl/trunk
Files:
6 added
6 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/xml2owl/trunk/pom.xml

    r7779 r7859  
    4545                </dependency> 
    4646 
    47                 <!--  
    48                         Temporary dependencies due to the ndg.ontology.parser.support package, 
    49                         which hopefully will be separated in another artifact                    
    50                  --> 
     47                <!-- Temporary dependencies due to the ndg.ontology.parser.support package,  
     48                        which hopefully will be separated in another artifact --> 
    5149                <dependency> 
    5250                        <groupId>edu.stanford.smi</groupId> 
     
    102100                        <groupId>org.openrdf.sesame</groupId> 
    103101                        <artifactId>sesame-repository-api</artifactId> 
    104                         <version>2.3.0</version> 
    105                         <scope>compile</scope> 
     102                        <version>2.3.2</version> 
    106103                </dependency> 
     104 
     105                <dependency> 
     106                        <groupId>org.openrdf.sesame</groupId> 
     107                        <artifactId>sesame-repository-sail</artifactId> 
     108                        <version>2.3.2</version> 
     109                </dependency> 
     110                 
     111                <dependency> 
     112                        <groupId>org.openrdf.sesame</groupId> 
     113                        <artifactId>sesame-sail-memory</artifactId> 
     114                        <version>2.3.2</version> 
     115                </dependency> 
     116 
     117                <dependency> 
     118                        <groupId>org.openrdf.sesame</groupId> 
     119                        <artifactId>sesame-rio-rdfxml</artifactId> 
     120                        <version>2.3.2</version> 
     121                </dependency>            
    107122        </dependencies> 
    108123 
  • mauRepo/xml2owl/trunk/protege.properties

    r7799 r7859  
    11#Protege Properties 
    2 #Thu Jan 06 12:36:08 GMT 2011 
     2#Fri Jan 28 13:37:23 GMT 2011 
    33SwitchableClassDefinitionType=edu.stanford.smi.protegex.owl.ui.cls.LogicClassDefinitionWidgetType 
    44history.projects.reopen=file\:/home/users/mnagni/workspace/ESGGateway/metafor/examples/newspaper/newspaper.pprj,file\:/home/users/mnagni/workspace/ESGGateway/metafor/examples/pizza/pizza.owl.pprj 
  • mauRepo/xml2owl/trunk/src/main/java/ndg/ontology/parser/support/ProtegeeOntSupport.java

    r7799 r7859  
    149149                } 
    150150                */ 
    151                 Jena.dumpRDF(model.getOntModel(), out); 
     151                //Jena.dumpRDF(model.getOntModel(), out); 
     152                //model.getOntModel().write(out); 
    152153                /* 
    153154                OWLModelWriter writer = new OWLModelWriter(model, model.getTripleStoreModel().getTopTripleStore(), new OutputStreamWriter(out)); 
     
    160161                //model.getJenaModel().write(out, "N-TRIPLE"); 
    161162                //model.getJenaModel().write(out,  "RDF/XML-ABBREV"); 
    162                 //model.getJenaModel().write(out); 
     163                model.getJenaModel().write(out); 
    163164        } 
    164165} 
  • mauRepo/xml2owl/trunk/src/main/java/ndg/ontology/parser/support/SesameOntSupport.java

    r7757 r7859  
    22 
    33import java.io.OutputStream; 
    4 import java.net.URL; 
    5  
     4 
     5import ndg.ontology.parser.exception.IndividualException; 
    66import ndg.ontology.parser.exception.StatementSupportException; 
    77import ndg.ontology.parser.model.StatementSupport; 
    88 
    9 import org.openrdf.OpenRDFException; 
    10 import org.openrdf.repository.Repository; 
     9import org.openrdf.model.Statement; 
     10import org.openrdf.model.URI; 
     11import org.openrdf.model.Value; 
     12import org.openrdf.model.ValueFactory; 
     13import org.openrdf.model.vocabulary.RDF; 
     14import org.openrdf.model.vocabulary.RDFS; 
     15import org.openrdf.query.GraphQuery; 
     16import org.openrdf.query.MalformedQueryException; 
     17import org.openrdf.query.QueryEvaluationException; 
     18import org.openrdf.query.QueryLanguage; 
    1119import org.openrdf.repository.RepositoryConnection; 
    12 import org.openrdf.rio.RDFFormat; 
     20import org.openrdf.repository.RepositoryException; 
     21import org.openrdf.repository.RepositoryResult; 
     22import org.openrdf.rio.RDFHandlerException; 
     23import org.openrdf.rio.rdfxml.RDFXMLWriter; 
    1324import org.slf4j.Logger; 
    1425import org.slf4j.LoggerFactory; 
     
    1829        /** The Constant LOG. */ 
    1930        private static final Logger LOGGER = LoggerFactory.getLogger(SesameOntSupport.class); 
    20          
    21         private final Repository repository; 
    22  
    23         public SesameOntSupport(final Repository repository) { 
     31 
     32        private final  ValueFactory f; 
     33        private final String model; 
     34        private RepositoryConnection conn; 
     35 
     36         
     37        public RepositoryConnection getConn() { 
     38                return conn; 
     39        } 
     40         
     41        public void setConn(RepositoryConnection conn) { 
     42                this.conn = conn; 
     43        } 
     44 
     45        public SesameOntSupport(final RepositoryConnection connection, ValueFactory f, String model) { 
    2446                super(); 
    25                 this.repository = repository; 
    26         } 
    27  
     47                this.f = f; 
     48                this.model = model; 
     49                this.conn = connection; 
     50        } 
     51 
     52         
     53         
     54        /* 
     55        public final void startTransaction(boolean autocommit) throws StatementSupportException { 
     56                try { 
     57                        conn = repository.getConnection(); 
     58                        conn.setAutoCommit(autocommit); 
     59                } catch (RepositoryException e) { 
     60                        throw new StatementSupportException(e); 
     61                } 
     62        } 
     63 
     64         
     65        public final void closeTransaction(boolean closeTransaction) throws StatementSupportException { 
     66                try { 
     67                        if (conn != null && closeTransaction) { 
     68                                conn.commit(); 
     69                        } 
     70                } catch (RepositoryException e) { 
     71                        try { 
     72                                // roll back transaction 
     73                                if (conn != null) { 
     74                                        conn.rollback(); 
     75                                } 
     76                        } catch (RepositoryException re) { 
     77                                throw new StatementSupportException(re); 
     78                        } finally { 
     79                                try { 
     80                                        if (conn != null) { 
     81                                                conn.close(); 
     82                                        } 
     83                                } catch (RepositoryException se) { 
     84                                        throw new StatementSupportException(se); 
     85                                } finally { 
     86                                        conn = null; 
     87                                } 
     88                        } 
     89                } 
     90        } 
     91        */ 
     92         
    2893        @Override 
    2994        public void addComment(final String resourceURI, final String resourceIndividualURI, final String label) 
    3095                        throws StatementSupportException { 
    31                 // TODO Auto-generated method stub 
    32  
     96                addLabelComment(resourceURI, resourceIndividualURI, label, RDFS.COMMENT); 
    3397        } 
    3498 
     
    36100        public void addLabel(final String resourceURI, final String resourceIndividualURI, final String label) 
    37101                        throws StatementSupportException { 
    38                 // TODO Auto-generated method stub 
    39  
    40         } 
    41  
    42         @Override 
    43         public <T> void addLiteral(final String subjectClassURI, final String subjectIndividualURI, final String propertyURI, T objectValue) 
    44                         throws StatementSupportException { 
    45                 // TODO Auto-generated method stub 
     102                addLabelComment(resourceURI, resourceIndividualURI, label, RDFS.LABEL); 
     103        } 
     104 
     105        private void addLabelComment(final String resourceURI, final String resourceIndividualURI, final String text, URI rdfsType) throws StatementSupportException { 
     106                try { 
     107                        URI subject = createURI(resourceURI, resourceIndividualURI); 
     108                        URI predicate = rdfsType; 
     109                        Value value = f.createLiteral(text) ; 
     110                        doInsert(subject, predicate, value); 
     111                } catch (IndividualException e) { 
     112                        throw new StatementSupportException(e.getMessage()); 
     113                }                                
     114                if (LOGGER.isDebugEnabled()) { 
     115                        LOGGER.debug("Add Label" + text + " to Individual(" + resourceURI + ":" + resourceIndividualURI + ")"); 
     116                }        
     117        } 
     118         
     119        @Override 
     120        public <T> void addLiteral(final String subjectClassURI, final String subjectIndividualURI, 
     121                        final String propertyURI, T objectValue) throws StatementSupportException { 
     122                try { 
     123                        URI subject = createURI(subjectClassURI, subjectIndividualURI); 
     124                        URI predicate = f.createURI(subjectClassURI); 
     125                        Value value = f.createLiteral((String)objectValue) ; 
     126                        doInsert(subject, predicate, value);                     
     127                } catch (IndividualException e) { 
     128                        throw new StatementSupportException(e.getMessage()); 
     129                }                                
     130                if (LOGGER.isDebugEnabled()) { 
     131                        LOGGER.debug("Add Literal" + objectValue.toString() + " to Individual(" + subjectClassURI + ":" + subjectIndividualURI + ")");   
     132                } 
    46133 
    47134        } 
     
    50137        public void addProperty(final String subjectClassURI, final String subjectIndividualURI, final String propertyURI, 
    51138                        final String objectClassURI, final String objectIndividualURI) throws StatementSupportException { 
    52                 try { 
    53                         RepositoryConnection con = repository.getConnection(); 
    54                         try { 
    55                                 URL url = new URL("http://example.org/example/remote"); 
    56                                 con.add(url, url.toString(), RDFFormat.RDFXML); 
    57                         } finally { 
    58                                 con.close(); 
    59                         } 
    60                 } catch (OpenRDFException e) { 
    61                         throw new StatementSupportException(e); 
    62                 } catch (java.io.IOException e) { 
    63                         throw new StatementSupportException(e); 
    64                 } 
     139 
     140                try { 
     141                        URI subject = createURI(subjectClassURI, subjectIndividualURI); 
     142                        URI predicate = createURI(objectClassURI, objectIndividualURI);                  
     143                        Value value = createURI(objectClassURI, objectIndividualURI); 
     144                        doInsert(subject, predicate, value); 
     145                } catch (IndividualException e) { 
     146                        throw new StatementSupportException(e.getMessage()); 
     147                }        
    65148 
    66149        } 
     
    68151        @Override 
    69152        public void dump(final OutputStream out) throws StatementSupportException { 
    70                 // TODO Auto-generated method stub 
    71  
    72         } 
    73  
     153                //startTransaction(false); 
     154                try { 
     155                        String queryString = "CONSTRUCT * FROM {} predicate {}"; 
     156                        GraphQuery graphQuery = conn.prepareGraphQuery(QueryLanguage.SERQL, queryString); 
     157                        RDFXMLWriter rdfXMLWriter = new RDFXMLWriter(out); 
     158                        graphQuery.evaluate(rdfXMLWriter); 
     159                } catch (RepositoryException e) { 
     160                        throw new StatementSupportException(e); 
     161                } catch (MalformedQueryException e) { 
     162                        throw new StatementSupportException(e); 
     163                } catch (QueryEvaluationException e) { 
     164                        throw new StatementSupportException(e); 
     165                } catch (RDFHandlerException e) { 
     166                        throw new StatementSupportException(e); 
     167                } 
     168                //closeTransaction(); 
     169        } 
     170 
     171        private void doInsert(URI subject, URI predicate, Value value) throws StatementSupportException { 
     172                try { 
     173                        conn.add(subject, predicate, value); 
     174                } catch (RepositoryException e) { 
     175                        throw new StatementSupportException(e); 
     176                } 
     177        } 
     178 
     179        /* 
     180        private void checkConnectionOpen() throws StatementSupportException { 
     181                if (conn == null) { 
     182                        startTransaction(false); 
     183                        if (LOGGER.isInfoEnabled()) { 
     184                                LOGGER.info("Connection open with property autocommit=FALSE");   
     185                        } 
     186                } 
     187        } 
     188 
     189        private void checkCloseConnection() throws StatementSupportException { 
     190                try { 
     191                        if (conn != null && conn.isAutoCommit()) { 
     192                                 
     193                                if (LOGGER.isInfoEnabled()) { 
     194                                        LOGGER.info("Connection open with property autocommit=FALSE");   
     195                                } 
     196                        } 
     197                } catch (RepositoryException e) { 
     198                        // TODO Auto-generated catch block 
     199                        e.printStackTrace(); 
     200                } 
     201        } 
     202        */ 
     203        private URI createURI(final String classURI, final String individualURI) throws IndividualException, StatementSupportException { 
     204                if (classURI == null) { 
     205                        throw new IndividualException("classURI null"); 
     206                } 
     207 
     208                if (individualURI == null) { 
     209                        throw new IndividualException("individualURI null"); 
     210                } 
     211 
     212                String indURI = individualURI.replaceAll("\\s", "_"); 
     213                URI subject = f.createURI(model + "#" + indURI); 
     214                RepositoryResult<Statement> statements = null; 
     215                try { 
     216                        conn.getStatements(subject, null, null, true); 
     217                        statements = conn.getStatements(subject, null, null, true); 
     218                        if (statements == null || !statements.hasNext()) { 
     219                                URI predicate = RDF.TYPE; 
     220                                Value value = f.createURI(classURI); 
     221                                conn.add(subject, predicate, value); 
     222                        } 
     223                } catch (RepositoryException e) { 
     224                        throw new IndividualException(e); 
     225                } finally { 
     226                        if (statements != null) { 
     227                                try { 
     228                                        statements.close(); 
     229                                } catch (RepositoryException e) { 
     230                                        throw new IndividualException(e); 
     231                                }                                
     232                        } 
     233                } 
     234                return subject; 
     235        } 
    74236} 
  • mauRepo/xml2owl/trunk/src/test/java/ndg/ontology/parser/OntSupportFactory.java

    r7779 r7859  
    55import ndg.ontology.parser.support.JenaOntSupport; 
    66import ndg.ontology.parser.support.ProtegeeOntSupport; 
     7import ndg.ontology.parser.support.SesameOntSupport; 
     8 
     9import org.openrdf.model.URI; 
     10import org.openrdf.model.Value; 
     11import org.openrdf.model.ValueFactory; 
     12import org.openrdf.model.vocabulary.RDF; 
     13import org.openrdf.model.vocabulary.RDFS; 
     14import org.openrdf.query.GraphQuery; 
     15import org.openrdf.query.MalformedQueryException; 
     16import org.openrdf.query.QueryEvaluationException; 
     17import org.openrdf.query.QueryLanguage; 
     18import org.openrdf.repository.Repository; 
     19import org.openrdf.repository.RepositoryConnection; 
     20import org.openrdf.repository.RepositoryException; 
     21import org.openrdf.repository.sail.SailRepository; 
     22import org.openrdf.rio.RDFHandlerException; 
     23import org.openrdf.rio.rdfxml.RDFXMLWriter; 
     24import org.openrdf.sail.memory.MemoryStore; 
    725 
    826import com.hp.hpl.jena.ontology.OntDocumentManager; 
     
    1230import edu.stanford.smi.protegex.owl.ProtegeOWL; 
    1331 
     32 
    1433public class OntSupportFactory { 
    1534        public static StatementSupport getJenaSupport(String model) { 
     
    1837                return new JenaOntSupport(OntDocumentManager.getInstance().getOntology(ont1, OntModelSpec.OWL_MEM)); 
    1938        } 
    20          
     39 
    2140        public static StatementSupport getProtegeeSupport(String model) throws ResourceNotAvailable { 
    2241                try { 
     
    2443                } catch (OntologyLoadException e) { 
    2544                        throw new ResourceNotAvailable(e); 
    26                 }  
     45                } 
     46        } 
     47 
     48        public static StatementSupport getSesameSupport(String model) throws ResourceNotAvailable { 
     49                Repository repository = new SailRepository(new MemoryStore()); 
     50                try { 
     51                        repository.initialize(); 
     52                        RepositoryConnection conn = repository.getConnection(); 
     53                        conn.setAutoCommit(false); 
     54                        return new SesameOntSupport(conn, repository.getValueFactory(), model);                  
     55                } catch (RepositoryException e) { 
     56                        throw new ResourceNotAvailable(e); 
     57                } 
     58        } 
     59         
     60        /** 
     61         * {@inheritDoc} 
     62         *  
     63         * Note that this method will wrap the insertion of all triples in a single transaction, which will be rolled back if anything goes wrong. 
     64         */ 
     65         
     66        private static void insert(Repository repository, String model) { 
     67 
     68                RepositoryConnection conn = null; 
     69                try { 
     70                        conn = repository.getConnection(); 
     71                        // execute in transaction to insert all triples at once or none 
     72                        conn.setAutoCommit(false); 
     73 
     74                         
     75                                ValueFactory f = repository.getValueFactory(); 
     76                                 
     77                                URI subject = f.createURI(model + "#ae7b1bc4-d3a5-11df-837f-00163e9152a5"); 
     78                                URI predicate = RDF.TYPE; 
     79                                Value value = f.createURI("http://www.earthsystemgrid.org/esg.owl#Experiment") ; 
     80                                conn.add(subject, predicate, value); 
     81 
     82                                predicate = RDFS.LABEL ; 
     83                                value = f.createLiteral("Pescribed SST experiment") ; 
     84                                conn.add(subject, predicate, value); 
     85                                  
     86                                predicate = RDFS.COMMENT ; 
     87                                value = f.createLiteral("Pescribed SST experiment") ; 
     88                                conn.add(subject, predicate, value); 
     89                                 
     90                                predicate = f.createURI("http://www.earthsystemgrid.org/esg.owl#hasExperimentRationale") ; 
     91                                value = f.createLiteral("Initialize 10-year simulations") ; 
     92                                conn.add(subject, predicate, value); 
     93                                 
     94                                predicate = f.createURI("http://www.earthsystemgrid.org/esg.owl#hasExperimentalRequirement") ; 
     95                                value = f.createURI("http://ontologies.ucar.edu/owl/esd_data.owl#bc.050") ; 
     96                                conn.add(subject, predicate, value); 
     97                                /* 
     98                                Literal literal = f.createLiteral("ae7b1bc4-d3a5-11df-837f-00163e9152a5"); 
     99                                URI id = RDF.TYPE; 
     100                                Value value = f.createURI("http://www.earthsystemgrid.org/esg.owl#Experiment") ; 
     101*/ 
     102                        conn.commit(); // commit transaction 
     103                        String queryString = "CONSTRUCT * FROM {} predicate {}"; 
     104 
     105                        GraphQuery graphQuery = conn.prepareGraphQuery(QueryLanguage.SERQL, queryString); 
     106 
     107                        RDFXMLWriter rdfXMLWriter = new RDFXMLWriter(System.out); 
     108 
     109                        graphQuery.evaluate(rdfXMLWriter); 
     110 
     111                } catch (RepositoryException e) { 
     112                        try { 
     113                                // roll back transaction 
     114                                if (conn != null) { 
     115                                        conn.rollback(); 
     116                                } 
     117                        } catch (RepositoryException re) { 
     118                                re.printStackTrace(); 
     119                        } 
     120 
     121                } catch (MalformedQueryException e) { 
     122                        // TODO Auto-generated catch block 
     123                        e.printStackTrace(); 
     124                } catch (QueryEvaluationException e) { 
     125                        // TODO Auto-generated catch block 
     126                        e.printStackTrace(); 
     127                } catch (RDFHandlerException e) { 
     128                        // TODO Auto-generated catch block 
     129                        e.printStackTrace(); 
     130                } finally { 
     131                        try { 
     132                                if (conn != null) { 
     133                                        conn.close(); 
     134                                } 
     135                        } catch (RepositoryException e) { 
     136                                e.printStackTrace(); 
     137                        } 
     138                } 
    27139        } 
    28140} 
  • mauRepo/xml2owl/trunk/src/test/java/ndg/ontology/parser/TestBindDOM.java

    r7799 r7859  
    1717import ndg.ontology.parser.exception.StatementSupportException; 
    1818import ndg.ontology.parser.model.StatementSupport; 
     19import ndg.ontology.parser.support.SesameOntSupport; 
    1920import net.sf.saxon.xqj.SaxonXQDataSource; 
    2021 
     22import org.junit.Before; 
    2123import org.junit.Test; 
     24import org.openrdf.repository.RepositoryConnection; 
     25import org.openrdf.repository.RepositoryException; 
    2226import org.xml.sax.SAXException; 
    2327 
     
    2630public class TestBindDOM { 
    2731 
     32        private String select = null; 
     33        private StatementSupport ss = null; 
     34        private NdgOntParser ontParser = null; 
     35        OutputStream os = null; 
     36         
     37        @Before  
     38        public void initialize() { 
     39                select = "experiment"; 
     40                //select = "cmip5"; 
     41        } 
     42         
    2843        /** 
    2944         * @param args 
     
    3550         * @throws ResourceNotAvailable 
    3651         * @throws OntologyLoadException 
    37          * @throws XQException  
    38          * @throws StatementSupportException  
     52         * @throws XQException 
     53         * @throws StatementSupportException 
     54         * @throws RepositoryException 
    3955         */ 
    4056        @Test 
    41         public void doTest() throws ParserConfigurationException, SAXException, IOException, XPathExpressionException, 
    42                         ResourceNotAvailable, JAXBException, XQException, StatementSupportException { 
     57        public void doTestSesameSupport() throws ParserConfigurationException, SAXException, IOException, 
     58                        XPathExpressionException, ResourceNotAvailable, JAXBException, XQException, StatementSupportException, 
     59                        RepositoryException { 
     60                File[] files = prepareIngest("sesame"); 
     61                ((SesameOntSupport) ss).getConn().setAutoCommit(false); 
     62                 
     63                doIngest(files); 
    4364 
    44                 //initialize the parser 
    45                 NdgOntParser ontParser = new NdgOntParser(getIngesterConfig(),  
    46                                 getStatementSupport(),  
    47                                 new SaxonXQDataSource()); 
     65                ((SesameOntSupport) ss).getConn().commit(); 
    4866 
    49                 //standard loop over the documents 
    50                 String rootPath = "/home/users/mnagni/workspace/ESGGateway/metafor/src/test/resources"; 
     67                os = new FileOutputStream("ontSesameParserOut.owl"); 
     68                ontParser.dump(os); 
     69                os.close();              
     70                closeTransaction(((SesameOntSupport) ss).getConn()); 
     71        } 
    5172 
    52                 String path = rootPath + "/sample_cmip5qn_100930_mark.xml"; 
    53                 //String path = rootPath + "/PersistedXML"; 
     73        @Test 
     74        public void doTestProtegeeSupport() throws ParserConfigurationException, SAXException, IOException, 
     75                        XPathExpressionException, ResourceNotAvailable, JAXBException, XQException, StatementSupportException, 
     76                        RepositoryException { 
     77                File[] files = prepareIngest("protegee"); 
    5478                 
    55                 File[] files = getPaths(path); 
     79                doIngest(files); 
     80 
     81                os = new FileOutputStream("ontProtegeeParserOut.owl"); 
     82                ontParser.dump(os); 
     83                os.close(); 
     84        } 
     85         
     86        private File[] prepareIngest(String type) throws ResourceNotAvailable { 
     87                ss = getStatementSupport(type); 
     88                ontParser = new NdgOntParser(getIngesterConfig(), ss, new SaxonXQDataSource()); 
     89 
     90                File rootPath = getDocument(); 
     91                File[] files = { rootPath }; 
     92                if (rootPath.isDirectory()) { 
     93                        files = getPaths(rootPath.getPath()); 
     94                } 
     95                return files; 
     96        } 
     97         
     98        private void doIngest(File[] files) throws ResourceNotAvailable, XPathExpressionException, XQException, ParserConfigurationException, SAXException, IOException, JAXBException, StatementSupportException { 
    5699                for (File file : files) { 
    57                         InputStream xmlDoc = new FileInputStream(file);  
     100                        InputStream xmlDoc = new FileInputStream(file); 
    58101                        ontParser.ingest(xmlDoc); 
    59102                } 
    60                 OutputStream os = new FileOutputStream("ontParserOut.owl"); 
    61                 ontParser.dump(os); 
    62103        } 
    63104         
    64         private File[] getPaths(String path) {           
    65             if (path != null) { 
    66                 File file = new File(path); 
    67                 if (file.isDirectory()) { 
    68                         return file.listFiles(); 
    69                 } else { 
    70                         return new File[]{file}; 
    71                 } 
    72             }            
    73                 return null;             
     105        private final void closeTransaction(RepositoryConnection conn) throws StatementSupportException { 
     106                try { 
     107                        if (conn != null) { 
     108                                conn.commit(); 
     109                        } 
     110                } catch (RepositoryException e) { 
     111                        try { 
     112                                // roll back transaction 
     113                                if (conn != null) { 
     114                                        conn.rollback(); 
     115                                } 
     116                        } catch (RepositoryException re) { 
     117                                throw new StatementSupportException(re); 
     118                        } finally { 
     119                                try { 
     120                                        if (conn != null) { 
     121                                                conn.close(); 
     122                                        } 
     123                                } catch (RepositoryException se) { 
     124                                        throw new StatementSupportException(se); 
     125                                } finally { 
     126                                        conn = null; 
     127                                } 
     128                        } 
     129                } 
    74130        } 
    75          
    76         private StatementSupport getStatementSupport() throws ResourceNotAvailable {     
    77                 return OntSupportFactory.getProtegeeSupport("http://ontologies.ucar.edu/owl/esg_data.owl"); 
    78                 //return OntSupportFactory.getProtegeeSupport("http://ontologies.ucar.edu/owl/cim.owl"); 
    79                 //return OntSupportFactory.getJenaSupport("http://ontologies.ucar.edu/owl/esg_data.owl"); 
     131 
     132        private File[] getPaths(String path) { 
     133                if (path != null) { 
     134                        File file = new File(path); 
     135                        if (file.isDirectory()) { 
     136                                return file.listFiles(); 
     137                        } else { 
     138                                return new File[] { file }; 
     139                        } 
     140                } 
     141                return null; 
    80142        } 
    81          
    82         private InputStream getIngesterConfig() { 
    83                 String sample = "/ingesterConfig.xml"; 
    84                 //String sample = "/experimentIngestConfig.xml"; 
     143 
     144        private File getDocument() { 
     145                if (select.equals("experiment")) { 
     146                        return new File(TestBindDOM.class.getClassLoader().getResource("PersistedXML").getPath()); 
     147                } else if (select.equals("cimp5")) { 
     148                        return new File(TestBindDOM.class.getClassLoader().getResource("sample_cmip5qn_100930_mark.xml").getPath()); 
     149                } else { 
     150                        return new File(TestBindDOM.class.getClassLoader().getResource("sample_cmip5qn_100930_mark.xml").getPath()); 
     151                } 
     152        } 
     153 
     154        private StatementSupport getStatementSupport(String type) throws ResourceNotAvailable {          
     155                String model = null; 
     156                StatementSupport ss = null; 
     157                if (select.equals("experiment")) { 
     158                        model = "http://ontologies.ucar.edu/owl/esg_data.owl"; 
     159                } else if (select.equals("cimp5")) { 
     160                        model = "http://ontologies.ucar.edu/owl/cim.owl"; 
     161                } else { 
     162                        throw new ResourceNotAvailable("The required model does not exist!"); 
     163                } 
     164                 
     165                if (type.equals("protegee")) { 
     166                        ss = OntSupportFactory.getProtegeeSupport(model); 
     167                } else if (type.equals("sesame")) { 
     168                        ss = OntSupportFactory.getSesameSupport(model); 
     169                } else if (type.equals("jena")) { 
     170                        ss = OntSupportFactory.getJenaSupport(model);  
     171                }  
     172                return ss; 
     173        } 
     174 
     175        private InputStream getIngesterConfig() throws ResourceNotAvailable { 
     176                String sample = null; 
     177                if (select.equals("experiment")) { 
     178                        sample = "/experimentIngestConfig.xml"; 
     179                } else if (select.equals("cimp5")) { 
     180                        sample = "/ingesterConfig.xml"; 
     181                } else { 
     182                        throw new ResourceNotAvailable("The mapping model does not exist!"); 
     183                } 
    85184                return getClass().getResourceAsStream(sample); 
    86185        } 
     186 
    87187} 
Note: See TracChangeset for help on using the changeset viewer.