001    // $HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcbase/XMLFactory.java $
002    /*----------------------------------------------------------------------------
003     This file is part of deegree, http://deegree.org/
004     Copyright (C) 2001-2009 by:
005       Department of Geography, University of Bonn
006     and
007       lat/lon GmbH
008    
009     This library is free software; you can redistribute it and/or modify it under
010     the terms of the GNU Lesser General Public License as published by the Free
011     Software Foundation; either version 2.1 of the License, or (at your option)
012     any later version.
013     This library is distributed in the hope that it will be useful, but WITHOUT
014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016     details.
017     You should have received a copy of the GNU Lesser General Public License
018     along with this library; if not, write to the Free Software Foundation, Inc.,
019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020    
021     Contact information:
022    
023     lat/lon GmbH
024     Aennchenstr. 19, 53177 Bonn
025     Germany
026     http://lat-lon.de/
027    
028     Department of Geography, University of Bonn
029     Prof. Dr. Klaus Greve
030     Postfach 1147, 53001 Bonn
031     Germany
032     http://www.geographie.uni-bonn.de/deegree/
033    
034     e-mail: info@deegree.org
035    ----------------------------------------------------------------------------*/
036    package org.deegree.ogcbase;
037    
038    import java.io.ByteArrayInputStream;
039    import java.net.URI;
040    
041    import org.deegree.datatypes.CodeList;
042    import org.deegree.datatypes.time.TimeDuration;
043    import org.deegree.datatypes.time.TimePeriod;
044    import org.deegree.datatypes.time.TimePosition;
045    import org.deegree.datatypes.time.TimeSequence;
046    import org.deegree.datatypes.values.Interval;
047    import org.deegree.datatypes.values.TypedLiteral;
048    import org.deegree.datatypes.values.Values;
049    import org.deegree.datatypes.xlink.SimpleLink;
050    import org.deegree.framework.log.ILogger;
051    import org.deegree.framework.log.LoggerFactory;
052    import org.deegree.framework.util.StringTools;
053    import org.deegree.framework.util.TimeTools;
054    import org.deegree.framework.xml.XMLFragment;
055    import org.deegree.framework.xml.XMLTools;
056    import org.deegree.model.crs.CoordinateSystem;
057    import org.deegree.model.metadata.iso19115.Keywords;
058    import org.deegree.model.metadata.iso19115.OnlineResource;
059    import org.deegree.model.spatialschema.Envelope;
060    import org.deegree.model.spatialschema.GMLGeometryAdapter;
061    import org.deegree.model.spatialschema.Geometry;
062    import org.deegree.model.spatialschema.GeometryException;
063    import org.deegree.ogcwebservices.LonLatEnvelope;
064    import org.w3c.dom.Element;
065    import org.w3c.dom.Node;
066    import org.w3c.dom.Text;
067    
068    /**
069     * Factory for creating <code>DOM</code> representations from java objects used to represent OGC
070     * related schema types.
071     *
072     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
073     * @author <a href="mailto:mschneider@lat-lon.de">Markus Schneider </a>
074     * @author last edited by: $Author: mschneider $
075     *
076     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
077     */
078    public class XMLFactory {
079    
080        protected static final ILogger LOG = LoggerFactory.getLogger( XMLFactory.class );
081    
082        protected static final URI OGCNS = CommonNamespaces.OGCNS;
083    
084        protected static final URI GMLNS = CommonNamespaces.GMLNS;
085    
086        protected static final URI XLNNS = CommonNamespaces.XLNNS;
087    
088        /**
089         * Appends the <code>DOM</code> representation of a <code>LonLatEnvelope</code> to the
090         * passed <code>Element</code>.
091         *
092         * @param root
093         * @param lonLatEnvelope
094         * @param namespaceURI
095         */
096        protected static void appendLonLatEnvelope( Element root, LonLatEnvelope lonLatEnvelope, URI namespaceURI ) {
097            Element lonLatEnvelopeElement = XMLTools.appendElement( root, namespaceURI, "lonLatEnvelope" );
098            //lonLatEnvelopeElement.setAttribute( "srsName", "WGS84(DD)" );
099            lonLatEnvelopeElement.setAttribute( "srsName", lonLatEnvelope.getSrs() );
100            String min = lonLatEnvelope.getMin().getX() + " " + lonLatEnvelope.getMin().getY();
101            Element elem = XMLTools.appendElement( lonLatEnvelopeElement, GMLNS, "gml:pos", min );
102            elem.setAttribute( "dimension", "2" );
103            String max = lonLatEnvelope.getMax().getX() + " " + lonLatEnvelope.getMax().getY();
104            elem = XMLTools.appendElement( lonLatEnvelopeElement, GMLNS, "gml:pos", max );
105            elem.setAttribute( "dimension", "2" );
106            TimePosition[] tpos = lonLatEnvelope.getTimePositions();
107            if ( tpos != null ) {
108                for ( int i = 0; i < tpos.length; i++ ) {
109                    appendTimePosition( lonLatEnvelopeElement, tpos[i] );
110                }
111            }
112        }
113    
114        /**
115         * Appends an <code>XML/GML Envelope</code> -element to the passed <code>Element</code>.
116         *
117         * @param xmlNode
118         * @param envelope
119         */
120        protected static void appendEnvelope( Element xmlNode, Envelope envelope ) {
121            Element node = XMLTools.appendElement( xmlNode, GMLNS, "gml:Envelope" );
122            CoordinateSystem crs = envelope.getCoordinateSystem();
123            if ( crs != null ) {
124                try {
125                    node.setAttribute( "srsName", crs.getIdentifier() );
126                } catch ( Exception e ) {
127                    e.printStackTrace();
128                }
129            }
130            Element env = node;
131    
132            String min = envelope.getMin().getX() + " " + envelope.getMin().getY();
133            node = XMLTools.appendElement( env, GMLNS, "gml:pos", min );
134            node.setAttribute( "dimension", "2" );
135    
136            String max = envelope.getMax().getX() + " " + envelope.getMax().getY();
137            node = XMLTools.appendElement( env, GMLNS, "gml:pos", max );
138            node.setAttribute( "dimension", "2" );
139        }
140    
141        /**
142         * Appends the <code>XML/GML</code> representation of a <code>TimePosition</code> to the
143         * passed <code>Element</code>.
144         *
145         * @param xmlNode
146         * @param tpos
147         */
148        protected static void appendTimePosition( Element xmlNode, TimePosition tpos ) {
149            if ( tpos != null ) {
150                String s = TimeTools.getISOFormattedTime( tpos.getTime() );
151                Element element = XMLTools.appendElement( xmlNode, GMLNS, "gml:timePosition", s );
152                element.setAttribute( "calendarEraName", tpos.getCalendarEraName() );
153                element.setAttribute( "frame", tpos.getFrame().toString() );
154                element.setAttribute( "indeterminatePosition", tpos.getIndeterminatePosition().value );
155            }
156        }
157    
158        /**
159         * Appends a <code>keywords</code> -element for each <code>Keywords</code> object of the
160         * passed array to the passed <code>Element</code>.
161         *
162         * @param xmlNode
163         * @param keywords
164         * @param namespaceURI
165         */
166        protected static void appendKeywords( Element xmlNode, Keywords[] keywords, URI namespaceURI ) {
167            if ( keywords != null ) {
168                for ( int i = 0; i < keywords.length; i++ ) {
169                    Element node = XMLTools.appendElement( xmlNode, namespaceURI, "keywords" );
170                    appendKeywords( node, keywords[i], namespaceURI );
171                }
172            }
173        }
174    
175        /**
176         * Appends a <code>keywords</code> -element to the passed <code>Element</code> and fills it
177         * with the available keywords.
178         *
179         * @param xmlNode
180         * @param keywords
181         * @param namespaceURI
182         */
183        protected static void appendKeywords( Element xmlNode, Keywords keywords, URI namespaceURI ) {
184            if ( keywords != null ) {
185                String[] kw = keywords.getKeywords();
186                for ( int i = 0; i < kw.length; i++ ) {
187                    XMLTools.appendElement( xmlNode, namespaceURI, "keyword", kw[i] );
188                }
189                if ( keywords.getThesaurusName() != null ) {
190                    XMLTools.appendElement( xmlNode, namespaceURI, "type", keywords.getThesaurusName() );
191                }
192            }
193        }
194    
195        /**
196         * Appends an <code>XML</code> representation of the passed <code>TimeSequence</code> to the
197         * passed <code>Element</code>.
198         *
199         * @param xmlNode
200         * @param timeSeq
201         * @param namespaceURI
202         */
203        protected static void appendTemporalDomain( Element xmlNode, TimeSequence timeSeq, URI namespaceURI ) {
204            if ( timeSeq != null ) {
205                Element node = XMLTools.appendElement( xmlNode, namespaceURI, "temporalDomain", null );
206                TimePeriod[] tPer = timeSeq.getTimePeriod();
207                if ( tPer != null ) {
208                    for ( int i = 0; i < tPer.length; i++ ) {
209                        appendTimePeriod( node, tPer[i], namespaceURI );
210                    }
211                }
212    
213                TimePosition[] tPos = timeSeq.getTimePosition();
214                if ( tPos != null ) {
215                    for ( int i = 0; i < tPos.length; i++ ) {
216                        appendTimePosition( node, tPos[i] );
217                    }
218                }
219            }
220        }
221    
222        /**
223         * Appends an <code>XML</code> representation of the passed <code>TimePeriod</code> to the
224         * passed <code>Element</code>.
225         *
226         * @param xmlNode
227         * @param tPeriod
228         * @param namespaceURI
229         */
230        protected static void appendTimePeriod( Element xmlNode, TimePeriod tPeriod, URI namespaceURI ) {
231            Element node = XMLTools.appendElement( xmlNode, namespaceURI, "timePeriod" );
232            appendTimePosition( node, tPeriod.getBeginPosition() );
233            appendTimePosition( node, tPeriod.getEndPosition() );
234            appendTimeResolution( node, tPeriod.getTimeResolution() );
235        }
236    
237        /**
238         * Appends an <code>XML/GML</code> representation of the passed <code>TimeDuration</code> to
239         * the passed <code>Element</code>.
240         *
241         * @param xmlNode
242         * @param duration
243         */
244        protected static void appendTimeResolution( Element xmlNode, TimeDuration duration ) {
245            XMLTools.appendElement( xmlNode, GMLNS, "gml:timeResolution", duration.getAsGMLTimeDuration() );
246        }
247    
248        /**
249         * Appends an <code>XML</code> representation of the passed <code>Values</code> to the
250         * passed <code>Element</code>.
251         *
252         * @param xmlNode
253         * @param values
254         * @param namespaceURI
255         */
256        protected static void appendValues( Element xmlNode, Values values, URI namespaceURI ) {
257            Element node = XMLTools.appendElement( xmlNode, namespaceURI, "values" );
258            if ( values.getType() != null ) {
259                node.setAttribute( "type", values.getType().toString() );
260            }
261            if ( values.getSemantic() != null ) {
262                node.setAttribute( "xmlns:dgr", namespaceURI.toString() );
263                node.setAttributeNS( namespaceURI.toString(), "dgr:semantic", values.getSemantic().toString() );
264            }
265            Interval[] intervals = values.getInterval();
266            if ( intervals != null ) {
267                for ( int i = 0; i < intervals.length; i++ ) {
268                    appendInterval( node, intervals[i], namespaceURI );
269                }
270            }
271            TypedLiteral[] sVal = values.getSingleValue();
272            if ( sVal != null ) {
273                for ( int i = 0; i < sVal.length; i++ ) {
274                    appendTypedLiteral( node, sVal[i], "singleValue", namespaceURI );
275                }
276            }
277        }
278    
279        /**
280         * Appends an <code>XML</code> representation of the passed <code>Interval</code> to the
281         * passed <code>Element</code>.
282         *
283         * @param xmlNode
284         * @param interval
285         * @param namespaceURI
286         */
287        protected static void appendInterval( Element xmlNode, Interval interval, URI namespaceURI ) {
288            Element node = XMLTools.appendElement( xmlNode, namespaceURI, "interval" );
289            Element inter = node;
290            if ( interval.getType() != null ) {
291                node.setAttribute( "type", interval.getType().toString() );
292            }
293    
294            if ( interval.getSemantic() != null ) {
295                node.setAttribute( "xmlns:dgr", namespaceURI.toString() );
296                node.setAttributeNS( namespaceURI.toString(), "dgr:semantic", interval.getSemantic().toString() );
297            }
298            node.setAttribute( "atomic", "" + interval.isAtomic() );
299            if ( interval.getClosure() != null && interval.getClosure().value != "" && interval.getClosure().value != null ) {
300                node.setAttribute( "xmlns:dgr", namespaceURI.toString() );
301                node.setAttributeNS( namespaceURI.toString(), "dgr:closure", interval.getClosure().value );
302            }
303            node = XMLTools.appendElement( inter, namespaceURI, "min", interval.getMin().getValue() );
304            if ( interval.getMin().getType() != null ) {
305                node.setAttribute( "type", interval.getMin().getType().toString() );
306            }
307            node = XMLTools.appendElement( inter, namespaceURI, "max", interval.getMin().getValue() );
308            if ( interval.getMax().getType() != null ) {
309                node.setAttribute( "type", interval.getMax().getType().toString() );
310            }
311            node = XMLTools.appendElement( inter, namespaceURI, "res", interval.getRes().getValue() );
312            if ( interval.getRes().getType() != null ) {
313                node.setAttribute( "type", interval.getRes().getType().toString() );
314            }
315        }
316    
317        /**
318         * Appends an <code>XML</code> representation of the passed <code>TypedLiteral</code> to the
319         * passed <code>Element</code>.
320         *
321         * @param xmlNode
322         * @param singleValue
323         * @param name
324         * @param namespaceURI
325         */
326        protected static void appendTypedLiteral( Element xmlNode, TypedLiteral singleValue, String name, URI namespaceURI ) {
327            Node node = XMLTools.appendElement( xmlNode, namespaceURI, name, singleValue.getValue() );
328            if ( singleValue.getType() != null ) {
329                ( (Element) node ).setAttribute( "type", singleValue.getType().toString() );
330            }
331        }
332    
333        /**
334         * Appends an <code>XML</code> representation of the passed <code>CodeList</code> to the
335         * passed <code>Element</code>.
336         *
337         * @param xmlNode
338         * @param codeList
339         * @param namespaceURI
340         */
341        protected static void appendCodeList( Element xmlNode, CodeList codeList, URI namespaceURI ) {
342            String[] codes = codeList.getCodes();
343            String s = StringTools.arrayToString( codes, ' ' );
344            Node node = XMLTools.appendElement( xmlNode, namespaceURI, codeList.getName(), s );
345            if ( codeList.getCodeSpace() != null ) {
346                ( (Element) node ).setAttribute( "codeSpace", codeList.getCodeSpace().toString() );
347            }
348        }
349    
350        /**
351         * Appends the XML attributes of the given <code>SimpleLink</code> to the also passed
352         * <code>Element</code>.
353         *
354         * @param linkElement
355         * @param simpleLink
356         */
357        protected static void appendSimpleLinkAttributes( Element linkElement, SimpleLink simpleLink ) {
358    
359            linkElement.setAttributeNS( XLNNS.toString(), "xlink:type", "simple" );
360            if ( simpleLink.getHref() != null ) {
361                linkElement.setAttributeNS( XLNNS.toString(), "xlink:href", simpleLink.getHref().toString() );
362            }
363            if ( simpleLink.getRole() != null ) {
364                linkElement.setAttributeNS( XLNNS.toString(), "xlink:role", simpleLink.getRole().toString() );
365            }
366            if ( simpleLink.getArcrole() != null ) {
367                linkElement.setAttributeNS( XLNNS.toString(), "xlink:arcrole", simpleLink.getArcrole().toString() );
368            }
369            if ( simpleLink.getTitle() != null ) {
370                linkElement.setAttributeNS( XLNNS.toString(), "xlink:title", simpleLink.getTitle() );
371            }
372            if ( simpleLink.getShow() != null ) {
373                linkElement.setAttributeNS( XLNNS.toString(), "xlink:show", simpleLink.getShow() );
374            }
375            if ( simpleLink.getActuate() != null ) {
376                linkElement.setAttributeNS( XLNNS.toString(), "xlink:actuate", simpleLink.getActuate() );
377            }
378        }
379    
380        /**
381         * Appends the <code>DOM</code> representation of a simple <code>XLink</code> -element to
382         * the passed <code>Element</code>.
383         *
384         * @param xmlNode
385         * @param elementName
386         * @param onlineResource
387         * @param namespaceURI
388         */
389        protected static void appendOnlineResource( Element xmlNode, String elementName, OnlineResource onlineResource,
390                                                    URI namespaceURI ) {
391            Element linkElement = XMLTools.appendElement( xmlNode, namespaceURI, elementName );
392            linkElement.setAttributeNS( XLNNS.toString(), "xlink:type", "simple" );
393            linkElement.setAttributeNS( XLNNS.toString(), "xlink:href", onlineResource.getLinkage().getHref().toString() );
394        }
395    
396        /**
397         * Appends the <code>DOM</code> representation of the given <code>PropertyPath</code> as a
398         * new text node to the given element (including necessary namespace bindings).
399         *
400         * @param element
401         *            Element node where the PropertyPath is appended to
402         * @param propertyPath
403         */
404        protected static void appendPropertyPath( Element element, PropertyPath propertyPath ) {
405            StringBuffer sb = new StringBuffer();
406            sb.append( propertyPath );
407    
408            Text textNode = element.getOwnerDocument().createTextNode( sb.toString() );
409            element.appendChild( textNode );
410            XMLTools.appendNSBindings( element, propertyPath.getNamespaceContext() );
411        }
412    
413        /**
414         * Appends the <code>DOM</code> representation of the given feature id to the given element.
415         *
416         * @param root
417         *            Element node where the "ogc:FeatureId" element is appended to
418         * @param fid
419         *            feature identifier
420         */
421        protected static void appendFeatureId( Element root, String fid ) {
422            Element gmlObjectIdElement = XMLTools.appendElement( root, OGCNS, "ogc:FeatureId" );
423            gmlObjectIdElement.setAttribute( "fid", fid );
424        }
425    
426        /**
427         * Appends the <code>DOM</code> representation of the given {@link Geometry} to the given
428         * element.
429         *
430         * TODO Do this a better way...
431         *
432         * @param el
433         *            element node where the geometry is appended to
434         * @param geom
435         *            geometry to be appended
436         * @throws GeometryException
437         */
438        protected static void appendGeometry( Element el, Geometry geom )
439                                throws GeometryException {
440    
441            StringBuffer sb = new StringBuffer();
442            sb.append( "<dummy xmlns:gml=\"" );
443            sb.append( CommonNamespaces.GMLNS.toString() );
444            sb.append( "\">" );
445            sb.append( GMLGeometryAdapter.export( geom ) );
446            sb.append( "</dummy>" );
447    
448            ByteArrayInputStream bis = new ByteArrayInputStream( sb.toString().getBytes() );
449            try {
450                GMLDocument doc = new GMLDocument();
451                doc.load( bis, XMLFragment.DEFAULT_URL );
452                XMLTools.insertNodeInto( XMLTools.getFirstChildElement( doc.getRootElement() ), el );
453            } catch ( Exception e ) {
454                throw new GeometryException( e.getMessage() );
455            }
456        }
457    }