001 //$HeadURL: $
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
037 package org.deegree.ogcwebservices.wcts.operation;
038
039 import java.util.ArrayList;
040 import java.util.List;
041 import java.util.Map;
042
043 import org.deegree.framework.util.Pair;
044 import org.deegree.i18n.Messages;
045 import org.deegree.model.crs.CRSFactory;
046 import org.deegree.model.crs.CoordinateSystem;
047 import org.deegree.model.crs.UnknownCRSException;
048 import org.deegree.ogcbase.ExceptionCode;
049 import org.deegree.ogcwebservices.OGCWebServiceException;
050 import org.deegree.ogcwebservices.wcts.WCTSExceptionCode;
051 import org.deegree.ogcwebservices.wcts.WCTService;
052
053 /**
054 * <code>IsTransformable</code> encapsulates the bean representation of the xml-dom or kvp encoded IsTransformable
055 * request of the wcts 0.4.0
056 *
057 * @author <a href="mailto:bezema@lat-lon.de">Rutger Bezema</a>
058 *
059 * @author last edited by: $Author:$
060 *
061 * @version $Revision:$, $Date:$
062 *
063 */
064 public class IsTransformable extends WCTSRequestBase {
065
066 private static final long serialVersionUID = 5834206406155257853L;
067
068 private final CoordinateSystem sourceCRS;
069
070 private final CoordinateSystem targetCRS;
071
072 private final String transformation;
073
074 private final String method;
075
076 private final List<Pair<String, String>> geometryTypes;
077
078 private final List<String> simpleGeometryTypes;
079
080 private final List<Pair<String, String>> coverageTypes;
081
082 private final List<Pair<String, String>> interpolationTypes;
083
084 /**
085 * @param version
086 * @param id
087 * @param sourceCRS
088 * if <code>null</code> it is assumed that the sourceCRS is not supported.
089 * @param targetCRS
090 * if <code>null</code> it is assumed that the targetCRS is not supported.
091 * @param transformation
092 * @param method
093 * @param geometryTypes
094 * @param coverageTypes
095 * @param interpolationTypes
096 */
097 public IsTransformable( String version, String id, CoordinateSystem sourceCRS, CoordinateSystem targetCRS,
098 String transformation, String method, List<Pair<String, String>> geometryTypes,
099 List<Pair<String, String>> coverageTypes, List<Pair<String, String>> interpolationTypes ) {
100
101 super( version, id, null );
102 this.sourceCRS = sourceCRS;
103 this.targetCRS = targetCRS;
104 this.transformation = transformation;
105 this.method = method;
106 if ( coverageTypes != null ) {
107 throw new IllegalArgumentException( Messages.getMessage( "WCTS_ISTRANSFORMABLE_COVERAGE_NOT_SUPPORTED" ) );
108 }
109 this.coverageTypes = coverageTypes;
110 if ( interpolationTypes != null ) {
111 throw new IllegalArgumentException(
112 Messages.getMessage( "WCTS_ISTRANSFORMABLE_INTERPOLATION_NOT_SUPPORTED" ) );
113 }
114 this.interpolationTypes = interpolationTypes;
115 this.geometryTypes = geometryTypes;
116 this.simpleGeometryTypes = null;
117 }
118
119 /**
120 * @param version
121 * @param requestID
122 * @param sourceCRS
123 * if <code>null</code> it is assumed that the sourceCRS is not supported.
124 * @param targetCRS
125 * if <code>null</code> it is assumed that the targetCRS is not supported.
126 * @param geometryTypes
127 * a list of simple geometry representations.
128 */
129 public IsTransformable( String version, String requestID, CoordinateSystem sourceCRS, CoordinateSystem targetCRS,
130 List<String> geometryTypes ) {
131 super( version, requestID, null );
132 this.sourceCRS = sourceCRS;
133 this.targetCRS = targetCRS;
134 this.transformation = null;
135 this.method = null;
136 this.coverageTypes = null;
137 this.interpolationTypes = null;
138
139 this.geometryTypes = null;
140 this.simpleGeometryTypes = geometryTypes;
141 }
142
143 /**
144 * @return the sourceCRS, if <code>null</code> it can be assumed that the sourceCRS is not supported.
145 */
146 public final CoordinateSystem getSourceCRS() {
147 return sourceCRS;
148 }
149
150 /**
151 * @return the targetCRS, if <code>null</code> it can be assumed that the targetCRS is not supported.
152 */
153 public final CoordinateSystem getTargetCRS() {
154 return targetCRS;
155 }
156
157 /**
158 * @return the transformation currently <code>null</code>
159 */
160 public final String getTransformation() {
161 return transformation;
162 }
163
164 /**
165 * @return the method currently <code>null</code>
166 */
167 public final String getMethod() {
168 return method;
169 }
170
171 /**
172 * @return the geometryTypes as a list of < value, codeSpace > pairs. May be <code>null</code>, if so, check
173 * {@link #getSimpleGeometryTypes()} to see if the request defined geometryTypes by KVP.
174 */
175 public final List<Pair<String, String>> getGeometryTypes() {
176 return geometryTypes;
177 }
178
179 /**
180 * @return the simpleGeometryTypes. Maybe <code>null</code>, if so check {@link #getGeometryTypes()} to see if
181 * xml encoded geometryTypes were supplied.
182 */
183 public final List<String> getSimpleGeometryTypes() {
184 return simpleGeometryTypes;
185 }
186
187 /**
188 * @return the coverageTypes currently <code>null</code>.
189 */
190 public final List<Pair<String, String>> getCoverageTypes() {
191 return coverageTypes;
192 }
193
194 /**
195 * @return the interpolationTypes currently <code>null</code>.
196 */
197 public final List<Pair<String, String>> getInterpolationTypes() {
198 return interpolationTypes;
199 }
200
201 /**
202 * Create a {@link IsTransformable}-request by extracting the values from the map, and calling the constructor with
203 * these values.
204 *
205 * @param requestID
206 * service internal id for this request.
207 * @param map
208 * to extract requested values from.
209 * @return the bean representation
210 * @throws OGCWebServiceException
211 * if the map is <code>null</code> or has size==0, or the service,request parameters have none
212 * accepted values.
213 */
214 public static IsTransformable create( String requestID, Map<String, String> map )
215 throws OGCWebServiceException {
216 if ( map == null || map.size() == 0 ) {
217 throw new OGCWebServiceException( Messages.getMessage( "WCTS_REQUESTMAP_NULL" ),
218 ExceptionCode.MISSINGPARAMETERVALUE );
219 }
220 String service = map.get( "SERVICE" );
221 if ( service == null || !"WCTS".equals( service ) ) {
222 throw new OGCWebServiceException( Messages.getMessage( "WCTS_NO_VERSION_KVP", service ),
223 ExceptionCode.MISSINGPARAMETERVALUE );
224 }
225 String request = map.get( "REQUEST" );
226 if ( request == null || !"IsTransformable".equalsIgnoreCase( request ) ) {
227 throw new OGCWebServiceException( Messages.getMessage( "WCTS_NO_REQUEST_KVP", "IsTransformable" ),
228 ( request == null ? ExceptionCode.MISSINGPARAMETERVALUE
229 : ExceptionCode.OPERATIONNOTSUPPORTED ) );
230 }
231 String version = map.get( "VERSION" );
232 if ( version == null || !WCTService.version.equalsIgnoreCase( version ) ) {
233 throw new OGCWebServiceException( Messages.getMessage( "WCTS_NO_VERSION_KVP", version ),
234 ExceptionCode.MISSINGPARAMETERVALUE );
235 }
236
237 String sCRS = map.get( "SOURCECRS" );
238 String tCRS = map.get( "TARGETCRS" );
239 if ( ( ( sCRS != null && !"".equals( sCRS.trim() ) ) && ( tCRS == null || "".equals( tCRS.trim() ) ) )
240 || ( ( tCRS != null && !"".equals( tCRS.trim() ) ) && ( sCRS == null || "".equals( sCRS.trim() ) ) ) ) {
241 throw new OGCWebServiceException( Messages.getMessage( "WCTS_MISSING_MUTUAL_KEY_KVP",
242 ( ( sCRS == null ) ? "TargetCRS" : "SourceCRS" ),
243 ( ( sCRS == null ) ? "SourceCRS" : "TargetCRS" ) ),
244 ExceptionCode.INVALIDPARAMETERVALUE );
245 }
246 if ( ( sCRS == null || "".equals( sCRS.trim() ) ) && ( tCRS == null || "".equals( tCRS.trim() ) ) ) {
247 String transformation = map.get( "TRANSFORMATION" );
248 if ( !( transformation == null || "".equals( transformation.trim() ) ) ) {
249 throw new OGCWebServiceException(
250 Messages.getMessage( "WCTS_OPERATION_NOT_SUPPORTED",
251 "defining of transformations (Transformation key)" ),
252 ExceptionCode.OPERATIONNOTSUPPORTED );
253 }
254
255 String method = map.get( "METHOD" );
256 if ( !( method == null || "".equals( method.trim() ) ) ) {
257 throw new OGCWebServiceException( Messages.getMessage( "WCTS_OPERATION_NOT_SUPPORTED",
258 "transformation method (Method key)" ),
259 ExceptionCode.OPERATIONNOTSUPPORTED );
260 }
261 throw new OGCWebServiceException( Messages.getMessage( "WCTS_TRANSFORMATION_NO_CRS_OR_TRANSFORM_KVP" ),
262 ExceptionCode.MISSINGPARAMETERVALUE );
263
264 }
265 CoordinateSystem sourceCRS = null;
266 CoordinateSystem targetCRS = null;
267 try {
268 sourceCRS = CRSFactory.create( WCTService.CRS_PROVIDER, sCRS );
269 targetCRS = CRSFactory.create( WCTService.CRS_PROVIDER, tCRS );
270 } catch ( UnknownCRSException e ) {
271 throw new OGCWebServiceException( e.getMessage(), WCTSExceptionCode.UNSUPPORTED_COMBINATION );
272 }
273
274 String tmp = map.get( "GEOMETRYTYPES" );
275 List<String> geometryTypes = new ArrayList<String>( 10 );
276 if ( tmp != null && !"".equals( tmp.trim() ) ) {
277 String[] splitter = tmp.split( "," );
278 for ( String split : splitter ) {
279 if ( split != null && !"".equals( split.trim() ) ) {
280 geometryTypes.add( split.trim() );
281 }
282 }
283 }
284
285 String coverageTypes = map.get( "COVERAGETYPES" );
286 if ( !( coverageTypes == null || "".equals( coverageTypes.trim() ) ) ) {
287 throw new OGCWebServiceException( Messages.getMessage( "WCTS_OPERATION_NOT_SUPPORTED",
288 "CoverageTypes (key)" ),
289 ExceptionCode.OPERATIONNOTSUPPORTED );
290 }
291
292 String interPolationType = map.get( "INTERPOLATIONTYPES" );
293 if ( !( interPolationType == null || "".equals( interPolationType.trim() ) ) ) {
294 throw new OGCWebServiceException( Messages.getMessage( "WCTS_OPERATION_NOT_SUPPORTED",
295 "InterpolationTypes (key)" ),
296 ExceptionCode.OPERATIONNOTSUPPORTED );
297 }
298
299 return new IsTransformable( version, requestID, sourceCRS, targetCRS, geometryTypes );
300 }
301
302 }