001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    /**
020     * Provides a wrapper for {@link LockLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see LockLocalService
024     * @generated
025     */
026    @ProviderType
027    public class LockLocalServiceWrapper implements LockLocalService,
028            ServiceWrapper<LockLocalService> {
029            public LockLocalServiceWrapper(LockLocalService lockLocalService) {
030                    _lockLocalService = lockLocalService;
031            }
032    
033            /**
034            * Adds the lock to the database. Also notifies the appropriate model listeners.
035            *
036            * @param lock the lock
037            * @return the lock that was added
038            */
039            @Override
040            public com.liferay.portal.model.Lock addLock(
041                    com.liferay.portal.model.Lock lock) {
042                    return _lockLocalService.addLock(lock);
043            }
044    
045            @Override
046            public void clear() {
047                    _lockLocalService.clear();
048            }
049    
050            /**
051            * Creates a new lock with the primary key. Does not add the lock to the database.
052            *
053            * @param lockId the primary key for the new lock
054            * @return the new lock
055            */
056            @Override
057            public com.liferay.portal.model.Lock createLock(long lockId) {
058                    return _lockLocalService.createLock(lockId);
059            }
060    
061            /**
062            * Deletes the lock from the database. Also notifies the appropriate model listeners.
063            *
064            * @param lock the lock
065            * @return the lock that was removed
066            */
067            @Override
068            public com.liferay.portal.model.Lock deleteLock(
069                    com.liferay.portal.model.Lock lock) {
070                    return _lockLocalService.deleteLock(lock);
071            }
072    
073            /**
074            * Deletes the lock with the primary key from the database. Also notifies the appropriate model listeners.
075            *
076            * @param lockId the primary key of the lock
077            * @return the lock that was removed
078            * @throws PortalException if a lock with the primary key could not be found
079            */
080            @Override
081            public com.liferay.portal.model.Lock deleteLock(long lockId)
082                    throws com.liferay.portal.kernel.exception.PortalException {
083                    return _lockLocalService.deleteLock(lockId);
084            }
085    
086            /**
087            * @throws PortalException
088            */
089            @Override
090            public com.liferay.portal.model.PersistedModel deletePersistedModel(
091                    com.liferay.portal.model.PersistedModel persistedModel)
092                    throws com.liferay.portal.kernel.exception.PortalException {
093                    return _lockLocalService.deletePersistedModel(persistedModel);
094            }
095    
096            @Override
097            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
098                    return _lockLocalService.dynamicQuery();
099            }
100    
101            /**
102            * Performs a dynamic query on the database and returns the matching rows.
103            *
104            * @param dynamicQuery the dynamic query
105            * @return the matching rows
106            */
107            @Override
108            public <T> java.util.List<T> dynamicQuery(
109                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
110                    return _lockLocalService.dynamicQuery(dynamicQuery);
111            }
112    
113            /**
114            * Performs a dynamic query on the database and returns a range of the matching rows.
115            *
116            * <p>
117            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LockModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
118            * </p>
119            *
120            * @param dynamicQuery the dynamic query
121            * @param start the lower bound of the range of model instances
122            * @param end the upper bound of the range of model instances (not inclusive)
123            * @return the range of matching rows
124            */
125            @Override
126            public <T> java.util.List<T> dynamicQuery(
127                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
128                    int end) {
129                    return _lockLocalService.dynamicQuery(dynamicQuery, start, end);
130            }
131    
132            /**
133            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
134            *
135            * <p>
136            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LockModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
137            * </p>
138            *
139            * @param dynamicQuery the dynamic query
140            * @param start the lower bound of the range of model instances
141            * @param end the upper bound of the range of model instances (not inclusive)
142            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
143            * @return the ordered range of matching rows
144            */
145            @Override
146            public <T> java.util.List<T> dynamicQuery(
147                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
148                    int end,
149                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
150                    return _lockLocalService.dynamicQuery(dynamicQuery, start, end,
151                            orderByComparator);
152            }
153    
154            /**
155            * Returns the number of rows matching the dynamic query.
156            *
157            * @param dynamicQuery the dynamic query
158            * @return the number of rows matching the dynamic query
159            */
160            @Override
161            public long dynamicQueryCount(
162                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
163                    return _lockLocalService.dynamicQueryCount(dynamicQuery);
164            }
165    
166            /**
167            * Returns the number of rows matching the dynamic query.
168            *
169            * @param dynamicQuery the dynamic query
170            * @param projection the projection to apply to the query
171            * @return the number of rows matching the dynamic query
172            */
173            @Override
174            public long dynamicQueryCount(
175                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
176                    com.liferay.portal.kernel.dao.orm.Projection projection) {
177                    return _lockLocalService.dynamicQueryCount(dynamicQuery, projection);
178            }
179    
180            @Override
181            public com.liferay.portal.model.Lock fetchLock(long lockId) {
182                    return _lockLocalService.fetchLock(lockId);
183            }
184    
185            /**
186            * Returns the lock with the matching UUID and company.
187            *
188            * @param uuid the lock's UUID
189            * @param companyId the primary key of the company
190            * @return the matching lock, or <code>null</code> if a matching lock could not be found
191            */
192            @Override
193            public com.liferay.portal.model.Lock fetchLockByUuidAndCompanyId(
194                    java.lang.String uuid, long companyId) {
195                    return _lockLocalService.fetchLockByUuidAndCompanyId(uuid, companyId);
196            }
197    
198            @Override
199            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
200                    return _lockLocalService.getActionableDynamicQuery();
201            }
202    
203            /**
204            * Returns the Spring bean ID for this bean.
205            *
206            * @return the Spring bean ID for this bean
207            */
208            @Override
209            public java.lang.String getBeanIdentifier() {
210                    return _lockLocalService.getBeanIdentifier();
211            }
212    
213            @Override
214            public com.liferay.portal.model.Lock getLock(java.lang.String className,
215                    long key) throws com.liferay.portal.kernel.exception.PortalException {
216                    return _lockLocalService.getLock(className, key);
217            }
218    
219            @Override
220            public com.liferay.portal.model.Lock getLock(java.lang.String className,
221                    java.lang.String key)
222                    throws com.liferay.portal.kernel.exception.PortalException {
223                    return _lockLocalService.getLock(className, key);
224            }
225    
226            /**
227            * Returns the lock with the primary key.
228            *
229            * @param lockId the primary key of the lock
230            * @return the lock
231            * @throws PortalException if a lock with the primary key could not be found
232            */
233            @Override
234            public com.liferay.portal.model.Lock getLock(long lockId)
235                    throws com.liferay.portal.kernel.exception.PortalException {
236                    return _lockLocalService.getLock(lockId);
237            }
238    
239            /**
240            * Returns the lock with the matching UUID and company.
241            *
242            * @param uuid the lock's UUID
243            * @param companyId the primary key of the company
244            * @return the matching lock
245            * @throws PortalException if a matching lock could not be found
246            */
247            @Override
248            public com.liferay.portal.model.Lock getLockByUuidAndCompanyId(
249                    java.lang.String uuid, long companyId)
250                    throws com.liferay.portal.kernel.exception.PortalException {
251                    return _lockLocalService.getLockByUuidAndCompanyId(uuid, companyId);
252            }
253    
254            /**
255            * Returns a range of all the locks.
256            *
257            * <p>
258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LockModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
259            * </p>
260            *
261            * @param start the lower bound of the range of locks
262            * @param end the upper bound of the range of locks (not inclusive)
263            * @return the range of locks
264            */
265            @Override
266            public java.util.List<com.liferay.portal.model.Lock> getLocks(int start,
267                    int end) {
268                    return _lockLocalService.getLocks(start, end);
269            }
270    
271            /**
272            * Returns the number of locks.
273            *
274            * @return the number of locks
275            */
276            @Override
277            public int getLocksCount() {
278                    return _lockLocalService.getLocksCount();
279            }
280    
281            @Override
282            public com.liferay.portal.model.PersistedModel getPersistedModel(
283                    java.io.Serializable primaryKeyObj)
284                    throws com.liferay.portal.kernel.exception.PortalException {
285                    return _lockLocalService.getPersistedModel(primaryKeyObj);
286            }
287    
288            @Override
289            public boolean hasLock(long userId, java.lang.String className,
290                    java.lang.String key) {
291                    return _lockLocalService.hasLock(userId, className, key);
292            }
293    
294            @Override
295            public boolean hasLock(long userId, java.lang.String className, long key) {
296                    return _lockLocalService.hasLock(userId, className, key);
297            }
298    
299            @Override
300            public boolean isLocked(java.lang.String className, java.lang.String key) {
301                    return _lockLocalService.isLocked(className, key);
302            }
303    
304            @Override
305            public boolean isLocked(java.lang.String className, long key) {
306                    return _lockLocalService.isLocked(className, key);
307            }
308    
309            @Override
310            public com.liferay.portal.model.Lock lock(java.lang.String className,
311                    java.lang.String key, java.lang.String expectedOwner,
312                    java.lang.String updatedOwner) {
313                    return _lockLocalService.lock(className, key, expectedOwner,
314                            updatedOwner);
315            }
316    
317            /**
318            * @deprecated As of 6.2.0, replaced by {@link #lock(String, String, String,
319            String)}
320            */
321            @Deprecated
322            @Override
323            public com.liferay.portal.model.Lock lock(java.lang.String className,
324                    java.lang.String key, java.lang.String expectedOwner,
325                    java.lang.String updatedOwner, boolean retrieveFromCache) {
326                    return _lockLocalService.lock(className, key, expectedOwner,
327                            updatedOwner, retrieveFromCache);
328            }
329    
330            @Override
331            public com.liferay.portal.model.Lock lock(java.lang.String className,
332                    java.lang.String key, java.lang.String owner) {
333                    return _lockLocalService.lock(className, key, owner);
334            }
335    
336            /**
337            * @deprecated As of 6.2.0, replaced by {@link #lock(String, String,
338            String)}
339            */
340            @Deprecated
341            @Override
342            public com.liferay.portal.model.Lock lock(java.lang.String className,
343                    java.lang.String key, java.lang.String owner, boolean retrieveFromCache) {
344                    return _lockLocalService.lock(className, key, owner, retrieveFromCache);
345            }
346    
347            @Override
348            public com.liferay.portal.model.Lock lock(long userId,
349                    java.lang.String className, java.lang.String key,
350                    java.lang.String owner, boolean inheritable, long expirationTime)
351                    throws com.liferay.portal.kernel.exception.PortalException {
352                    return _lockLocalService.lock(userId, className, key, owner,
353                            inheritable, expirationTime);
354            }
355    
356            @Override
357            public com.liferay.portal.model.Lock lock(long userId,
358                    java.lang.String className, long key, java.lang.String owner,
359                    boolean inheritable, long expirationTime)
360                    throws com.liferay.portal.kernel.exception.PortalException {
361                    return _lockLocalService.lock(userId, className, key, owner,
362                            inheritable, expirationTime);
363            }
364    
365            @Override
366            public com.liferay.portal.model.Lock refresh(java.lang.String uuid,
367                    long companyId, long expirationTime)
368                    throws com.liferay.portal.kernel.exception.PortalException {
369                    return _lockLocalService.refresh(uuid, companyId, expirationTime);
370            }
371    
372            /**
373            * Sets the Spring bean ID for this bean.
374            *
375            * @param beanIdentifier the Spring bean ID for this bean
376            */
377            @Override
378            public void setBeanIdentifier(java.lang.String beanIdentifier) {
379                    _lockLocalService.setBeanIdentifier(beanIdentifier);
380            }
381    
382            @Override
383            public void unlock(java.lang.String className, long key) {
384                    _lockLocalService.unlock(className, key);
385            }
386    
387            @Override
388            public void unlock(java.lang.String className, java.lang.String key) {
389                    _lockLocalService.unlock(className, key);
390            }
391    
392            @Override
393            public void unlock(java.lang.String className, java.lang.String key,
394                    java.lang.String owner) {
395                    _lockLocalService.unlock(className, key, owner);
396            }
397    
398            /**
399            * @deprecated As of 6.2.0, replaced by {@link #unlock(String, String,
400            String)}
401            */
402            @Deprecated
403            @Override
404            public void unlock(java.lang.String className, java.lang.String key,
405                    java.lang.String owner, boolean retrieveFromCache) {
406                    _lockLocalService.unlock(className, key, owner, retrieveFromCache);
407            }
408    
409            /**
410            * Updates the lock in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
411            *
412            * @param lock the lock
413            * @return the lock that was updated
414            */
415            @Override
416            public com.liferay.portal.model.Lock updateLock(
417                    com.liferay.portal.model.Lock lock) {
418                    return _lockLocalService.updateLock(lock);
419            }
420    
421            /**
422             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
423             */
424            @Deprecated
425            public LockLocalService getWrappedLockLocalService() {
426                    return _lockLocalService;
427            }
428    
429            /**
430             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
431             */
432            @Deprecated
433            public void setWrappedLockLocalService(LockLocalService lockLocalService) {
434                    _lockLocalService = lockLocalService;
435            }
436    
437            @Override
438            public LockLocalService getWrappedService() {
439                    return _lockLocalService;
440            }
441    
442            @Override
443            public void setWrappedService(LockLocalService lockLocalService) {
444                    _lockLocalService = lockLocalService;
445            }
446    
447            private LockLocalService _lockLocalService;
448    }