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.portlet.mobiledevicerules.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.service.ServiceContext;
024    
025    import com.liferay.portlet.mobiledevicerules.model.MDRRuleGroup;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the m d r rule group service. This utility wraps {@link com.liferay.portlet.mobiledevicerules.service.persistence.impl.MDRRuleGroupPersistenceImpl} 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Edward C. Han
037     * @see MDRRuleGroupPersistence
038     * @see com.liferay.portlet.mobiledevicerules.service.persistence.impl.MDRRuleGroupPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class MDRRuleGroupUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(MDRRuleGroup mdrRuleGroup) {
060                    getPersistence().clearCache(mdrRuleGroup);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<MDRRuleGroup> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<MDRRuleGroup> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<MDRRuleGroup> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<MDRRuleGroup> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static MDRRuleGroup update(MDRRuleGroup mdrRuleGroup) {
101                    return getPersistence().update(mdrRuleGroup);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static MDRRuleGroup update(MDRRuleGroup mdrRuleGroup,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(mdrRuleGroup, serviceContext);
110            }
111    
112            /**
113            * Returns all the m d r rule groups where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching m d r rule groups
117            */
118            public static List<MDRRuleGroup> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the m d r rule groups where uuid = &#63;.
124            *
125            * <p>
126            * 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 MDRRuleGroupModelImpl}. 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of m d r rule groups
131            * @param end the upper bound of the range of m d r rule groups (not inclusive)
132            * @return the range of matching m d r rule groups
133            */
134            public static List<MDRRuleGroup> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the m d r rule groups where uuid = &#63;.
141            *
142            * <p>
143            * 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 MDRRuleGroupModelImpl}. 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of m d r rule groups
148            * @param end the upper bound of the range of m d r rule groups (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching m d r rule groups
151            */
152            public static List<MDRRuleGroup> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first m d r rule group in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching m d r rule group
163            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
164            */
165            public static MDRRuleGroup findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<MDRRuleGroup> orderByComparator)
167                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first m d r rule group in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
177            */
178            public static MDRRuleGroup fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<MDRRuleGroup> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last m d r rule group in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching m d r rule group
189            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
190            */
191            public static MDRRuleGroup findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<MDRRuleGroup> orderByComparator)
193                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last m d r rule group in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
203            */
204            public static MDRRuleGroup fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<MDRRuleGroup> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where uuid = &#63;.
211            *
212            * @param ruleGroupId the primary key of the current m d r rule group
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next m d r rule group
216            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
217            */
218            public static MDRRuleGroup[] findByUuid_PrevAndNext(long ruleGroupId,
219                    java.lang.String uuid, OrderByComparator<MDRRuleGroup> orderByComparator)
220                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
221                    return getPersistence()
222                                       .findByUuid_PrevAndNext(ruleGroupId, uuid, orderByComparator);
223            }
224    
225            /**
226            * Removes all the m d r rule groups where uuid = &#63; from the database.
227            *
228            * @param uuid the uuid
229            */
230            public static void removeByUuid(java.lang.String uuid) {
231                    getPersistence().removeByUuid(uuid);
232            }
233    
234            /**
235            * Returns the number of m d r rule groups where uuid = &#63;.
236            *
237            * @param uuid the uuid
238            * @return the number of matching m d r rule groups
239            */
240            public static int countByUuid(java.lang.String uuid) {
241                    return getPersistence().countByUuid(uuid);
242            }
243    
244            /**
245            * Returns the m d r rule group where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchRuleGroupException} if it could not be found.
246            *
247            * @param uuid the uuid
248            * @param groupId the group ID
249            * @return the matching m d r rule group
250            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
251            */
252            public static MDRRuleGroup findByUUID_G(java.lang.String uuid, long groupId)
253                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
254                    return getPersistence().findByUUID_G(uuid, groupId);
255            }
256    
257            /**
258            * Returns the m d r rule group where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
259            *
260            * @param uuid the uuid
261            * @param groupId the group ID
262            * @return the matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
263            */
264            public static MDRRuleGroup fetchByUUID_G(java.lang.String uuid, long groupId) {
265                    return getPersistence().fetchByUUID_G(uuid, groupId);
266            }
267    
268            /**
269            * Returns the m d r rule group where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @param retrieveFromCache whether to use the finder cache
274            * @return the matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
275            */
276            public static MDRRuleGroup fetchByUUID_G(java.lang.String uuid,
277                    long groupId, boolean retrieveFromCache) {
278                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
279            }
280    
281            /**
282            * Removes the m d r rule group where uuid = &#63; and groupId = &#63; from the database.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the m d r rule group that was removed
287            */
288            public static MDRRuleGroup removeByUUID_G(java.lang.String uuid,
289                    long groupId)
290                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
291                    return getPersistence().removeByUUID_G(uuid, groupId);
292            }
293    
294            /**
295            * Returns the number of m d r rule groups where uuid = &#63; and groupId = &#63;.
296            *
297            * @param uuid the uuid
298            * @param groupId the group ID
299            * @return the number of matching m d r rule groups
300            */
301            public static int countByUUID_G(java.lang.String uuid, long groupId) {
302                    return getPersistence().countByUUID_G(uuid, groupId);
303            }
304    
305            /**
306            * Returns all the m d r rule groups where uuid = &#63; and companyId = &#63;.
307            *
308            * @param uuid the uuid
309            * @param companyId the company ID
310            * @return the matching m d r rule groups
311            */
312            public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid,
313                    long companyId) {
314                    return getPersistence().findByUuid_C(uuid, companyId);
315            }
316    
317            /**
318            * Returns a range of all the m d r rule groups where uuid = &#63; and companyId = &#63;.
319            *
320            * <p>
321            * 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 MDRRuleGroupModelImpl}. 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.
322            * </p>
323            *
324            * @param uuid the uuid
325            * @param companyId the company ID
326            * @param start the lower bound of the range of m d r rule groups
327            * @param end the upper bound of the range of m d r rule groups (not inclusive)
328            * @return the range of matching m d r rule groups
329            */
330            public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid,
331                    long companyId, int start, int end) {
332                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
333            }
334    
335            /**
336            * Returns an ordered range of all the m d r rule groups where uuid = &#63; and companyId = &#63;.
337            *
338            * <p>
339            * 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 MDRRuleGroupModelImpl}. 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.
340            * </p>
341            *
342            * @param uuid the uuid
343            * @param companyId the company ID
344            * @param start the lower bound of the range of m d r rule groups
345            * @param end the upper bound of the range of m d r rule groups (not inclusive)
346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
347            * @return the ordered range of matching m d r rule groups
348            */
349            public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid,
350                    long companyId, int start, int end,
351                    OrderByComparator<MDRRuleGroup> orderByComparator) {
352                    return getPersistence()
353                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
354            }
355    
356            /**
357            * Returns the first m d r rule group in the ordered set where uuid = &#63; and companyId = &#63;.
358            *
359            * @param uuid the uuid
360            * @param companyId the company ID
361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
362            * @return the first matching m d r rule group
363            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
364            */
365            public static MDRRuleGroup findByUuid_C_First(java.lang.String uuid,
366                    long companyId, OrderByComparator<MDRRuleGroup> orderByComparator)
367                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
368                    return getPersistence()
369                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
370            }
371    
372            /**
373            * Returns the first m d r rule group in the ordered set where uuid = &#63; and companyId = &#63;.
374            *
375            * @param uuid the uuid
376            * @param companyId the company ID
377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
378            * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
379            */
380            public static MDRRuleGroup fetchByUuid_C_First(java.lang.String uuid,
381                    long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) {
382                    return getPersistence()
383                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
384            }
385    
386            /**
387            * Returns the last m d r rule group in the ordered set where uuid = &#63; and companyId = &#63;.
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the last matching m d r rule group
393            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
394            */
395            public static MDRRuleGroup findByUuid_C_Last(java.lang.String uuid,
396                    long companyId, OrderByComparator<MDRRuleGroup> orderByComparator)
397                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
398                    return getPersistence()
399                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
400            }
401    
402            /**
403            * Returns the last m d r rule group in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
409            */
410            public static MDRRuleGroup fetchByUuid_C_Last(java.lang.String uuid,
411                    long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) {
412                    return getPersistence()
413                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
414            }
415    
416            /**
417            * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where uuid = &#63; and companyId = &#63;.
418            *
419            * @param ruleGroupId the primary key of the current m d r rule group
420            * @param uuid the uuid
421            * @param companyId the company ID
422            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
423            * @return the previous, current, and next m d r rule group
424            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
425            */
426            public static MDRRuleGroup[] findByUuid_C_PrevAndNext(long ruleGroupId,
427                    java.lang.String uuid, long companyId,
428                    OrderByComparator<MDRRuleGroup> orderByComparator)
429                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
430                    return getPersistence()
431                                       .findByUuid_C_PrevAndNext(ruleGroupId, uuid, companyId,
432                            orderByComparator);
433            }
434    
435            /**
436            * Removes all the m d r rule groups where uuid = &#63; and companyId = &#63; from the database.
437            *
438            * @param uuid the uuid
439            * @param companyId the company ID
440            */
441            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
442                    getPersistence().removeByUuid_C(uuid, companyId);
443            }
444    
445            /**
446            * Returns the number of m d r rule groups where uuid = &#63; and companyId = &#63;.
447            *
448            * @param uuid the uuid
449            * @param companyId the company ID
450            * @return the number of matching m d r rule groups
451            */
452            public static int countByUuid_C(java.lang.String uuid, long companyId) {
453                    return getPersistence().countByUuid_C(uuid, companyId);
454            }
455    
456            /**
457            * Returns all the m d r rule groups where groupId = &#63;.
458            *
459            * @param groupId the group ID
460            * @return the matching m d r rule groups
461            */
462            public static List<MDRRuleGroup> findByGroupId(long groupId) {
463                    return getPersistence().findByGroupId(groupId);
464            }
465    
466            /**
467            * Returns a range of all the m d r rule groups where groupId = &#63;.
468            *
469            * <p>
470            * 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 MDRRuleGroupModelImpl}. 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.
471            * </p>
472            *
473            * @param groupId the group ID
474            * @param start the lower bound of the range of m d r rule groups
475            * @param end the upper bound of the range of m d r rule groups (not inclusive)
476            * @return the range of matching m d r rule groups
477            */
478            public static List<MDRRuleGroup> findByGroupId(long groupId, int start,
479                    int end) {
480                    return getPersistence().findByGroupId(groupId, start, end);
481            }
482    
483            /**
484            * Returns an ordered range of all the m d r rule groups where groupId = &#63;.
485            *
486            * <p>
487            * 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 MDRRuleGroupModelImpl}. 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.
488            * </p>
489            *
490            * @param groupId the group ID
491            * @param start the lower bound of the range of m d r rule groups
492            * @param end the upper bound of the range of m d r rule groups (not inclusive)
493            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
494            * @return the ordered range of matching m d r rule groups
495            */
496            public static List<MDRRuleGroup> findByGroupId(long groupId, int start,
497                    int end, OrderByComparator<MDRRuleGroup> orderByComparator) {
498                    return getPersistence()
499                                       .findByGroupId(groupId, start, end, orderByComparator);
500            }
501    
502            /**
503            * Returns the first m d r rule group in the ordered set where groupId = &#63;.
504            *
505            * @param groupId the group ID
506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
507            * @return the first matching m d r rule group
508            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
509            */
510            public static MDRRuleGroup findByGroupId_First(long groupId,
511                    OrderByComparator<MDRRuleGroup> orderByComparator)
512                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
513                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
514            }
515    
516            /**
517            * Returns the first m d r rule group in the ordered set where groupId = &#63;.
518            *
519            * @param groupId the group ID
520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
521            * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
522            */
523            public static MDRRuleGroup fetchByGroupId_First(long groupId,
524                    OrderByComparator<MDRRuleGroup> orderByComparator) {
525                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
526            }
527    
528            /**
529            * Returns the last m d r rule group in the ordered set where groupId = &#63;.
530            *
531            * @param groupId the group ID
532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
533            * @return the last matching m d r rule group
534            * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found
535            */
536            public static MDRRuleGroup findByGroupId_Last(long groupId,
537                    OrderByComparator<MDRRuleGroup> orderByComparator)
538                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
539                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
540            }
541    
542            /**
543            * Returns the last m d r rule group in the ordered set where groupId = &#63;.
544            *
545            * @param groupId the group ID
546            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
547            * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found
548            */
549            public static MDRRuleGroup fetchByGroupId_Last(long groupId,
550                    OrderByComparator<MDRRuleGroup> orderByComparator) {
551                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
552            }
553    
554            /**
555            * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where groupId = &#63;.
556            *
557            * @param ruleGroupId the primary key of the current m d r rule group
558            * @param groupId the group ID
559            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
560            * @return the previous, current, and next m d r rule group
561            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
562            */
563            public static MDRRuleGroup[] findByGroupId_PrevAndNext(long ruleGroupId,
564                    long groupId, OrderByComparator<MDRRuleGroup> orderByComparator)
565                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
566                    return getPersistence()
567                                       .findByGroupId_PrevAndNext(ruleGroupId, groupId,
568                            orderByComparator);
569            }
570    
571            /**
572            * Returns all the m d r rule groups that the user has permission to view where groupId = &#63;.
573            *
574            * @param groupId the group ID
575            * @return the matching m d r rule groups that the user has permission to view
576            */
577            public static List<MDRRuleGroup> filterFindByGroupId(long groupId) {
578                    return getPersistence().filterFindByGroupId(groupId);
579            }
580    
581            /**
582            * Returns a range of all the m d r rule groups that the user has permission to view where groupId = &#63;.
583            *
584            * <p>
585            * 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 MDRRuleGroupModelImpl}. 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.
586            * </p>
587            *
588            * @param groupId the group ID
589            * @param start the lower bound of the range of m d r rule groups
590            * @param end the upper bound of the range of m d r rule groups (not inclusive)
591            * @return the range of matching m d r rule groups that the user has permission to view
592            */
593            public static List<MDRRuleGroup> filterFindByGroupId(long groupId,
594                    int start, int end) {
595                    return getPersistence().filterFindByGroupId(groupId, start, end);
596            }
597    
598            /**
599            * Returns an ordered range of all the m d r rule groups that the user has permissions to view where groupId = &#63;.
600            *
601            * <p>
602            * 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 MDRRuleGroupModelImpl}. 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.
603            * </p>
604            *
605            * @param groupId the group ID
606            * @param start the lower bound of the range of m d r rule groups
607            * @param end the upper bound of the range of m d r rule groups (not inclusive)
608            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
609            * @return the ordered range of matching m d r rule groups that the user has permission to view
610            */
611            public static List<MDRRuleGroup> filterFindByGroupId(long groupId,
612                    int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) {
613                    return getPersistence()
614                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
615            }
616    
617            /**
618            * Returns the m d r rule groups before and after the current m d r rule group in the ordered set of m d r rule groups that the user has permission to view where groupId = &#63;.
619            *
620            * @param ruleGroupId the primary key of the current m d r rule group
621            * @param groupId the group ID
622            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
623            * @return the previous, current, and next m d r rule group
624            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
625            */
626            public static MDRRuleGroup[] filterFindByGroupId_PrevAndNext(
627                    long ruleGroupId, long groupId,
628                    OrderByComparator<MDRRuleGroup> orderByComparator)
629                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
630                    return getPersistence()
631                                       .filterFindByGroupId_PrevAndNext(ruleGroupId, groupId,
632                            orderByComparator);
633            }
634    
635            /**
636            * Returns all the m d r rule groups that the user has permission to view where groupId = any &#63;.
637            *
638            * @param groupIds the group IDs
639            * @return the matching m d r rule groups that the user has permission to view
640            */
641            public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds) {
642                    return getPersistence().filterFindByGroupId(groupIds);
643            }
644    
645            /**
646            * Returns a range of all the m d r rule groups that the user has permission to view where groupId = any &#63;.
647            *
648            * <p>
649            * 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 MDRRuleGroupModelImpl}. 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.
650            * </p>
651            *
652            * @param groupIds the group IDs
653            * @param start the lower bound of the range of m d r rule groups
654            * @param end the upper bound of the range of m d r rule groups (not inclusive)
655            * @return the range of matching m d r rule groups that the user has permission to view
656            */
657            public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds,
658                    int start, int end) {
659                    return getPersistence().filterFindByGroupId(groupIds, start, end);
660            }
661    
662            /**
663            * Returns an ordered range of all the m d r rule groups that the user has permission to view where groupId = any &#63;.
664            *
665            * <p>
666            * 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 MDRRuleGroupModelImpl}. 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.
667            * </p>
668            *
669            * @param groupIds the group IDs
670            * @param start the lower bound of the range of m d r rule groups
671            * @param end the upper bound of the range of m d r rule groups (not inclusive)
672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
673            * @return the ordered range of matching m d r rule groups that the user has permission to view
674            */
675            public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds,
676                    int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) {
677                    return getPersistence()
678                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
679            }
680    
681            /**
682            * Returns all the m d r rule groups where groupId = any &#63;.
683            *
684            * <p>
685            * 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 MDRRuleGroupModelImpl}. 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.
686            * </p>
687            *
688            * @param groupIds the group IDs
689            * @return the matching m d r rule groups
690            */
691            public static List<MDRRuleGroup> findByGroupId(long[] groupIds) {
692                    return getPersistence().findByGroupId(groupIds);
693            }
694    
695            /**
696            * Returns a range of all the m d r rule groups where groupId = any &#63;.
697            *
698            * <p>
699            * 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 MDRRuleGroupModelImpl}. 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.
700            * </p>
701            *
702            * @param groupIds the group IDs
703            * @param start the lower bound of the range of m d r rule groups
704            * @param end the upper bound of the range of m d r rule groups (not inclusive)
705            * @return the range of matching m d r rule groups
706            */
707            public static List<MDRRuleGroup> findByGroupId(long[] groupIds, int start,
708                    int end) {
709                    return getPersistence().findByGroupId(groupIds, start, end);
710            }
711    
712            /**
713            * Returns an ordered range of all the m d r rule groups where groupId = any &#63;.
714            *
715            * <p>
716            * 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 MDRRuleGroupModelImpl}. 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.
717            * </p>
718            *
719            * @param groupIds the group IDs
720            * @param start the lower bound of the range of m d r rule groups
721            * @param end the upper bound of the range of m d r rule groups (not inclusive)
722            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
723            * @return the ordered range of matching m d r rule groups
724            */
725            public static List<MDRRuleGroup> findByGroupId(long[] groupIds, int start,
726                    int end, OrderByComparator<MDRRuleGroup> orderByComparator) {
727                    return getPersistence()
728                                       .findByGroupId(groupIds, start, end, orderByComparator);
729            }
730    
731            /**
732            * Removes all the m d r rule groups where groupId = &#63; from the database.
733            *
734            * @param groupId the group ID
735            */
736            public static void removeByGroupId(long groupId) {
737                    getPersistence().removeByGroupId(groupId);
738            }
739    
740            /**
741            * Returns the number of m d r rule groups where groupId = &#63;.
742            *
743            * @param groupId the group ID
744            * @return the number of matching m d r rule groups
745            */
746            public static int countByGroupId(long groupId) {
747                    return getPersistence().countByGroupId(groupId);
748            }
749    
750            /**
751            * Returns the number of m d r rule groups where groupId = any &#63;.
752            *
753            * @param groupIds the group IDs
754            * @return the number of matching m d r rule groups
755            */
756            public static int countByGroupId(long[] groupIds) {
757                    return getPersistence().countByGroupId(groupIds);
758            }
759    
760            /**
761            * Returns the number of m d r rule groups that the user has permission to view where groupId = &#63;.
762            *
763            * @param groupId the group ID
764            * @return the number of matching m d r rule groups that the user has permission to view
765            */
766            public static int filterCountByGroupId(long groupId) {
767                    return getPersistence().filterCountByGroupId(groupId);
768            }
769    
770            /**
771            * Returns the number of m d r rule groups that the user has permission to view where groupId = any &#63;.
772            *
773            * @param groupIds the group IDs
774            * @return the number of matching m d r rule groups that the user has permission to view
775            */
776            public static int filterCountByGroupId(long[] groupIds) {
777                    return getPersistence().filterCountByGroupId(groupIds);
778            }
779    
780            /**
781            * Caches the m d r rule group in the entity cache if it is enabled.
782            *
783            * @param mdrRuleGroup the m d r rule group
784            */
785            public static void cacheResult(MDRRuleGroup mdrRuleGroup) {
786                    getPersistence().cacheResult(mdrRuleGroup);
787            }
788    
789            /**
790            * Caches the m d r rule groups in the entity cache if it is enabled.
791            *
792            * @param mdrRuleGroups the m d r rule groups
793            */
794            public static void cacheResult(List<MDRRuleGroup> mdrRuleGroups) {
795                    getPersistence().cacheResult(mdrRuleGroups);
796            }
797    
798            /**
799            * Creates a new m d r rule group with the primary key. Does not add the m d r rule group to the database.
800            *
801            * @param ruleGroupId the primary key for the new m d r rule group
802            * @return the new m d r rule group
803            */
804            public static MDRRuleGroup create(long ruleGroupId) {
805                    return getPersistence().create(ruleGroupId);
806            }
807    
808            /**
809            * Removes the m d r rule group with the primary key from the database. Also notifies the appropriate model listeners.
810            *
811            * @param ruleGroupId the primary key of the m d r rule group
812            * @return the m d r rule group that was removed
813            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
814            */
815            public static MDRRuleGroup remove(long ruleGroupId)
816                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
817                    return getPersistence().remove(ruleGroupId);
818            }
819    
820            public static MDRRuleGroup updateImpl(MDRRuleGroup mdrRuleGroup) {
821                    return getPersistence().updateImpl(mdrRuleGroup);
822            }
823    
824            /**
825            * Returns the m d r rule group with the primary key or throws a {@link NoSuchRuleGroupException} if it could not be found.
826            *
827            * @param ruleGroupId the primary key of the m d r rule group
828            * @return the m d r rule group
829            * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found
830            */
831            public static MDRRuleGroup findByPrimaryKey(long ruleGroupId)
832                    throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException {
833                    return getPersistence().findByPrimaryKey(ruleGroupId);
834            }
835    
836            /**
837            * Returns the m d r rule group with the primary key or returns <code>null</code> if it could not be found.
838            *
839            * @param ruleGroupId the primary key of the m d r rule group
840            * @return the m d r rule group, or <code>null</code> if a m d r rule group with the primary key could not be found
841            */
842            public static MDRRuleGroup fetchByPrimaryKey(long ruleGroupId) {
843                    return getPersistence().fetchByPrimaryKey(ruleGroupId);
844            }
845    
846            public static java.util.Map<java.io.Serializable, MDRRuleGroup> fetchByPrimaryKeys(
847                    java.util.Set<java.io.Serializable> primaryKeys) {
848                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
849            }
850    
851            /**
852            * Returns all the m d r rule groups.
853            *
854            * @return the m d r rule groups
855            */
856            public static List<MDRRuleGroup> findAll() {
857                    return getPersistence().findAll();
858            }
859    
860            /**
861            * Returns a range of all the m d r rule groups.
862            *
863            * <p>
864            * 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 MDRRuleGroupModelImpl}. 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.
865            * </p>
866            *
867            * @param start the lower bound of the range of m d r rule groups
868            * @param end the upper bound of the range of m d r rule groups (not inclusive)
869            * @return the range of m d r rule groups
870            */
871            public static List<MDRRuleGroup> findAll(int start, int end) {
872                    return getPersistence().findAll(start, end);
873            }
874    
875            /**
876            * Returns an ordered range of all the m d r rule groups.
877            *
878            * <p>
879            * 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 MDRRuleGroupModelImpl}. 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.
880            * </p>
881            *
882            * @param start the lower bound of the range of m d r rule groups
883            * @param end the upper bound of the range of m d r rule groups (not inclusive)
884            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
885            * @return the ordered range of m d r rule groups
886            */
887            public static List<MDRRuleGroup> findAll(int start, int end,
888                    OrderByComparator<MDRRuleGroup> orderByComparator) {
889                    return getPersistence().findAll(start, end, orderByComparator);
890            }
891    
892            /**
893            * Removes all the m d r rule groups from the database.
894            */
895            public static void removeAll() {
896                    getPersistence().removeAll();
897            }
898    
899            /**
900            * Returns the number of m d r rule groups.
901            *
902            * @return the number of m d r rule groups
903            */
904            public static int countAll() {
905                    return getPersistence().countAll();
906            }
907    
908            public static MDRRuleGroupPersistence getPersistence() {
909                    if (_persistence == null) {
910                            _persistence = (MDRRuleGroupPersistence)PortalBeanLocatorUtil.locate(MDRRuleGroupPersistence.class.getName());
911    
912                            ReferenceRegistry.registerReference(MDRRuleGroupUtil.class,
913                                    "_persistence");
914                    }
915    
916                    return _persistence;
917            }
918    
919            /**
920             * @deprecated As of 6.2.0
921             */
922            @Deprecated
923            public void setPersistence(MDRRuleGroupPersistence persistence) {
924            }
925    
926            private static MDRRuleGroupPersistence _persistence;
927    }