1 package com.ontotext.ordi.mapper.processor;
2
3 import java.io.File;
4 import java.io.FileNotFoundException;
5 import java.io.FileReader;
6 import java.io.Reader;
7 import java.util.ArrayList;
8 import java.util.Collections;
9 import java.util.HashMap;
10 import java.util.HashSet;
11 import java.util.Iterator;
12 import java.util.List;
13 import java.util.Map;
14 import java.util.Set;
15
16 import org.apache.log4j.Logger;
17 import org.openrdf.model.Statement;
18 import org.openrdf.model.URI;
19 import org.openrdf.rio.RDFHandler;
20 import org.openrdf.rio.RDFHandlerException;
21 import org.openrdf.rio.RDFParser;
22 import org.openrdf.rio.RDFParserFactory;
23 import org.openrdf.rio.n3.N3ParserFactory;
24
25 import com.ontotext.ordi.mapper.exceptions.IllegalMapperDescriptorFormat;
26 import com.ontotext.ordi.mapper.model.DataSource;
27 import com.ontotext.ordi.mapper.model.MapperDescriptor;
28 import com.ontotext.ordi.mapper.model.PredicatePattern;
29
30 public class N3MapperDescriptorImpl implements MapperDescriptor {
31
32 private Set<PredicatePattern> predicateSet = new HashSet<PredicatePattern>();
33 private Map<URI, DataSource> dataSources = new HashMap<URI, DataSource>();
34 private static Logger logger = Logger
35 .getLogger(N3MapperDescriptorImpl.class);
36
37 public N3MapperDescriptorImpl(File... files) {
38 if (files == null) {
39 throw new IllegalArgumentException();
40 }
41 for (int i = 0; i < files.length; i++) {
42
43 try {
44 if (files[i] == null || files[i].exists() == false) {
45 String msg = String.format("Invalid file name %s!"
46 + files[i].getAbsolutePath());
47 logger.error(msg);
48 throw new IllegalArgumentException(msg);
49 }
50 if (files[i].length() > 1024 * 1024) {
51 String msg = String.format(
52 "The file %s has lenght of %d (the maximum allowed"
53 + " is %d!", files[i].getAbsolutePath(),
54 files[i].length(), 1024 * 1024);
55 logger.error(msg);
56 throw new IllegalMapperDescriptorFormat(msg);
57 }
58
59 initialize(new FileReader(files[i]));
60
61 } catch (FileNotFoundException fe) {
62 throw new IllegalMapperDescriptorFormat(fe.getMessage(), fe);
63 }
64 }
65 }
66
67 public N3MapperDescriptorImpl(Reader reader) {
68 if (reader == null) {
69 throw new IllegalArgumentException();
70 }
71 initialize(reader);
72 }
73
74 public boolean addPattern(PredicatePattern pattern) {
75 if (pattern == null) {
76 throw new IllegalArgumentException();
77 }
78 return predicateSet.add(pattern);
79 }
80
81 public Set<PredicatePattern> listPatterns() {
82 return Collections.unmodifiableSet(predicateSet);
83 }
84
85 public boolean removePattern(PredicatePattern pattern) {
86 return predicateSet.remove(pattern);
87 }
88
89 public DataSource getDataSource(URI name) {
90 return dataSources.get(name);
91 }
92
93 private void initialize(Reader reader) {
94 RDFParserFactory factory = new N3ParserFactory();
95 RDFParser parser = factory.getParser();
96 parser.setVerifyData(true);
97 parser.setStopAtFirstError(true);
98 MapperDescriptorParser handler = new MapperDescriptorParser();
99 parser.setRDFHandler(handler);
100
101 try {
102 parser.parse(reader, OntologyMapperReader.ORDI_NS);
103 } catch (Exception pe) {
104 String msg = "Could not process MapperDescriptor!";
105 logger.error(msg);
106 throw new IllegalMapperDescriptorFormat(msg, pe);
107 }
108
109 OntologyMapperReader ontologyReader = new OntologyMapperReader(
110 handler.statements);
111 for (Iterator<DataSource> i = ontologyReader.getDataSources()
112 .iterator(); i.hasNext();) {
113 DataSource ds = i.next();
114 dataSources.put(ds.getName(), ds);
115 }
116 for (Iterator<PredicatePattern> i = ontologyReader
117 .getPredicatePatterns(this).iterator(); i.hasNext();) {
118 predicateSet.add(i.next());
119 }
120
121 validate();
122 }
123
124 private void validate() {
125 for (Iterator<PredicatePattern> i = predicateSet.iterator(); i
126 .hasNext();) {
127 PredicatePattern pattern = (PredicatePattern) i.next();
128 if (pattern.isValid() == false) {
129 logger.info(String.format("The predicate pattern %s was "
130 + "ignored because its not valid!", pattern));
131 i.remove();
132 }
133 }
134 }
135
136 private class MapperDescriptorParser implements RDFHandler {
137
138 private List<Statement> statements = new ArrayList<Statement>();
139
140 public void startRDF() throws RDFHandlerException {
141 }
142
143 public void endRDF() throws RDFHandlerException {
144 }
145
146 public void handleNamespace(String prefix, String uri)
147 throws RDFHandlerException {
148 }
149
150 public void handleStatement(Statement st) throws RDFHandlerException {
151 statements.add(st);
152 }
153
154 public void handleComment(String comment) throws RDFHandlerException {
155 }
156 }
157 }