001    //$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/ogcwebservices/csw/discovery/Query.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    
037    package org.deegree.ogcwebservices.csw.discovery;
038    
039    import java.util.ArrayList;
040    import java.util.HashMap;
041    import java.util.List;
042    import java.util.Map;
043    
044    import org.deegree.datatypes.QualifiedName;
045    import org.deegree.model.filterencoding.Filter;
046    import org.deegree.ogcbase.PropertyPath;
047    import org.deegree.ogcbase.PropertyPathFactory;
048    import org.deegree.ogcbase.SortProperty;
049    
050    /**
051     * Main component of a <code>GetRecords</code> request. A <code>GetRecords</code> request may
052     * consist of several <code>Query</code> elements.
053     *
054     * @author <a href="mailto:mschneider@lat-lon.de">Markus Schneider </a>
055     *
056     * @author last edited by: $Author: mschneider $
057     *
058     * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
059     */
060    
061    public class Query {
062    
063        private String elementSetName;
064    
065        private List<PropertyPath> elementNamesAsPropertyPaths;
066    
067        private Filter constraint;
068    
069        private SortProperty[] sortProperties;
070    
071        private List<QualifiedName> typeNames;
072    
073        private Map<String, QualifiedName> declaredTypeNameVariables;
074    
075        private List<QualifiedName> elementSetNameTypeNamesList;
076    
077        private Map<String, QualifiedName> elementSetNameVariables;
078    
079        /**
080         * Creates a new Query instance.
081         *
082         * @param elementSetName
083         * @param elementNames
084         *            a String array containing the requested ElementName propertypaths. If not null,
085         *            they will be converted to an ArrayList<PropertyPath>.
086         * @param sortProperties
087         * @param constraint
088         * @param typeNames
089         *            which will be transformed to a list of qualified names.
090         */
091        Query( String elementSetName, String[] elementNames, Filter constraint,
092               SortProperty[] sortProperties, String[] typeNames ) {
093            List<QualifiedName> list = new ArrayList<QualifiedName>(
094                                                                     ( ( typeNames != null ) ? typeNames.length
095                                                                                            : 0 ) );
096            if ( typeNames != null ) {
097                for ( String tName : typeNames ) {
098                    list.add( new QualifiedName( tName ) );
099                }
100            }
101            this.elementSetName = elementSetName;
102            this.elementSetNameTypeNamesList = new ArrayList<QualifiedName>();
103            elementNamesAsPropertyPaths = new ArrayList<PropertyPath>();
104            if ( elementNames != null ) {
105                for ( String en : elementNames ) {
106                    elementNamesAsPropertyPaths.add( PropertyPathFactory.createPropertyPath( new QualifiedName(
107                                                                                                                en ) ) );
108                }
109            }
110    
111            this.constraint = constraint;
112            this.sortProperties = sortProperties;
113            this.typeNames = list;
114            this.elementSetNameVariables = new HashMap<String, QualifiedName>();
115            this.declaredTypeNameVariables = new HashMap<String, QualifiedName>();
116        }
117    
118        /**
119         * @param elementSetName
120         * @param elementSetNameTypeNames
121         *            the typenames (not the variables) which should be returned inside a
122         *            GetRecordsReponse
123         * @param elementSetNameVariables
124         *            the variables (and their mapping to the TypeName) which were requested.
125         * @param elementNames
126         *            a list of propertyPath of propertys a client is interested in.
127         * @param constraint
128         * @param sortProperties
129         * @param typeNames
130         *            list of QualifiedNames which were defined in the query element.
131         * @param typeNameVariables
132         *            the variables (strings starting with an $-sign) which were declared
133         *            typeNameattribtue in the Query element.
134         */
135        public Query( String elementSetName, List<QualifiedName> elementSetNameTypeNames,
136                      Map<String, QualifiedName> elementSetNameVariables,
137                      List<PropertyPath> elementNames, Filter constraint,
138                      SortProperty[] sortProperties, List<QualifiedName> typeNames,
139                      Map<String, QualifiedName> typeNameVariables ) {
140            this.elementSetName = elementSetName;
141            this.elementSetNameTypeNamesList = elementSetNameTypeNames;
142            this.elementSetNameVariables = elementSetNameVariables;
143            this.elementNamesAsPropertyPaths = elementNames;
144            this.constraint = constraint;
145            this.sortProperties = sortProperties;
146            this.typeNames = typeNames;
147            this.declaredTypeNameVariables = typeNameVariables;
148        }
149    
150        /**
151         * Zero or one (Optional); If <tt>null</tt> then getElementNames may return a list of
152         * requested elements. If both methods returns <tt>null</tt> the default action is to present
153         * all metadata elements.
154         * <p>
155         * The ElementName parameter is used to specify one or more metadata record elements that the
156         * query should present in the response to the a GetRecords operation. Well known sets of
157         * element may be named, in which case the ElementSetName parameter may be used (e. g.brief,
158         * summary or full).
159         * <p>
160         * If neither parameter is specified, then a CSW shall present all metadata record elements
161         *
162         * @return the textual value (brief, summary, full) of the elementSetName node or null if none
163         *         was given.
164         */
165        public String getElementSetName() {
166            return elementSetName;
167        }
168    
169        /**
170         * @return an Array of element names returned by a getRecord request.
171         * @deprecated this method is replaced with the more correct
172         *             {@link #getElementNamesAsPropertyPaths()}. For now it just returns the values of
173         *             {@link PropertyPath#getAsString()} method or <code>null</code> if no
174         *             elementName were requested.
175         *
176         */
177        @Deprecated
178        public String[] getElementsNames() {
179            if ( elementNamesAsPropertyPaths == null ) {
180                return null;
181            }
182            String[] r = new String[elementNamesAsPropertyPaths.size()];
183            for ( int i = 0; i < elementNamesAsPropertyPaths.size(); ++i ) {
184                r[i] = elementNamesAsPropertyPaths.get( i ).getAsString();
185            }
186            return r;
187        }
188    
189        /**
190         * Zero or one (Optional); Default action is to execute an unconstrained query
191         *
192         * @return the Filter which was given in the query.
193         */
194        public Filter getContraint() {
195            return this.constraint;
196        }
197    
198        /**
199         * Ordered list of names of metadata elements to use for sorting the response. Format of each
200         * list item is metadata_elemen_ name:A indicating an ascending sort or metadata_ element_name:D
201         * indicating descending sort
202         * <p>
203         * The result set may be sorted by specifying one or more metadata record elements upon which to
204         * sort.
205         * <p>
206         *
207         * @todo verify return type URI[] or String
208         * @return an Array of properties for sorting the response.
209         */
210        public SortProperty[] getSortProperties() {
211            return this.sortProperties;
212        }
213    
214        /**
215         * The typeName parameter specifies the record type name that defines a set of metadata record
216         * element names which will be constrained in the predicate of the query. In addition, all or
217         * some of the these names may be specified in the query to define which metadata record
218         * elements the query should present in the response to the GetRecords operation.
219         *
220         * @return the type names of the query.
221         * @deprecated this function actually creates an Array of Strings using the values returned from
222         *             the {@link QualifiedName#getFormattedString()} method or <code>null</code> if
223         *             no typenames were requested. It is more correct to use the values of the
224         *             {@link #getTypeNamesAsList()} method
225         */
226        @Deprecated
227        public String[] getTypeNames() {
228            if ( typeNames == null ) {
229                return null;
230            }
231            String[] tNames = new String[typeNames.size()];
232            for ( int i = 0; i < typeNames.size(); ++i ) {
233                tNames[i] = typeNames.get( i ).getFormattedString();
234            }
235            return tNames;
236        }
237    
238        /**
239         * The typeName parameter specifies the record type name that defines a set of metadata record
240         * element names which will be constrained in the predicate of the query. In addition, all or
241         * some of the these names may be specified in the query to define which metadata record
242         * elements the query should present in the response to the GetRecords operation.
243         *
244         * @return the type names of the query.
245         */
246        public List<QualifiedName> getTypeNamesAsList() {
247            return typeNames;
248        }
249    
250        /**
251         * @return the variables (with a leading $ (dollar_sign) as a String), declared with the
252         *         typeNames (given as {@link QualifiedName} ).
253         */
254        public Map<String, QualifiedName> getDeclaredTypeNameVariables() {
255            return declaredTypeNameVariables;
256        }
257    
258        /**
259         * @return the requested elementNames as a list of PropertyPaths.
260         */
261        public List<PropertyPath> getElementNamesAsPropertyPaths() {
262            return elementNamesAsPropertyPaths;
263        }
264    
265        /**
266         * @return the variables which were requested in the ElementSetNames/@typeNames attribute and
267         *         the mapping to their typenames.
268         */
269        public Map<String, QualifiedName> getElementSetNameVariables() {
270            return elementSetNameVariables;
271        }
272    
273        /**
274         * @return the typenames which were requested in the ElementSetNames/@typeNames attribute.
275         */
276        public List<QualifiedName> getElementSetNameTypeNamesList() {
277            return elementSetNameTypeNamesList;
278        }
279    
280    }