001: //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/trunk/src/org/deegree/ogcwebservices/csw/capabilities/CatalogueOperationsMetadata.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.csw.capabilities;
045:
046: import java.util.ArrayList;
047: import java.util.List;
048:
049: import org.deegree.ogcwebservices.csw.discovery.GetRepositoryItem;
050: import org.deegree.ogcwebservices.getcapabilities.Operation;
051: import org.deegree.ogcwebservices.getcapabilities.OperationsMetadata;
052: import org.deegree.owscommon.OWSDomainType;
053:
054: /**
055: * Represents the <code>OperationMetadata</code> part in the capabilities document of an OGC-CSW
056: * according to the <code>OpenGIS�
057: * Catalogue Services Specification 2.0</code>.
058: * <p>
059: * In addition to the <code>GetCapabilities</code> operation that all <code>OWS 0.2</code>
060: * compliant services must implement, it may define some or all of the following operations: <table
061: * border="1">
062: * <tr>
063: * <th>Name</th>
064: * <th>Mandatory?</th>
065: * <th>Function</th>
066: * </tr>
067: * <tr>
068: * <td>DescribeRecord</td>
069: * <td align="center">X</td>
070: * <td>Allows a client to discover elements of the information model supported by the target
071: * catalogue service.</td>
072: * </tr>
073: * <tr>
074: * <td>GetDomain</td>
075: * <td align="center">-</td>
076: * <td>The optional GetDomain operation is used to obtain runtime information about the range of
077: * values of a metadata record element or request parameter. The runtime range of values for a
078: * property or request parameter is typically much smaller than the value space for that property or
079: * parameter based on its static type definition. For example, a property or request parameter
080: * defined as a 16bit positive integer in a database may have a value space of 65535 distinct
081: * integers but the actual number of distinct values existing in the database may be much smaller.
082: * This type of runtime information about the range of values of a property or request parameter is
083: * useful for generating user interfaces with meaningful pick lists or for generating query
084: * predicates that have a higher chance of actually identifying a result set. It should be noted
085: * that the GetDomain operation is a �best-effort� operation. That is to say that a catalogue tries
086: * to generate useful information about the specified request parameter or property if it can. It is
087: * entirely possible that a catalogue may not be able to determine anything about the values of a
088: * property or request parameter in which case an empty response should be generated.</td>
089: * </tr>
090: * <tr>
091: * <td>GetRecords</td>
092: * <td align="center">X</td>
093: * <td>The primary means of resource discovery in the general model are the two operations search
094: * and present. In the HTTP protocol binding these are combined in the form of the mandatory
095: * GetRecords operation, which does a search and a piggybacked present.</td>
096: * </tr>
097: * <tr>
098: * <td>GetRecordById</td>
099: * <td align="center">X</td>
100: * <td>The mandatory GetRecordById request retrieves the default representation of catalogue
101: * records using their identifier. The GetRecordById operation is an implementation of the Present
102: * operation from the general model. This operation presumes that a previous query has been
103: * performed in order to obtain the identifiers that may be used with this operation. For example,
104: * records returned by a GetRecords operation may contain references to other records in the
105: * catalogue that may be retrieved using the GetRecordById operation. This operation is also a
106: * subset of the GetRecords operation, and is included as a convenient short form for retrieving and
107: * linking to records in a catalogue.</td>
108: * </tr>
109: * <tr>
110: * <td>Transaction</td>
111: * <td align="center">-</td>
112: * <td>The optional Transaction operation defines an interface for creating, modifying and deleting
113: * catalogue records. The specific payload being manipulated must be defined in a profile.</td>
114: * </tr>
115: * <tr>
116: * <td>Harvest</td>
117: * <td align="center">-</td>
118: * <td>The optional Harvest operation is an operation that "pulls" data into the catalogue. That
119: * is, this operation only references the data to be inserted or updated in the catalogue, and it is
120: * the job of the catalogue service to resolve the reference, fetch that data, and process it into
121: * the catalogue. The Harvest operation has two modes of operation, controlled by a flag in the
122: * request. The first mode of operation is a synchronous mode in which the CSW receives a Harvest
123: * request from the client, processes it immediately, and sends the results to the client while the
124: * client waits. The second mode of operation is asynchronous in that the server receives a Harvest
125: * request from the client, and sends the client an immediate acknowledgement that the request has
126: * been successfully received. The server can then process the Harvest request whenever it likes,
127: * taking as much time as is required and then send the results of the processing to a URI specified
128: * in the original Harvest request. This latter mode of operation is included to support Harvest
129: * requests that could run for a period of time longer than most HTTP timeout's will allow.
130: * Processing a Harvest request means that the CSW resolves the URI pointing to the metadata
131: * resource, parses the resource, and then creates or modifies metadata records in the catalogue in
132: * order to register the resource. This operation may be performed only once or periodically
133: * depending on how the client invokes the operation.</td>
134: * </tr>
135: * </table>
136: *
137: * @see org.deegree.ogcwebservices.getcapabilities.OperationsMetadata
138: * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
139: * @author last edited by: $Author: apoth $
140: *
141: * @version $Revision: 9345 $, $Date: 2007-12-27 08:22:25 -0800 (Thu, 27 Dec 2007) $
142: */
143:
144: public class CatalogueOperationsMetadata extends OperationsMetadata {
145:
146: public static final String DESCRIBE_RECORD_NAME = "DescribeRecord";
147:
148: public static final String GET_DOMAIN_NAME = "GetDomain";
149:
150: public static final String GET_RECORDS_NAME = "GetRecords";
151:
152: public static final String GET_RECORD_BY_ID_NAME = "GetRecordById";
153:
154: /**
155: * Identifier for a {@link GetRepositoryItem} request.
156: */
157: public static final String GET_REPOSITORY_ITEM = "GetRepositoryItem";
158:
159: public static final String TRANSACTION_NAME = "Transaction";
160:
161: public static final String HARVEST_NAME = "Harvest";
162:
163: private Operation describeRecord;
164:
165: private Operation getDomain;
166:
167: private Operation getRecords;
168:
169: private Operation getRecordById;
170:
171: private Operation transaction;
172:
173: private Operation harvest;
174:
175: /**
176: * Constructs a new <code>CatalogOperationsMetadata</code> from the given parameters.
177: *
178: * @param getCapabilities
179: * @param describeRecord
180: * @param getDomain
181: * @param getRecords
182: * @param getRecordById
183: * @param transaction
184: * @param harvest
185: * @param parameters
186: * @param constraints
187: */
188: public CatalogueOperationsMetadata(Operation getCapabilities,
189: Operation describeRecord, Operation getDomain,
190: Operation getRecords, Operation getRecordById,
191: Operation transaction, Operation harvest,
192: OWSDomainType[] parameters, OWSDomainType[] constraints) {
193: super (getCapabilities, parameters, constraints);
194: this .describeRecord = describeRecord;
195: this .getDomain = getDomain;
196: this .getRecords = getRecords;
197: this .getRecordById = getRecordById;
198: this .transaction = transaction;
199: this .harvest = harvest;
200: }
201:
202: /**
203: * Returns all <code>Operations</code>.
204: *
205: * @return all <code>Operations</code>.
206: */
207: public Operation[] getOperations() {
208: List<Operation> list = new ArrayList<Operation>();
209: list.add(getCapabilitiesOperation);
210: list.add(describeRecord);
211: list.add(getRecords);
212: if (getRecordById != null) {
213: list.add(getRecordById);
214: }
215: if (getDomain != null) {
216: list.add(getDomain);
217: }
218: if (transaction != null) {
219: list.add(transaction);
220: }
221: if (harvest != null) {
222: list.add(harvest);
223: }
224: return list.toArray(new Operation[list.size()]);
225: }
226:
227: /**
228: * @return the describeRecord.
229: *
230: */
231: public Operation getDescribeRecord() {
232: return describeRecord;
233: }
234:
235: /**
236: * @param describeRecord
237: * The describeRecord to set.
238: *
239: */
240: public void setDescribeRecord(Operation describeRecord) {
241: this .describeRecord = describeRecord;
242: }
243:
244: /**
245: * @return the getDomain.
246: *
247: */
248: public Operation getGetDomain() {
249: return getDomain;
250: }
251:
252: /**
253: * @param getDomain
254: * The getDomain to set.
255: *
256: */
257: public void setGetDomain(Operation getDomain) {
258: this .getDomain = getDomain;
259: }
260:
261: /**
262: * @return the getRecordById.
263: *
264: */
265: public Operation getGetRecordById() {
266: return getRecordById;
267: }
268:
269: /**
270: * @param getRecordById
271: * The getRecordId to set.
272: *
273: */
274: public void setGetRecordById(Operation getRecordById) {
275: this .getRecordById = getRecordById;
276: }
277:
278: /**
279: * @return the getRecords.
280: *
281: */
282: public Operation getGetRecords() {
283: return getRecords;
284: }
285:
286: /**
287: * @param getRecords
288: * The getRecords to set.
289: *
290: */
291: public void setGetRecords(Operation getRecords) {
292: this .getRecords = getRecords;
293: }
294:
295: /**
296: * @return the harvest.
297: *
298: */
299: public Operation getHarvest() {
300: return harvest;
301: }
302:
303: /**
304: * @param harvest
305: * The harvest to set.
306: *
307: */
308: public void setHarvest(Operation harvest) {
309: this .harvest = harvest;
310: }
311:
312: /**
313: * @return the transaction.
314: *
315: */
316: public Operation getTransaction() {
317: return transaction;
318: }
319:
320: /**
321: * @param transaction
322: * The transaction to set.
323: *
324: */
325: public void setTransaction(Operation transaction) {
326: this.transaction = transaction;
327: }
328:
329: }
|