    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_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    }