001: //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/trunk/src/org/deegree/ogcwebservices/wcs/describecoverage/DescribeCoverage.java $
002: /*---------------- FILE HEADER ------------------------------------------
003:
004: This file is part of deegree.
005: Copyright (C) 2001-2008 by:
006: EXSE, Department of Geography, University of Bonn
007: http://www.giub.uni-bonn.de/deegree/
008: lat/lon GmbH
009: http://www.lat-lon.de
010:
011: This library is free software; you can redistribute it and/or
012: modify it under the terms of the GNU Lesser General Public
013: License as published by the Free Software Foundation; either
014: version 2.1 of the License, or (at your option) any later version.
015:
016: This library is distributed in the hope that it will be useful,
017: but WITHOUT ANY WARRANTY; without even the implied warranty of
018: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
019: Lesser General Public License for more details.
020:
021: You should have received a copy of the GNU Lesser General Public
022: License along with this library; if not, write to the Free Software
023: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024:
025: Contact:
026:
027: Andreas Poth
028: lat/lon GmbH
029: Aennchenstr. 19
030: 53115 Bonn
031: Germany
032: E-Mail: poth@lat-lon.de
033:
034: Prof. Dr. Klaus Greve
035: Department of Geography
036: University of Bonn
037: Meckenheimer Allee 166
038: 53115 Bonn
039: Germany
040: E-Mail: greve@giub.uni-bonn.de
041:
042:
043: ---------------------------------------------------------------------------*/
044: package org.deegree.ogcwebservices.wcs.describecoverage;
045:
046: import java.util.Map;
047:
048: import org.deegree.framework.util.KVP2Map;
049: import org.deegree.framework.util.StringTools;
050: import org.deegree.framework.xml.ElementList;
051: import org.deegree.framework.xml.XMLParsingException;
052: import org.deegree.framework.xml.XMLTools;
053: import org.deegree.ogcbase.CommonNamespaces;
054: import org.deegree.ogcbase.ExceptionCode;
055: import org.deegree.ogcwebservices.InvalidParameterValueException;
056: import org.deegree.ogcwebservices.MissingParameterValueException;
057: import org.deegree.ogcwebservices.OGCWebServiceException;
058: import org.deegree.ogcwebservices.wcs.WCSException;
059: import org.deegree.ogcwebservices.wcs.WCSExceptionCode;
060: import org.deegree.ogcwebservices.wcs.WCSRequestBase;
061: import org.w3c.dom.Document;
062: import org.w3c.dom.Element;
063:
064: /**
065: * A DescribeCoverage request lists the coverages to be described, identified by the Coverage
066: * parameter. A request that lists no coverages shall be interpreted as requesting descriptions of
067: * all coverages that a WCS can serve.
068: *
069: * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
070: * @author last edited by: $Author: apoth $
071: *
072: * @version $Revision: 9345 $, $Date: 2007-12-27 08:22:25 -0800 (Thu, 27 Dec 2007) $
073: */
074: public class DescribeCoverage extends WCSRequestBase {
075:
076: private String[] coverages = null;
077:
078: /**
079: * creates a DescribeCoverage request from its KVP representation
080: *
081: * @param map
082: * request
083: * @return created <tt>DescribeCoverage</tt>
084: * @throws OGCWebServiceException
085: * will be thrown if something general is wrong
086: * @throws MissingParameterValueException
087: * @throws InvalidParameterValueException
088: * @throws WCSException
089: * will be thrown if a WCS/DescribeCoverage specific part of the request is
090: * erroreous
091: */
092: public static DescribeCoverage create(Map map)
093: throws OGCWebServiceException,
094: MissingParameterValueException,
095: InvalidParameterValueException {
096:
097: String version = (String) map.get("VERSION");
098: if (version == null) {
099: ExceptionCode code = ExceptionCode.MISSINGPARAMETERVALUE;
100: throw new MissingParameterValueException(
101: "DescribeCoverage", "'version' is missing", code);
102: }
103: if (!version.equals("1.0.0")) {
104: ExceptionCode code = ExceptionCode.INVALIDPARAMETERVALUE;
105: throw new InvalidParameterValueException(
106: "DescribeCoverage", "'version' <> 1.0.0", code);
107: }
108: String service = (String) map.get("SERVICE");
109: if (service == null) {
110: ExceptionCode code = ExceptionCode.MISSINGPARAMETERVALUE;
111: throw new MissingParameterValueException(
112: "DescribeCoverage", "'service' is missing", code);
113: }
114: if (!"WCS".equalsIgnoreCase(service)) {
115: ExceptionCode code = ExceptionCode.INVALIDPARAMETERVALUE;
116: throw new InvalidParameterValueException(
117: "DescribeCoverage", "'service' <> WCS", code);
118: }
119:
120: String[] coverages = new String[0];
121: if (map.get("COVERAGE") != null) {
122: String s = (String) map.get("COVERAGE");
123: coverages = StringTools.toArray(s, ",", true);
124: }
125:
126: String id = (String) map.get("ID");
127:
128: return new DescribeCoverage(id, version, coverages);
129: }
130:
131: /**
132: * creates a DescribeCoverage request from its KVP representation
133: *
134: * @param id
135: * unique ID of the request
136: * @param kvp
137: * request
138: * @return created <tt>DescribeCoverage</tt>
139: * @throws OGCWebServiceException
140: * will be thrown if something general is wrong
141: * @throws MissingParameterValueException
142: * @throws InvalidParameterValueException
143: * @throws WCSException
144: * will be thrown if a WCS/DescribeCoverage specific part of the request is
145: * erroreous
146: */
147: public static DescribeCoverage createDescribeCoverage(String id,
148: String kvp) throws OGCWebServiceException,
149: MissingParameterValueException,
150: InvalidParameterValueException {
151: Map<String, String> map = KVP2Map.toMap(kvp);
152: map.put("ID", id);
153: return create(map);
154: }
155:
156: /**
157: * creates a DescribeCoverage request from its XML representation
158: *
159: * @param id
160: * unique ID of the request
161: * @param doc
162: * XML representation of the request
163: * @return created <tt>DescribeCoverage</tt>
164: * @throws OGCWebServiceException
165: * will be thrown if something general is wrong
166: * @throws MissingParameterValueException
167: * @throws InvalidParameterValueException
168: * @throws WCSException
169: * will be thrown if a WCS/DescribeCoverage specific part of the request is
170: * erroreous
171: */
172: public static DescribeCoverage create(String id, Document doc)
173: throws OGCWebServiceException,
174: MissingParameterValueException,
175: InvalidParameterValueException {
176:
177: String[] coverages = null;
178: String version = null;
179: try {
180: Element root = XMLTools.getRequiredChildElement(
181: "DescribeCoverage", CommonNamespaces.WCSNS, doc);
182:
183: version = XMLTools
184: .getAttrValue(root, null, "version", null);
185: if (version == null) {
186: ExceptionCode code = ExceptionCode.MISSINGPARAMETERVALUE;
187: throw new MissingParameterValueException(
188: "DescribeCoverage", "'version' is missing",
189: code);
190: }
191: if (!version.equals("1.0.0")) {
192: ExceptionCode code = ExceptionCode.INVALIDPARAMETERVALUE;
193: throw new InvalidParameterValueException(
194: "DescribeCoverage", "'version' <> 1.0.0", code);
195: }
196:
197: String service = XMLTools.getAttrValue(root, null,
198: "service", null);
199: if (service == null) {
200: ExceptionCode code = ExceptionCode.MISSINGPARAMETERVALUE;
201: throw new MissingParameterValueException(
202: "DescribeCoverage", "'service' is missing",
203: code);
204: }
205: if (!"WCS".equalsIgnoreCase(service)) {
206: ExceptionCode code = ExceptionCode.INVALIDPARAMETERVALUE;
207: throw new InvalidParameterValueException(
208: "DescribeCoverage", "'service' <> WCS", code);
209: }
210:
211: ElementList el = XMLTools.getChildElements("Coverage",
212: CommonNamespaces.WCSNS, root);
213: coverages = new String[el.getLength()];
214: for (int i = 0; i < coverages.length; i++) {
215: coverages[i] = XMLTools.getStringValue(el.item(i));
216: }
217: } catch (XMLParsingException e) {
218: ExceptionCode code = WCSExceptionCode.INVALID_FORMAT;
219: throw new WCSException("DescribeCoverage", e.toString(),
220: code);
221: }
222:
223: return new DescribeCoverage(id, version, coverages);
224: }
225:
226: /**
227: * @param id
228: * unique ID of the request
229: * @param version
230: * Request protocol version
231: * @param coverages
232: * list of coverages to describe (identified by their name values in the Capabilities
233: * response). If <tt>null</tt> or length == 0 all coverages of the service
234: * instances will be described
235: */
236: public DescribeCoverage(String id, String version,
237: String[] coverages) {
238: super (id, version);
239: this .coverages = coverages;
240: }
241:
242: /**
243: * @return Returns the coverages.
244: *
245: */
246: public String[] getCoverages() {
247: return coverages;
248: }
249:
250: }
|