KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > syndication > io > impl > DCModuleParser


1 /*
2  * Copyright 2004 Sun Microsystems, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */

17 package com.sun.syndication.io.impl;
18
19 import com.sun.syndication.feed.module.DCModuleImpl;
20 import com.sun.syndication.feed.module.DCSubjectImpl;
21 import com.sun.syndication.feed.module.Module;
22 import com.sun.syndication.feed.module.DCModule;
23 import com.sun.syndication.feed.module.DCSubject;
24 import com.sun.syndication.io.ModuleParser;
25 import org.jdom.Attribute;
26 import org.jdom.Element;
27 import org.jdom.Namespace;
28
29 import java.util.ArrayList JavaDoc;
30 import java.util.Iterator JavaDoc;
31 import java.util.List JavaDoc;
32
33 /**
34  * Parser for the Dublin Core module.
35  */

36 public class DCModuleParser implements ModuleParser {
37
38     private static final String JavaDoc RDF_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
39     private static final String JavaDoc TAXO_URI = "http://purl.org/rss/1.0/modules/taxonomy/";
40
41     private static final Namespace DC_NS = Namespace.getNamespace(DCModule.URI);
42     private static final Namespace RDF_NS = Namespace.getNamespace(RDF_URI);
43     private static final Namespace TAXO_NS = Namespace.getNamespace(TAXO_URI);
44
45     public final String JavaDoc getNamespaceUri() {
46         return DCModule.URI;
47     }
48
49     private final Namespace getDCNamespace() {
50         return DC_NS;
51     }
52
53     private final Namespace getRDFNamespace() {
54         return RDF_NS;
55     }
56
57     private final Namespace getTaxonomyNamespace() {
58         return TAXO_NS;
59     }
60
61     /**
62      * Parse an element tree and return the module found in it.
63      * <p>
64      * @param dcRoot the root element containing the module elements.
65      * @return the module parsed from the element tree, <i>null</i> if none.
66      */

67     public Module parse(Element dcRoot) {
68         boolean foundSomething = false;
69         DCModule dcm = new DCModuleImpl();
70
71         List JavaDoc eList = dcRoot.getChildren("title", getDCNamespace());
72         if (eList.size() > 0) {
73             foundSomething = true;
74             dcm.setTitles(parseElementList(eList));
75         }
76         eList = dcRoot.getChildren("creator", getDCNamespace());
77         if (eList.size() > 0) {
78             foundSomething = true;
79             dcm.setCreators(parseElementList(eList));
80         }
81         eList = dcRoot.getChildren("subject", getDCNamespace());
82         if (eList.size() > 0) {
83             foundSomething = true;
84             dcm.setSubjects(parseSubjects(eList));
85         }
86         eList = dcRoot.getChildren("description", getDCNamespace());
87         if (eList.size() > 0) {
88             foundSomething = true;
89             dcm.setDescriptions(parseElementList(eList));
90         }
91         eList = dcRoot.getChildren("publisher", getDCNamespace());
92         if (eList.size() > 0) {
93             foundSomething = true;
94             dcm.setPublishers(parseElementList(eList));
95         }
96         eList = dcRoot.getChildren("contributor", getDCNamespace());
97         if (eList.size() > 0) {
98             foundSomething = true;
99             dcm.setContributors(parseElementList(eList));
100         }
101         eList = dcRoot.getChildren("date", getDCNamespace());
102         if (eList.size() > 0) {
103             foundSomething = true;
104             dcm.setDates(parseElementListDate(eList));
105         }
106         eList = dcRoot.getChildren("type", getDCNamespace());
107         if (eList.size() > 0) {
108             foundSomething = true;
109             dcm.setTypes(parseElementList(eList));
110         }
111         eList = dcRoot.getChildren("format", getDCNamespace());
112         if (eList.size() > 0) {
113             foundSomething = true;
114             dcm.setFormats(parseElementList(eList));
115         }
116         eList = dcRoot.getChildren("identifier", getDCNamespace());
117         if (eList.size() > 0) {
118             foundSomething = true;
119             dcm.setIdentifiers(parseElementList(eList));
120         }
121         eList = dcRoot.getChildren("source", getDCNamespace());
122         if (eList.size() > 0) {
123             foundSomething = true;
124             dcm.setSources(parseElementList(eList));
125         }
126         eList = dcRoot.getChildren("language", getDCNamespace());
127         if (eList.size() > 0) {
128             foundSomething = true;
129             dcm.setLanguages(parseElementList(eList));
130         }
131         eList = dcRoot.getChildren("relation", getDCNamespace());
132         if (eList.size() > 0) {
133             foundSomething = true;
134             dcm.setRelations(parseElementList(eList));
135         }
136         eList = dcRoot.getChildren("coverage", getDCNamespace());
137         if (eList.size() > 0) {
138             foundSomething = true;
139             dcm.setCoverages(parseElementList(eList));
140         }
141         eList = dcRoot.getChildren("rights", getDCNamespace());
142         if (eList.size() > 0) {
143             foundSomething = true;
144             dcm.setRightsList(parseElementList(eList));
145         }
146
147         return (foundSomething) ? dcm : null;
148     }
149
150     /**
151      * Utility method to parse a taxonomy from an element.
152      * <p>
153      * @param desc the taxonomy description element.
154      * @return the string contained in the resource of the element.
155      */

156     protected final String JavaDoc getTaxonomy(Element desc) {
157         String JavaDoc d = null;
158         Element taxo = desc.getChild("topic", getTaxonomyNamespace());
159         if (taxo!=null) {
160             Attribute a = taxo.getAttribute("resource", getRDFNamespace());
161             if (a!=null) {
162                 d = a.getValue();
163             }
164         }
165         return d;
166     }
167
168     /**
169      * Utility method to parse a list of subjects out of a list of elements.
170      * <p>
171      * @param eList the element list to parse.
172      * @return a list of subjects parsed from the elements.
173      */

174     protected final List JavaDoc parseSubjects(List JavaDoc eList) {
175         List JavaDoc subjects = new ArrayList JavaDoc();
176         for (Iterator JavaDoc i = eList.iterator(); i.hasNext();) {
177             Element eSubject = (Element) i.next();
178             Element eDesc = eSubject.getChild("Description", getRDFNamespace());
179             if (eDesc != null) {
180                 String JavaDoc taxonomy = getTaxonomy(eDesc);
181                 List JavaDoc eValues = eDesc.getChildren("value", getRDFNamespace());
182                 for (Iterator JavaDoc v = eValues.iterator(); v.hasNext();) {
183                     Element eValue = (Element) v.next();
184                     DCSubject subject = new DCSubjectImpl();
185                     subject.setTaxonomyUri(taxonomy);
186                     subject.setValue(eValue.getText());
187                     subjects.add(subject);
188                 }
189             } else {
190                 DCSubject subject = new DCSubjectImpl();
191                 subject.setValue(eSubject.getText());
192                 subjects.add(subject);
193             }
194         }
195
196         return subjects;
197     }
198
199     /**
200      * Utility method to parse a list of strings out of a list of elements.
201      * <p>
202      * @param eList the list of elements to parse.
203      * @return the list of strings
204      */

205     protected final List JavaDoc parseElementList(List JavaDoc eList) {
206         List JavaDoc values= new ArrayList JavaDoc();
207         for (Iterator JavaDoc i = eList.iterator(); i.hasNext();) {
208             Element e = (Element) i.next();
209             values.add(e.getText());
210         }
211
212         return values;
213     }
214
215     /**
216      * Utility method to parse a list of dates out of a list of elements.
217      * <p>
218      * @param eList the list of elements to parse.
219      * @return the list of dates.
220      */

221     protected final List JavaDoc parseElementListDate(List JavaDoc eList) {
222         List JavaDoc values = new ArrayList JavaDoc();
223         for (Iterator JavaDoc i = eList.iterator(); i.hasNext();) {
224             Element e = (Element) i.next();
225             values.add(DateParser.parseW3CDateTime(e.getText()));
226         }
227
228         return values;
229     }
230 }
231
Popular Tags