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.SystemEvent;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the system event service. This utility wraps {@link com.liferay.portal.service.persistence.impl.SystemEventPersistenceImpl} 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 SystemEventPersistence
037     * @see com.liferay.portal.service.persistence.impl.SystemEventPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class SystemEventUtil {
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(SystemEvent systemEvent) {
059                    getPersistence().clearCache(systemEvent);
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<SystemEvent> 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<SystemEvent> 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<SystemEvent> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<SystemEvent> 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 SystemEvent update(SystemEvent systemEvent) {
100                    return getPersistence().update(systemEvent);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static SystemEvent update(SystemEvent systemEvent,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(systemEvent, serviceContext);
109            }
110    
111            /**
112            * Returns all the system events where groupId = &#63;.
113            *
114            * @param groupId the group ID
115            * @return the matching system events
116            */
117            public static List<SystemEvent> findByGroupId(long groupId) {
118                    return getPersistence().findByGroupId(groupId);
119            }
120    
121            /**
122            * Returns a range of all the system events where groupId = &#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 SystemEventModelImpl}. 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 groupId the group ID
129            * @param start the lower bound of the range of system events
130            * @param end the upper bound of the range of system events (not inclusive)
131            * @return the range of matching system events
132            */
133            public static List<SystemEvent> findByGroupId(long groupId, int start,
134                    int end) {
135                    return getPersistence().findByGroupId(groupId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the system events where groupId = &#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 SystemEventModelImpl}. 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 groupId the group ID
146            * @param start the lower bound of the range of system events
147            * @param end the upper bound of the range of system events (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching system events
150            */
151            public static List<SystemEvent> findByGroupId(long groupId, int start,
152                    int end, OrderByComparator<SystemEvent> orderByComparator) {
153                    return getPersistence()
154                                       .findByGroupId(groupId, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the system events where groupId = &#63;.
159            *
160            * <p>
161            * 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 SystemEventModelImpl}. 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.
162            * </p>
163            *
164            * @param groupId the group ID
165            * @param start the lower bound of the range of system events
166            * @param end the upper bound of the range of system events (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching system events
170            */
171            public static List<SystemEvent> findByGroupId(long groupId, int start,
172                    int end, OrderByComparator<SystemEvent> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByGroupId(groupId, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first system event in the ordered set where groupId = &#63;.
181            *
182            * @param groupId the group ID
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching system event
185            * @throws NoSuchSystemEventException if a matching system event could not be found
186            */
187            public static SystemEvent findByGroupId_First(long groupId,
188                    OrderByComparator<SystemEvent> orderByComparator)
189                    throws com.liferay.portal.exception.NoSuchSystemEventException {
190                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
191            }
192    
193            /**
194            * Returns the first system event in the ordered set where groupId = &#63;.
195            *
196            * @param groupId the group ID
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching system event, or <code>null</code> if a matching system event could not be found
199            */
200            public static SystemEvent fetchByGroupId_First(long groupId,
201                    OrderByComparator<SystemEvent> orderByComparator) {
202                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
203            }
204    
205            /**
206            * Returns the last system event in the ordered set where groupId = &#63;.
207            *
208            * @param groupId the group ID
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching system event
211            * @throws NoSuchSystemEventException if a matching system event could not be found
212            */
213            public static SystemEvent findByGroupId_Last(long groupId,
214                    OrderByComparator<SystemEvent> orderByComparator)
215                    throws com.liferay.portal.exception.NoSuchSystemEventException {
216                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
217            }
218    
219            /**
220            * Returns the last system event in the ordered set where groupId = &#63;.
221            *
222            * @param groupId the group ID
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching system event, or <code>null</code> if a matching system event could not be found
225            */
226            public static SystemEvent fetchByGroupId_Last(long groupId,
227                    OrderByComparator<SystemEvent> orderByComparator) {
228                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
229            }
230    
231            /**
232            * Returns the system events before and after the current system event in the ordered set where groupId = &#63;.
233            *
234            * @param systemEventId the primary key of the current system event
235            * @param groupId the group ID
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next system event
238            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
239            */
240            public static SystemEvent[] findByGroupId_PrevAndNext(long systemEventId,
241                    long groupId, OrderByComparator<SystemEvent> orderByComparator)
242                    throws com.liferay.portal.exception.NoSuchSystemEventException {
243                    return getPersistence()
244                                       .findByGroupId_PrevAndNext(systemEventId, groupId,
245                            orderByComparator);
246            }
247    
248            /**
249            * Removes all the system events where groupId = &#63; from the database.
250            *
251            * @param groupId the group ID
252            */
253            public static void removeByGroupId(long groupId) {
254                    getPersistence().removeByGroupId(groupId);
255            }
256    
257            /**
258            * Returns the number of system events where groupId = &#63;.
259            *
260            * @param groupId the group ID
261            * @return the number of matching system events
262            */
263            public static int countByGroupId(long groupId) {
264                    return getPersistence().countByGroupId(groupId);
265            }
266    
267            /**
268            * Returns all the system events where groupId = &#63; and systemEventSetKey = &#63;.
269            *
270            * @param groupId the group ID
271            * @param systemEventSetKey the system event set key
272            * @return the matching system events
273            */
274            public static List<SystemEvent> findByG_S(long groupId,
275                    long systemEventSetKey) {
276                    return getPersistence().findByG_S(groupId, systemEventSetKey);
277            }
278    
279            /**
280            * Returns a range of all the system events where groupId = &#63; and systemEventSetKey = &#63;.
281            *
282            * <p>
283            * 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 SystemEventModelImpl}. 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.
284            * </p>
285            *
286            * @param groupId the group ID
287            * @param systemEventSetKey the system event set key
288            * @param start the lower bound of the range of system events
289            * @param end the upper bound of the range of system events (not inclusive)
290            * @return the range of matching system events
291            */
292            public static List<SystemEvent> findByG_S(long groupId,
293                    long systemEventSetKey, int start, int end) {
294                    return getPersistence().findByG_S(groupId, systemEventSetKey, start, end);
295            }
296    
297            /**
298            * Returns an ordered range of all the system events where groupId = &#63; and systemEventSetKey = &#63;.
299            *
300            * <p>
301            * 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 SystemEventModelImpl}. 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.
302            * </p>
303            *
304            * @param groupId the group ID
305            * @param systemEventSetKey the system event set key
306            * @param start the lower bound of the range of system events
307            * @param end the upper bound of the range of system events (not inclusive)
308            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
309            * @return the ordered range of matching system events
310            */
311            public static List<SystemEvent> findByG_S(long groupId,
312                    long systemEventSetKey, int start, int end,
313                    OrderByComparator<SystemEvent> orderByComparator) {
314                    return getPersistence()
315                                       .findByG_S(groupId, systemEventSetKey, start, end,
316                            orderByComparator);
317            }
318    
319            /**
320            * Returns an ordered range of all the system events where groupId = &#63; and systemEventSetKey = &#63;.
321            *
322            * <p>
323            * 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 SystemEventModelImpl}. 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.
324            * </p>
325            *
326            * @param groupId the group ID
327            * @param systemEventSetKey the system event set key
328            * @param start the lower bound of the range of system events
329            * @param end the upper bound of the range of system events (not inclusive)
330            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
331            * @param retrieveFromCache whether to retrieve from the finder cache
332            * @return the ordered range of matching system events
333            */
334            public static List<SystemEvent> findByG_S(long groupId,
335                    long systemEventSetKey, int start, int end,
336                    OrderByComparator<SystemEvent> orderByComparator,
337                    boolean retrieveFromCache) {
338                    return getPersistence()
339                                       .findByG_S(groupId, systemEventSetKey, start, end,
340                            orderByComparator, retrieveFromCache);
341            }
342    
343            /**
344            * Returns the first system event in the ordered set where groupId = &#63; and systemEventSetKey = &#63;.
345            *
346            * @param groupId the group ID
347            * @param systemEventSetKey the system event set key
348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
349            * @return the first matching system event
350            * @throws NoSuchSystemEventException if a matching system event could not be found
351            */
352            public static SystemEvent findByG_S_First(long groupId,
353                    long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator)
354                    throws com.liferay.portal.exception.NoSuchSystemEventException {
355                    return getPersistence()
356                                       .findByG_S_First(groupId, systemEventSetKey,
357                            orderByComparator);
358            }
359    
360            /**
361            * Returns the first system event in the ordered set where groupId = &#63; and systemEventSetKey = &#63;.
362            *
363            * @param groupId the group ID
364            * @param systemEventSetKey the system event set key
365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
366            * @return the first matching system event, or <code>null</code> if a matching system event could not be found
367            */
368            public static SystemEvent fetchByG_S_First(long groupId,
369                    long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) {
370                    return getPersistence()
371                                       .fetchByG_S_First(groupId, systemEventSetKey,
372                            orderByComparator);
373            }
374    
375            /**
376            * Returns the last system event in the ordered set where groupId = &#63; and systemEventSetKey = &#63;.
377            *
378            * @param groupId the group ID
379            * @param systemEventSetKey the system event set key
380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
381            * @return the last matching system event
382            * @throws NoSuchSystemEventException if a matching system event could not be found
383            */
384            public static SystemEvent findByG_S_Last(long groupId,
385                    long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator)
386                    throws com.liferay.portal.exception.NoSuchSystemEventException {
387                    return getPersistence()
388                                       .findByG_S_Last(groupId, systemEventSetKey, orderByComparator);
389            }
390    
391            /**
392            * Returns the last system event in the ordered set where groupId = &#63; and systemEventSetKey = &#63;.
393            *
394            * @param groupId the group ID
395            * @param systemEventSetKey the system event set key
396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
397            * @return the last matching system event, or <code>null</code> if a matching system event could not be found
398            */
399            public static SystemEvent fetchByG_S_Last(long groupId,
400                    long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) {
401                    return getPersistence()
402                                       .fetchByG_S_Last(groupId, systemEventSetKey,
403                            orderByComparator);
404            }
405    
406            /**
407            * Returns the system events before and after the current system event in the ordered set where groupId = &#63; and systemEventSetKey = &#63;.
408            *
409            * @param systemEventId the primary key of the current system event
410            * @param groupId the group ID
411            * @param systemEventSetKey the system event set key
412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
413            * @return the previous, current, and next system event
414            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
415            */
416            public static SystemEvent[] findByG_S_PrevAndNext(long systemEventId,
417                    long groupId, long systemEventSetKey,
418                    OrderByComparator<SystemEvent> orderByComparator)
419                    throws com.liferay.portal.exception.NoSuchSystemEventException {
420                    return getPersistence()
421                                       .findByG_S_PrevAndNext(systemEventId, groupId,
422                            systemEventSetKey, orderByComparator);
423            }
424    
425            /**
426            * Removes all the system events where groupId = &#63; and systemEventSetKey = &#63; from the database.
427            *
428            * @param groupId the group ID
429            * @param systemEventSetKey the system event set key
430            */
431            public static void removeByG_S(long groupId, long systemEventSetKey) {
432                    getPersistence().removeByG_S(groupId, systemEventSetKey);
433            }
434    
435            /**
436            * Returns the number of system events where groupId = &#63; and systemEventSetKey = &#63;.
437            *
438            * @param groupId the group ID
439            * @param systemEventSetKey the system event set key
440            * @return the number of matching system events
441            */
442            public static int countByG_S(long groupId, long systemEventSetKey) {
443                    return getPersistence().countByG_S(groupId, systemEventSetKey);
444            }
445    
446            /**
447            * Returns all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
448            *
449            * @param groupId the group ID
450            * @param classNameId the class name ID
451            * @param classPK the class p k
452            * @return the matching system events
453            */
454            public static List<SystemEvent> findByG_C_C(long groupId, long classNameId,
455                    long classPK) {
456                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
457            }
458    
459            /**
460            * Returns a range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
461            *
462            * <p>
463            * 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 SystemEventModelImpl}. 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.
464            * </p>
465            *
466            * @param groupId the group ID
467            * @param classNameId the class name ID
468            * @param classPK the class p k
469            * @param start the lower bound of the range of system events
470            * @param end the upper bound of the range of system events (not inclusive)
471            * @return the range of matching system events
472            */
473            public static List<SystemEvent> findByG_C_C(long groupId, long classNameId,
474                    long classPK, int start, int end) {
475                    return getPersistence()
476                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
477            }
478    
479            /**
480            * Returns an ordered range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
481            *
482            * <p>
483            * 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 SystemEventModelImpl}. 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.
484            * </p>
485            *
486            * @param groupId the group ID
487            * @param classNameId the class name ID
488            * @param classPK the class p k
489            * @param start the lower bound of the range of system events
490            * @param end the upper bound of the range of system events (not inclusive)
491            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
492            * @return the ordered range of matching system events
493            */
494            public static List<SystemEvent> findByG_C_C(long groupId, long classNameId,
495                    long classPK, int start, int end,
496                    OrderByComparator<SystemEvent> orderByComparator) {
497                    return getPersistence()
498                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
499                            orderByComparator);
500            }
501    
502            /**
503            * Returns an ordered range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
504            *
505            * <p>
506            * 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 SystemEventModelImpl}. 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.
507            * </p>
508            *
509            * @param groupId the group ID
510            * @param classNameId the class name ID
511            * @param classPK the class p k
512            * @param start the lower bound of the range of system events
513            * @param end the upper bound of the range of system events (not inclusive)
514            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
515            * @param retrieveFromCache whether to retrieve from the finder cache
516            * @return the ordered range of matching system events
517            */
518            public static List<SystemEvent> findByG_C_C(long groupId, long classNameId,
519                    long classPK, int start, int end,
520                    OrderByComparator<SystemEvent> orderByComparator,
521                    boolean retrieveFromCache) {
522                    return getPersistence()
523                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
524                            orderByComparator, retrieveFromCache);
525            }
526    
527            /**
528            * Returns the first system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
529            *
530            * @param groupId the group ID
531            * @param classNameId the class name ID
532            * @param classPK the class p k
533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
534            * @return the first matching system event
535            * @throws NoSuchSystemEventException if a matching system event could not be found
536            */
537            public static SystemEvent findByG_C_C_First(long groupId, long classNameId,
538                    long classPK, OrderByComparator<SystemEvent> orderByComparator)
539                    throws com.liferay.portal.exception.NoSuchSystemEventException {
540                    return getPersistence()
541                                       .findByG_C_C_First(groupId, classNameId, classPK,
542                            orderByComparator);
543            }
544    
545            /**
546            * Returns the first system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
547            *
548            * @param groupId the group ID
549            * @param classNameId the class name ID
550            * @param classPK the class p k
551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
552            * @return the first matching system event, or <code>null</code> if a matching system event could not be found
553            */
554            public static SystemEvent fetchByG_C_C_First(long groupId,
555                    long classNameId, long classPK,
556                    OrderByComparator<SystemEvent> orderByComparator) {
557                    return getPersistence()
558                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
559                            orderByComparator);
560            }
561    
562            /**
563            * Returns the last system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
564            *
565            * @param groupId the group ID
566            * @param classNameId the class name ID
567            * @param classPK the class p k
568            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
569            * @return the last matching system event
570            * @throws NoSuchSystemEventException if a matching system event could not be found
571            */
572            public static SystemEvent findByG_C_C_Last(long groupId, long classNameId,
573                    long classPK, OrderByComparator<SystemEvent> orderByComparator)
574                    throws com.liferay.portal.exception.NoSuchSystemEventException {
575                    return getPersistence()
576                                       .findByG_C_C_Last(groupId, classNameId, classPK,
577                            orderByComparator);
578            }
579    
580            /**
581            * Returns the last system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
582            *
583            * @param groupId the group ID
584            * @param classNameId the class name ID
585            * @param classPK the class p k
586            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
587            * @return the last matching system event, or <code>null</code> if a matching system event could not be found
588            */
589            public static SystemEvent fetchByG_C_C_Last(long groupId, long classNameId,
590                    long classPK, OrderByComparator<SystemEvent> orderByComparator) {
591                    return getPersistence()
592                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
593                            orderByComparator);
594            }
595    
596            /**
597            * Returns the system events before and after the current system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
598            *
599            * @param systemEventId the primary key of the current system event
600            * @param groupId the group ID
601            * @param classNameId the class name ID
602            * @param classPK the class p k
603            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
604            * @return the previous, current, and next system event
605            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
606            */
607            public static SystemEvent[] findByG_C_C_PrevAndNext(long systemEventId,
608                    long groupId, long classNameId, long classPK,
609                    OrderByComparator<SystemEvent> orderByComparator)
610                    throws com.liferay.portal.exception.NoSuchSystemEventException {
611                    return getPersistence()
612                                       .findByG_C_C_PrevAndNext(systemEventId, groupId,
613                            classNameId, classPK, orderByComparator);
614            }
615    
616            /**
617            * Removes all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
618            *
619            * @param groupId the group ID
620            * @param classNameId the class name ID
621            * @param classPK the class p k
622            */
623            public static void removeByG_C_C(long groupId, long classNameId,
624                    long classPK) {
625                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
626            }
627    
628            /**
629            * Returns the number of system events where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
630            *
631            * @param groupId the group ID
632            * @param classNameId the class name ID
633            * @param classPK the class p k
634            * @return the number of matching system events
635            */
636            public static int countByG_C_C(long groupId, long classNameId, long classPK) {
637                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
638            }
639    
640            /**
641            * Returns all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
642            *
643            * @param groupId the group ID
644            * @param classNameId the class name ID
645            * @param classPK the class p k
646            * @param type the type
647            * @return the matching system events
648            */
649            public static List<SystemEvent> findByG_C_C_T(long groupId,
650                    long classNameId, long classPK, int type) {
651                    return getPersistence()
652                                       .findByG_C_C_T(groupId, classNameId, classPK, type);
653            }
654    
655            /**
656            * Returns a range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
657            *
658            * <p>
659            * 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 SystemEventModelImpl}. 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.
660            * </p>
661            *
662            * @param groupId the group ID
663            * @param classNameId the class name ID
664            * @param classPK the class p k
665            * @param type the type
666            * @param start the lower bound of the range of system events
667            * @param end the upper bound of the range of system events (not inclusive)
668            * @return the range of matching system events
669            */
670            public static List<SystemEvent> findByG_C_C_T(long groupId,
671                    long classNameId, long classPK, int type, int start, int end) {
672                    return getPersistence()
673                                       .findByG_C_C_T(groupId, classNameId, classPK, type, start,
674                            end);
675            }
676    
677            /**
678            * Returns an ordered range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
679            *
680            * <p>
681            * 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 SystemEventModelImpl}. 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.
682            * </p>
683            *
684            * @param groupId the group ID
685            * @param classNameId the class name ID
686            * @param classPK the class p k
687            * @param type the type
688            * @param start the lower bound of the range of system events
689            * @param end the upper bound of the range of system events (not inclusive)
690            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
691            * @return the ordered range of matching system events
692            */
693            public static List<SystemEvent> findByG_C_C_T(long groupId,
694                    long classNameId, long classPK, int type, int start, int end,
695                    OrderByComparator<SystemEvent> orderByComparator) {
696                    return getPersistence()
697                                       .findByG_C_C_T(groupId, classNameId, classPK, type, start,
698                            end, orderByComparator);
699            }
700    
701            /**
702            * Returns an ordered range of all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
703            *
704            * <p>
705            * 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 SystemEventModelImpl}. 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.
706            * </p>
707            *
708            * @param groupId the group ID
709            * @param classNameId the class name ID
710            * @param classPK the class p k
711            * @param type the type
712            * @param start the lower bound of the range of system events
713            * @param end the upper bound of the range of system events (not inclusive)
714            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
715            * @param retrieveFromCache whether to retrieve from the finder cache
716            * @return the ordered range of matching system events
717            */
718            public static List<SystemEvent> findByG_C_C_T(long groupId,
719                    long classNameId, long classPK, int type, int start, int end,
720                    OrderByComparator<SystemEvent> orderByComparator,
721                    boolean retrieveFromCache) {
722                    return getPersistence()
723                                       .findByG_C_C_T(groupId, classNameId, classPK, type, start,
724                            end, orderByComparator, retrieveFromCache);
725            }
726    
727            /**
728            * Returns the first system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
729            *
730            * @param groupId the group ID
731            * @param classNameId the class name ID
732            * @param classPK the class p k
733            * @param type the type
734            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
735            * @return the first matching system event
736            * @throws NoSuchSystemEventException if a matching system event could not be found
737            */
738            public static SystemEvent findByG_C_C_T_First(long groupId,
739                    long classNameId, long classPK, int type,
740                    OrderByComparator<SystemEvent> orderByComparator)
741                    throws com.liferay.portal.exception.NoSuchSystemEventException {
742                    return getPersistence()
743                                       .findByG_C_C_T_First(groupId, classNameId, classPK, type,
744                            orderByComparator);
745            }
746    
747            /**
748            * Returns the first system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
749            *
750            * @param groupId the group ID
751            * @param classNameId the class name ID
752            * @param classPK the class p k
753            * @param type the type
754            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
755            * @return the first matching system event, or <code>null</code> if a matching system event could not be found
756            */
757            public static SystemEvent fetchByG_C_C_T_First(long groupId,
758                    long classNameId, long classPK, int type,
759                    OrderByComparator<SystemEvent> orderByComparator) {
760                    return getPersistence()
761                                       .fetchByG_C_C_T_First(groupId, classNameId, classPK, type,
762                            orderByComparator);
763            }
764    
765            /**
766            * Returns the last system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
767            *
768            * @param groupId the group ID
769            * @param classNameId the class name ID
770            * @param classPK the class p k
771            * @param type the type
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the last matching system event
774            * @throws NoSuchSystemEventException if a matching system event could not be found
775            */
776            public static SystemEvent findByG_C_C_T_Last(long groupId,
777                    long classNameId, long classPK, int type,
778                    OrderByComparator<SystemEvent> orderByComparator)
779                    throws com.liferay.portal.exception.NoSuchSystemEventException {
780                    return getPersistence()
781                                       .findByG_C_C_T_Last(groupId, classNameId, classPK, type,
782                            orderByComparator);
783            }
784    
785            /**
786            * Returns the last system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
787            *
788            * @param groupId the group ID
789            * @param classNameId the class name ID
790            * @param classPK the class p k
791            * @param type the type
792            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
793            * @return the last matching system event, or <code>null</code> if a matching system event could not be found
794            */
795            public static SystemEvent fetchByG_C_C_T_Last(long groupId,
796                    long classNameId, long classPK, int type,
797                    OrderByComparator<SystemEvent> orderByComparator) {
798                    return getPersistence()
799                                       .fetchByG_C_C_T_Last(groupId, classNameId, classPK, type,
800                            orderByComparator);
801            }
802    
803            /**
804            * Returns the system events before and after the current system event in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
805            *
806            * @param systemEventId the primary key of the current system event
807            * @param groupId the group ID
808            * @param classNameId the class name ID
809            * @param classPK the class p k
810            * @param type the type
811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
812            * @return the previous, current, and next system event
813            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
814            */
815            public static SystemEvent[] findByG_C_C_T_PrevAndNext(long systemEventId,
816                    long groupId, long classNameId, long classPK, int type,
817                    OrderByComparator<SystemEvent> orderByComparator)
818                    throws com.liferay.portal.exception.NoSuchSystemEventException {
819                    return getPersistence()
820                                       .findByG_C_C_T_PrevAndNext(systemEventId, groupId,
821                            classNameId, classPK, type, orderByComparator);
822            }
823    
824            /**
825            * Removes all the system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; from the database.
826            *
827            * @param groupId the group ID
828            * @param classNameId the class name ID
829            * @param classPK the class p k
830            * @param type the type
831            */
832            public static void removeByG_C_C_T(long groupId, long classNameId,
833                    long classPK, int type) {
834                    getPersistence().removeByG_C_C_T(groupId, classNameId, classPK, type);
835            }
836    
837            /**
838            * Returns the number of system events where groupId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
839            *
840            * @param groupId the group ID
841            * @param classNameId the class name ID
842            * @param classPK the class p k
843            * @param type the type
844            * @return the number of matching system events
845            */
846            public static int countByG_C_C_T(long groupId, long classNameId,
847                    long classPK, int type) {
848                    return getPersistence()
849                                       .countByG_C_C_T(groupId, classNameId, classPK, type);
850            }
851    
852            /**
853            * Caches the system event in the entity cache if it is enabled.
854            *
855            * @param systemEvent the system event
856            */
857            public static void cacheResult(SystemEvent systemEvent) {
858                    getPersistence().cacheResult(systemEvent);
859            }
860    
861            /**
862            * Caches the system events in the entity cache if it is enabled.
863            *
864            * @param systemEvents the system events
865            */
866            public static void cacheResult(List<SystemEvent> systemEvents) {
867                    getPersistence().cacheResult(systemEvents);
868            }
869    
870            /**
871            * Creates a new system event with the primary key. Does not add the system event to the database.
872            *
873            * @param systemEventId the primary key for the new system event
874            * @return the new system event
875            */
876            public static SystemEvent create(long systemEventId) {
877                    return getPersistence().create(systemEventId);
878            }
879    
880            /**
881            * Removes the system event with the primary key from the database. Also notifies the appropriate model listeners.
882            *
883            * @param systemEventId the primary key of the system event
884            * @return the system event that was removed
885            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
886            */
887            public static SystemEvent remove(long systemEventId)
888                    throws com.liferay.portal.exception.NoSuchSystemEventException {
889                    return getPersistence().remove(systemEventId);
890            }
891    
892            public static SystemEvent updateImpl(SystemEvent systemEvent) {
893                    return getPersistence().updateImpl(systemEvent);
894            }
895    
896            /**
897            * Returns the system event with the primary key or throws a {@link NoSuchSystemEventException} if it could not be found.
898            *
899            * @param systemEventId the primary key of the system event
900            * @return the system event
901            * @throws NoSuchSystemEventException if a system event with the primary key could not be found
902            */
903            public static SystemEvent findByPrimaryKey(long systemEventId)
904                    throws com.liferay.portal.exception.NoSuchSystemEventException {
905                    return getPersistence().findByPrimaryKey(systemEventId);
906            }
907    
908            /**
909            * Returns the system event with the primary key or returns <code>null</code> if it could not be found.
910            *
911            * @param systemEventId the primary key of the system event
912            * @return the system event, or <code>null</code> if a system event with the primary key could not be found
913            */
914            public static SystemEvent fetchByPrimaryKey(long systemEventId) {
915                    return getPersistence().fetchByPrimaryKey(systemEventId);
916            }
917    
918            public static java.util.Map<java.io.Serializable, SystemEvent> fetchByPrimaryKeys(
919                    java.util.Set<java.io.Serializable> primaryKeys) {
920                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
921            }
922    
923            /**
924            * Returns all the system events.
925            *
926            * @return the system events
927            */
928            public static List<SystemEvent> findAll() {
929                    return getPersistence().findAll();
930            }
931    
932            /**
933            * Returns a range of all the system events.
934            *
935            * <p>
936            * 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 SystemEventModelImpl}. 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.
937            * </p>
938            *
939            * @param start the lower bound of the range of system events
940            * @param end the upper bound of the range of system events (not inclusive)
941            * @return the range of system events
942            */
943            public static List<SystemEvent> findAll(int start, int end) {
944                    return getPersistence().findAll(start, end);
945            }
946    
947            /**
948            * Returns an ordered range of all the system events.
949            *
950            * <p>
951            * 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 SystemEventModelImpl}. 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.
952            * </p>
953            *
954            * @param start the lower bound of the range of system events
955            * @param end the upper bound of the range of system events (not inclusive)
956            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
957            * @return the ordered range of system events
958            */
959            public static List<SystemEvent> findAll(int start, int end,
960                    OrderByComparator<SystemEvent> orderByComparator) {
961                    return getPersistence().findAll(start, end, orderByComparator);
962            }
963    
964            /**
965            * Returns an ordered range of all the system events.
966            *
967            * <p>
968            * 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 SystemEventModelImpl}. 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.
969            * </p>
970            *
971            * @param start the lower bound of the range of system events
972            * @param end the upper bound of the range of system events (not inclusive)
973            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
974            * @param retrieveFromCache whether to retrieve from the finder cache
975            * @return the ordered range of system events
976            */
977            public static List<SystemEvent> findAll(int start, int end,
978                    OrderByComparator<SystemEvent> orderByComparator,
979                    boolean retrieveFromCache) {
980                    return getPersistence()
981                                       .findAll(start, end, orderByComparator, retrieveFromCache);
982            }
983    
984            /**
985            * Removes all the system events from the database.
986            */
987            public static void removeAll() {
988                    getPersistence().removeAll();
989            }
990    
991            /**
992            * Returns the number of system events.
993            *
994            * @return the number of system events
995            */
996            public static int countAll() {
997                    return getPersistence().countAll();
998            }
999    
1000            public static java.util.Set<java.lang.String> getBadColumnNames() {
1001                    return getPersistence().getBadColumnNames();
1002            }
1003    
1004            public static SystemEventPersistence getPersistence() {
1005                    if (_persistence == null) {
1006                            _persistence = (SystemEventPersistence)PortalBeanLocatorUtil.locate(SystemEventPersistence.class.getName());
1007    
1008                            ReferenceRegistry.registerReference(SystemEventUtil.class,
1009                                    "_persistence");
1010                    }
1011    
1012                    return _persistence;
1013            }
1014    
1015            private static SystemEventPersistence _persistence;
1016    }