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.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.UserTracker;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the user tracker service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see UserTrackerPersistence
037     * @see com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class UserTrackerUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(UserTracker userTracker) {
059                    getPersistence().clearCache(userTracker);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<UserTracker> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<UserTracker> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<UserTracker> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<UserTracker> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static UserTracker update(UserTracker userTracker) {
100                    return getPersistence().update(userTracker);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static UserTracker update(UserTracker userTracker,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(userTracker, serviceContext);
109            }
110    
111            /**
112            * Returns all the user trackers where companyId = &#63;.
113            *
114            * @param companyId the company ID
115            * @return the matching user trackers
116            */
117            public static List<UserTracker> findByCompanyId(long companyId) {
118                    return getPersistence().findByCompanyId(companyId);
119            }
120    
121            /**
122            * Returns a range of all the user trackers where companyId = &#63;.
123            *
124            * <p>
125            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
126            * </p>
127            *
128            * @param companyId the company ID
129            * @param start the lower bound of the range of user trackers
130            * @param end the upper bound of the range of user trackers (not inclusive)
131            * @return the range of matching user trackers
132            */
133            public static List<UserTracker> findByCompanyId(long companyId, int start,
134                    int end) {
135                    return getPersistence().findByCompanyId(companyId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the user trackers where companyId = &#63;.
140            *
141            * <p>
142            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
143            * </p>
144            *
145            * @param companyId the company ID
146            * @param start the lower bound of the range of user trackers
147            * @param end the upper bound of the range of user trackers (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching user trackers
150            */
151            public static List<UserTracker> findByCompanyId(long companyId, int start,
152                    int end, OrderByComparator<UserTracker> orderByComparator) {
153                    return getPersistence()
154                                       .findByCompanyId(companyId, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first user tracker in the ordered set where companyId = &#63;.
159            *
160            * @param companyId the company ID
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching user tracker
163            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
164            */
165            public static UserTracker findByCompanyId_First(long companyId,
166                    OrderByComparator<UserTracker> orderByComparator)
167                    throws com.liferay.portal.NoSuchUserTrackerException {
168                    return getPersistence()
169                                       .findByCompanyId_First(companyId, orderByComparator);
170            }
171    
172            /**
173            * Returns the first user tracker in the ordered set where companyId = &#63;.
174            *
175            * @param companyId the company ID
176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
177            * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found
178            */
179            public static UserTracker fetchByCompanyId_First(long companyId,
180                    OrderByComparator<UserTracker> orderByComparator) {
181                    return getPersistence()
182                                       .fetchByCompanyId_First(companyId, orderByComparator);
183            }
184    
185            /**
186            * Returns the last user tracker in the ordered set where companyId = &#63;.
187            *
188            * @param companyId the company ID
189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
190            * @return the last matching user tracker
191            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
192            */
193            public static UserTracker findByCompanyId_Last(long companyId,
194                    OrderByComparator<UserTracker> orderByComparator)
195                    throws com.liferay.portal.NoSuchUserTrackerException {
196                    return getPersistence()
197                                       .findByCompanyId_Last(companyId, orderByComparator);
198            }
199    
200            /**
201            * Returns the last user tracker in the ordered set where companyId = &#63;.
202            *
203            * @param companyId the company ID
204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
205            * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found
206            */
207            public static UserTracker fetchByCompanyId_Last(long companyId,
208                    OrderByComparator<UserTracker> orderByComparator) {
209                    return getPersistence()
210                                       .fetchByCompanyId_Last(companyId, orderByComparator);
211            }
212    
213            /**
214            * Returns the user trackers before and after the current user tracker in the ordered set where companyId = &#63;.
215            *
216            * @param userTrackerId the primary key of the current user tracker
217            * @param companyId the company ID
218            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
219            * @return the previous, current, and next user tracker
220            * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found
221            */
222            public static UserTracker[] findByCompanyId_PrevAndNext(
223                    long userTrackerId, long companyId,
224                    OrderByComparator<UserTracker> orderByComparator)
225                    throws com.liferay.portal.NoSuchUserTrackerException {
226                    return getPersistence()
227                                       .findByCompanyId_PrevAndNext(userTrackerId, companyId,
228                            orderByComparator);
229            }
230    
231            /**
232            * Removes all the user trackers where companyId = &#63; from the database.
233            *
234            * @param companyId the company ID
235            */
236            public static void removeByCompanyId(long companyId) {
237                    getPersistence().removeByCompanyId(companyId);
238            }
239    
240            /**
241            * Returns the number of user trackers where companyId = &#63;.
242            *
243            * @param companyId the company ID
244            * @return the number of matching user trackers
245            */
246            public static int countByCompanyId(long companyId) {
247                    return getPersistence().countByCompanyId(companyId);
248            }
249    
250            /**
251            * Returns all the user trackers where userId = &#63;.
252            *
253            * @param userId the user ID
254            * @return the matching user trackers
255            */
256            public static List<UserTracker> findByUserId(long userId) {
257                    return getPersistence().findByUserId(userId);
258            }
259    
260            /**
261            * Returns a range of all the user trackers where userId = &#63;.
262            *
263            * <p>
264            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
265            * </p>
266            *
267            * @param userId the user ID
268            * @param start the lower bound of the range of user trackers
269            * @param end the upper bound of the range of user trackers (not inclusive)
270            * @return the range of matching user trackers
271            */
272            public static List<UserTracker> findByUserId(long userId, int start, int end) {
273                    return getPersistence().findByUserId(userId, start, end);
274            }
275    
276            /**
277            * Returns an ordered range of all the user trackers where userId = &#63;.
278            *
279            * <p>
280            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
281            * </p>
282            *
283            * @param userId the user ID
284            * @param start the lower bound of the range of user trackers
285            * @param end the upper bound of the range of user trackers (not inclusive)
286            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
287            * @return the ordered range of matching user trackers
288            */
289            public static List<UserTracker> findByUserId(long userId, int start,
290                    int end, OrderByComparator<UserTracker> orderByComparator) {
291                    return getPersistence()
292                                       .findByUserId(userId, start, end, orderByComparator);
293            }
294    
295            /**
296            * Returns the first user tracker in the ordered set where userId = &#63;.
297            *
298            * @param userId the user ID
299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
300            * @return the first matching user tracker
301            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
302            */
303            public static UserTracker findByUserId_First(long userId,
304                    OrderByComparator<UserTracker> orderByComparator)
305                    throws com.liferay.portal.NoSuchUserTrackerException {
306                    return getPersistence().findByUserId_First(userId, orderByComparator);
307            }
308    
309            /**
310            * Returns the first user tracker in the ordered set where userId = &#63;.
311            *
312            * @param userId the user ID
313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
314            * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found
315            */
316            public static UserTracker fetchByUserId_First(long userId,
317                    OrderByComparator<UserTracker> orderByComparator) {
318                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
319            }
320    
321            /**
322            * Returns the last user tracker in the ordered set where userId = &#63;.
323            *
324            * @param userId the user ID
325            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
326            * @return the last matching user tracker
327            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
328            */
329            public static UserTracker findByUserId_Last(long userId,
330                    OrderByComparator<UserTracker> orderByComparator)
331                    throws com.liferay.portal.NoSuchUserTrackerException {
332                    return getPersistence().findByUserId_Last(userId, orderByComparator);
333            }
334    
335            /**
336            * Returns the last user tracker in the ordered set where userId = &#63;.
337            *
338            * @param userId the user ID
339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
340            * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found
341            */
342            public static UserTracker fetchByUserId_Last(long userId,
343                    OrderByComparator<UserTracker> orderByComparator) {
344                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
345            }
346    
347            /**
348            * Returns the user trackers before and after the current user tracker in the ordered set where userId = &#63;.
349            *
350            * @param userTrackerId the primary key of the current user tracker
351            * @param userId the user ID
352            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
353            * @return the previous, current, and next user tracker
354            * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found
355            */
356            public static UserTracker[] findByUserId_PrevAndNext(long userTrackerId,
357                    long userId, OrderByComparator<UserTracker> orderByComparator)
358                    throws com.liferay.portal.NoSuchUserTrackerException {
359                    return getPersistence()
360                                       .findByUserId_PrevAndNext(userTrackerId, userId,
361                            orderByComparator);
362            }
363    
364            /**
365            * Removes all the user trackers where userId = &#63; from the database.
366            *
367            * @param userId the user ID
368            */
369            public static void removeByUserId(long userId) {
370                    getPersistence().removeByUserId(userId);
371            }
372    
373            /**
374            * Returns the number of user trackers where userId = &#63;.
375            *
376            * @param userId the user ID
377            * @return the number of matching user trackers
378            */
379            public static int countByUserId(long userId) {
380                    return getPersistence().countByUserId(userId);
381            }
382    
383            /**
384            * Returns all the user trackers where sessionId = &#63;.
385            *
386            * @param sessionId the session ID
387            * @return the matching user trackers
388            */
389            public static List<UserTracker> findBySessionId(java.lang.String sessionId) {
390                    return getPersistence().findBySessionId(sessionId);
391            }
392    
393            /**
394            * Returns a range of all the user trackers where sessionId = &#63;.
395            *
396            * <p>
397            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
398            * </p>
399            *
400            * @param sessionId the session ID
401            * @param start the lower bound of the range of user trackers
402            * @param end the upper bound of the range of user trackers (not inclusive)
403            * @return the range of matching user trackers
404            */
405            public static List<UserTracker> findBySessionId(
406                    java.lang.String sessionId, int start, int end) {
407                    return getPersistence().findBySessionId(sessionId, start, end);
408            }
409    
410            /**
411            * Returns an ordered range of all the user trackers where sessionId = &#63;.
412            *
413            * <p>
414            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
415            * </p>
416            *
417            * @param sessionId the session ID
418            * @param start the lower bound of the range of user trackers
419            * @param end the upper bound of the range of user trackers (not inclusive)
420            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
421            * @return the ordered range of matching user trackers
422            */
423            public static List<UserTracker> findBySessionId(
424                    java.lang.String sessionId, int start, int end,
425                    OrderByComparator<UserTracker> orderByComparator) {
426                    return getPersistence()
427                                       .findBySessionId(sessionId, start, end, orderByComparator);
428            }
429    
430            /**
431            * Returns the first user tracker in the ordered set where sessionId = &#63;.
432            *
433            * @param sessionId the session ID
434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
435            * @return the first matching user tracker
436            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
437            */
438            public static UserTracker findBySessionId_First(
439                    java.lang.String sessionId,
440                    OrderByComparator<UserTracker> orderByComparator)
441                    throws com.liferay.portal.NoSuchUserTrackerException {
442                    return getPersistence()
443                                       .findBySessionId_First(sessionId, orderByComparator);
444            }
445    
446            /**
447            * Returns the first user tracker in the ordered set where sessionId = &#63;.
448            *
449            * @param sessionId the session ID
450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
451            * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found
452            */
453            public static UserTracker fetchBySessionId_First(
454                    java.lang.String sessionId,
455                    OrderByComparator<UserTracker> orderByComparator) {
456                    return getPersistence()
457                                       .fetchBySessionId_First(sessionId, orderByComparator);
458            }
459    
460            /**
461            * Returns the last user tracker in the ordered set where sessionId = &#63;.
462            *
463            * @param sessionId the session ID
464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
465            * @return the last matching user tracker
466            * @throws NoSuchUserTrackerException if a matching user tracker could not be found
467            */
468            public static UserTracker findBySessionId_Last(java.lang.String sessionId,
469                    OrderByComparator<UserTracker> orderByComparator)
470                    throws com.liferay.portal.NoSuchUserTrackerException {
471                    return getPersistence()
472                                       .findBySessionId_Last(sessionId, orderByComparator);
473            }
474    
475            /**
476            * Returns the last user tracker in the ordered set where sessionId = &#63;.
477            *
478            * @param sessionId the session ID
479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
480            * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found
481            */
482            public static UserTracker fetchBySessionId_Last(
483                    java.lang.String sessionId,
484                    OrderByComparator<UserTracker> orderByComparator) {
485                    return getPersistence()
486                                       .fetchBySessionId_Last(sessionId, orderByComparator);
487            }
488    
489            /**
490            * Returns the user trackers before and after the current user tracker in the ordered set where sessionId = &#63;.
491            *
492            * @param userTrackerId the primary key of the current user tracker
493            * @param sessionId the session ID
494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
495            * @return the previous, current, and next user tracker
496            * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found
497            */
498            public static UserTracker[] findBySessionId_PrevAndNext(
499                    long userTrackerId, java.lang.String sessionId,
500                    OrderByComparator<UserTracker> orderByComparator)
501                    throws com.liferay.portal.NoSuchUserTrackerException {
502                    return getPersistence()
503                                       .findBySessionId_PrevAndNext(userTrackerId, sessionId,
504                            orderByComparator);
505            }
506    
507            /**
508            * Removes all the user trackers where sessionId = &#63; from the database.
509            *
510            * @param sessionId the session ID
511            */
512            public static void removeBySessionId(java.lang.String sessionId) {
513                    getPersistence().removeBySessionId(sessionId);
514            }
515    
516            /**
517            * Returns the number of user trackers where sessionId = &#63;.
518            *
519            * @param sessionId the session ID
520            * @return the number of matching user trackers
521            */
522            public static int countBySessionId(java.lang.String sessionId) {
523                    return getPersistence().countBySessionId(sessionId);
524            }
525    
526            /**
527            * Caches the user tracker in the entity cache if it is enabled.
528            *
529            * @param userTracker the user tracker
530            */
531            public static void cacheResult(UserTracker userTracker) {
532                    getPersistence().cacheResult(userTracker);
533            }
534    
535            /**
536            * Caches the user trackers in the entity cache if it is enabled.
537            *
538            * @param userTrackers the user trackers
539            */
540            public static void cacheResult(List<UserTracker> userTrackers) {
541                    getPersistence().cacheResult(userTrackers);
542            }
543    
544            /**
545            * Creates a new user tracker with the primary key. Does not add the user tracker to the database.
546            *
547            * @param userTrackerId the primary key for the new user tracker
548            * @return the new user tracker
549            */
550            public static UserTracker create(long userTrackerId) {
551                    return getPersistence().create(userTrackerId);
552            }
553    
554            /**
555            * Removes the user tracker with the primary key from the database. Also notifies the appropriate model listeners.
556            *
557            * @param userTrackerId the primary key of the user tracker
558            * @return the user tracker that was removed
559            * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found
560            */
561            public static UserTracker remove(long userTrackerId)
562                    throws com.liferay.portal.NoSuchUserTrackerException {
563                    return getPersistence().remove(userTrackerId);
564            }
565    
566            public static UserTracker updateImpl(UserTracker userTracker) {
567                    return getPersistence().updateImpl(userTracker);
568            }
569    
570            /**
571            * Returns the user tracker with the primary key or throws a {@link NoSuchUserTrackerException} if it could not be found.
572            *
573            * @param userTrackerId the primary key of the user tracker
574            * @return the user tracker
575            * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found
576            */
577            public static UserTracker findByPrimaryKey(long userTrackerId)
578                    throws com.liferay.portal.NoSuchUserTrackerException {
579                    return getPersistence().findByPrimaryKey(userTrackerId);
580            }
581    
582            /**
583            * Returns the user tracker with the primary key or returns <code>null</code> if it could not be found.
584            *
585            * @param userTrackerId the primary key of the user tracker
586            * @return the user tracker, or <code>null</code> if a user tracker with the primary key could not be found
587            */
588            public static UserTracker fetchByPrimaryKey(long userTrackerId) {
589                    return getPersistence().fetchByPrimaryKey(userTrackerId);
590            }
591    
592            public static java.util.Map<java.io.Serializable, UserTracker> fetchByPrimaryKeys(
593                    java.util.Set<java.io.Serializable> primaryKeys) {
594                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
595            }
596    
597            /**
598            * Returns all the user trackers.
599            *
600            * @return the user trackers
601            */
602            public static List<UserTracker> findAll() {
603                    return getPersistence().findAll();
604            }
605    
606            /**
607            * Returns a range of all the user trackers.
608            *
609            * <p>
610            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
611            * </p>
612            *
613            * @param start the lower bound of the range of user trackers
614            * @param end the upper bound of the range of user trackers (not inclusive)
615            * @return the range of user trackers
616            */
617            public static List<UserTracker> findAll(int start, int end) {
618                    return getPersistence().findAll(start, end);
619            }
620    
621            /**
622            * Returns an ordered range of all the user trackers.
623            *
624            * <p>
625            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserTrackerModelImpl}. 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.
626            * </p>
627            *
628            * @param start the lower bound of the range of user trackers
629            * @param end the upper bound of the range of user trackers (not inclusive)
630            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
631            * @return the ordered range of user trackers
632            */
633            public static List<UserTracker> findAll(int start, int end,
634                    OrderByComparator<UserTracker> orderByComparator) {
635                    return getPersistence().findAll(start, end, orderByComparator);
636            }
637    
638            /**
639            * Removes all the user trackers from the database.
640            */
641            public static void removeAll() {
642                    getPersistence().removeAll();
643            }
644    
645            /**
646            * Returns the number of user trackers.
647            *
648            * @return the number of user trackers
649            */
650            public static int countAll() {
651                    return getPersistence().countAll();
652            }
653    
654            public static UserTrackerPersistence getPersistence() {
655                    if (_persistence == null) {
656                            _persistence = (UserTrackerPersistence)PortalBeanLocatorUtil.locate(UserTrackerPersistence.class.getName());
657    
658                            ReferenceRegistry.registerReference(UserTrackerUtil.class,
659                                    "_persistence");
660                    }
661    
662                    return _persistence;
663            }
664    
665            /**
666             * @deprecated As of 6.2.0
667             */
668            @Deprecated
669            public void setPersistence(UserTrackerPersistence persistence) {
670            }
671    
672            private static UserTrackerPersistence _persistence;
673    }