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.Group;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the group service. This utility wraps {@link com.liferay.portal.service.persistence.impl.GroupPersistenceImpl} 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 GroupPersistence
037     * @see com.liferay.portal.service.persistence.impl.GroupPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class GroupUtil {
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(Group group) {
059                    getPersistence().clearCache(group);
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<Group> findWithDynamicQuery(DynamicQuery dynamicQuery) {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery,
080                    int start, int end) {
081                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
082            }
083    
084            /**
085             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
086             */
087            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery,
088                    int start, int end, OrderByComparator<Group> orderByComparator) {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
096             */
097            public static Group update(Group group) {
098                    return getPersistence().update(group);
099            }
100    
101            /**
102             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
103             */
104            public static Group update(Group group, ServiceContext serviceContext) {
105                    return getPersistence().update(group, serviceContext);
106            }
107    
108            /**
109            * Returns all the groups where uuid = &#63;.
110            *
111            * @param uuid the uuid
112            * @return the matching groups
113            */
114            public static List<Group> findByUuid(java.lang.String uuid) {
115                    return getPersistence().findByUuid(uuid);
116            }
117    
118            /**
119            * Returns a range of all the groups where uuid = &#63;.
120            *
121            * <p>
122            * 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 GroupModelImpl}. 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.
123            * </p>
124            *
125            * @param uuid the uuid
126            * @param start the lower bound of the range of groups
127            * @param end the upper bound of the range of groups (not inclusive)
128            * @return the range of matching groups
129            */
130            public static List<Group> findByUuid(java.lang.String uuid, int start,
131                    int end) {
132                    return getPersistence().findByUuid(uuid, start, end);
133            }
134    
135            /**
136            * Returns an ordered range of all the groups where uuid = &#63;.
137            *
138            * <p>
139            * 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 GroupModelImpl}. 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.
140            * </p>
141            *
142            * @param uuid the uuid
143            * @param start the lower bound of the range of groups
144            * @param end the upper bound of the range of groups (not inclusive)
145            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
146            * @return the ordered range of matching groups
147            */
148            public static List<Group> findByUuid(java.lang.String uuid, int start,
149                    int end, OrderByComparator<Group> orderByComparator) {
150                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
151            }
152    
153            /**
154            * Returns the first group in the ordered set where uuid = &#63;.
155            *
156            * @param uuid the uuid
157            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
158            * @return the first matching group
159            * @throws NoSuchGroupException if a matching group could not be found
160            */
161            public static Group findByUuid_First(java.lang.String uuid,
162                    OrderByComparator<Group> orderByComparator)
163                    throws com.liferay.portal.NoSuchGroupException {
164                    return getPersistence().findByUuid_First(uuid, orderByComparator);
165            }
166    
167            /**
168            * Returns the first group in the ordered set where uuid = &#63;.
169            *
170            * @param uuid the uuid
171            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
172            * @return the first matching group, or <code>null</code> if a matching group could not be found
173            */
174            public static Group fetchByUuid_First(java.lang.String uuid,
175                    OrderByComparator<Group> orderByComparator) {
176                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
177            }
178    
179            /**
180            * Returns the last group in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the last matching group
185            * @throws NoSuchGroupException if a matching group could not be found
186            */
187            public static Group findByUuid_Last(java.lang.String uuid,
188                    OrderByComparator<Group> orderByComparator)
189                    throws com.liferay.portal.NoSuchGroupException {
190                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the last group in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the last matching group, or <code>null</code> if a matching group could not be found
199            */
200            public static Group fetchByUuid_Last(java.lang.String uuid,
201                    OrderByComparator<Group> orderByComparator) {
202                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the groups before and after the current group in the ordered set where uuid = &#63;.
207            *
208            * @param groupId the primary key of the current group
209            * @param uuid the uuid
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the previous, current, and next group
212            * @throws NoSuchGroupException if a group with the primary key could not be found
213            */
214            public static Group[] findByUuid_PrevAndNext(long groupId,
215                    java.lang.String uuid, OrderByComparator<Group> orderByComparator)
216                    throws com.liferay.portal.NoSuchGroupException {
217                    return getPersistence()
218                                       .findByUuid_PrevAndNext(groupId, uuid, orderByComparator);
219            }
220    
221            /**
222            * Removes all the groups where uuid = &#63; from the database.
223            *
224            * @param uuid the uuid
225            */
226            public static void removeByUuid(java.lang.String uuid) {
227                    getPersistence().removeByUuid(uuid);
228            }
229    
230            /**
231            * Returns the number of groups where uuid = &#63;.
232            *
233            * @param uuid the uuid
234            * @return the number of matching groups
235            */
236            public static int countByUuid(java.lang.String uuid) {
237                    return getPersistence().countByUuid(uuid);
238            }
239    
240            /**
241            * Returns the group where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
242            *
243            * @param uuid the uuid
244            * @param groupId the group ID
245            * @return the matching group
246            * @throws NoSuchGroupException if a matching group could not be found
247            */
248            public static Group findByUUID_G(java.lang.String uuid, long groupId)
249                    throws com.liferay.portal.NoSuchGroupException {
250                    return getPersistence().findByUUID_G(uuid, groupId);
251            }
252    
253            /**
254            * Returns the group where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
255            *
256            * @param uuid the uuid
257            * @param groupId the group ID
258            * @return the matching group, or <code>null</code> if a matching group could not be found
259            */
260            public static Group fetchByUUID_G(java.lang.String uuid, long groupId) {
261                    return getPersistence().fetchByUUID_G(uuid, groupId);
262            }
263    
264            /**
265            * Returns the group where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
266            *
267            * @param uuid the uuid
268            * @param groupId the group ID
269            * @param retrieveFromCache whether to use the finder cache
270            * @return the matching group, or <code>null</code> if a matching group could not be found
271            */
272            public static Group fetchByUUID_G(java.lang.String uuid, long groupId,
273                    boolean retrieveFromCache) {
274                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
275            }
276    
277            /**
278            * Removes the group where uuid = &#63; and groupId = &#63; from the database.
279            *
280            * @param uuid the uuid
281            * @param groupId the group ID
282            * @return the group that was removed
283            */
284            public static Group removeByUUID_G(java.lang.String uuid, long groupId)
285                    throws com.liferay.portal.NoSuchGroupException {
286                    return getPersistence().removeByUUID_G(uuid, groupId);
287            }
288    
289            /**
290            * Returns the number of groups where uuid = &#63; and groupId = &#63;.
291            *
292            * @param uuid the uuid
293            * @param groupId the group ID
294            * @return the number of matching groups
295            */
296            public static int countByUUID_G(java.lang.String uuid, long groupId) {
297                    return getPersistence().countByUUID_G(uuid, groupId);
298            }
299    
300            /**
301            * Returns all the groups where uuid = &#63; and companyId = &#63;.
302            *
303            * @param uuid the uuid
304            * @param companyId the company ID
305            * @return the matching groups
306            */
307            public static List<Group> findByUuid_C(java.lang.String uuid, long companyId) {
308                    return getPersistence().findByUuid_C(uuid, companyId);
309            }
310    
311            /**
312            * Returns a range of all the groups where uuid = &#63; and companyId = &#63;.
313            *
314            * <p>
315            * 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 GroupModelImpl}. 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.
316            * </p>
317            *
318            * @param uuid the uuid
319            * @param companyId the company ID
320            * @param start the lower bound of the range of groups
321            * @param end the upper bound of the range of groups (not inclusive)
322            * @return the range of matching groups
323            */
324            public static List<Group> findByUuid_C(java.lang.String uuid,
325                    long companyId, int start, int end) {
326                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
327            }
328    
329            /**
330            * Returns an ordered range of all the groups where uuid = &#63; and companyId = &#63;.
331            *
332            * <p>
333            * 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 GroupModelImpl}. 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.
334            * </p>
335            *
336            * @param uuid the uuid
337            * @param companyId the company ID
338            * @param start the lower bound of the range of groups
339            * @param end the upper bound of the range of groups (not inclusive)
340            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
341            * @return the ordered range of matching groups
342            */
343            public static List<Group> findByUuid_C(java.lang.String uuid,
344                    long companyId, int start, int end,
345                    OrderByComparator<Group> orderByComparator) {
346                    return getPersistence()
347                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
348            }
349    
350            /**
351            * Returns the first group in the ordered set where uuid = &#63; and companyId = &#63;.
352            *
353            * @param uuid the uuid
354            * @param companyId the company ID
355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
356            * @return the first matching group
357            * @throws NoSuchGroupException if a matching group could not be found
358            */
359            public static Group findByUuid_C_First(java.lang.String uuid,
360                    long companyId, OrderByComparator<Group> orderByComparator)
361                    throws com.liferay.portal.NoSuchGroupException {
362                    return getPersistence()
363                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
364            }
365    
366            /**
367            * Returns the first group in the ordered set where uuid = &#63; and companyId = &#63;.
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
372            * @return the first matching group, or <code>null</code> if a matching group could not be found
373            */
374            public static Group fetchByUuid_C_First(java.lang.String uuid,
375                    long companyId, OrderByComparator<Group> orderByComparator) {
376                    return getPersistence()
377                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
378            }
379    
380            /**
381            * Returns the last group in the ordered set where uuid = &#63; and companyId = &#63;.
382            *
383            * @param uuid the uuid
384            * @param companyId the company ID
385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
386            * @return the last matching group
387            * @throws NoSuchGroupException if a matching group could not be found
388            */
389            public static Group findByUuid_C_Last(java.lang.String uuid,
390                    long companyId, OrderByComparator<Group> orderByComparator)
391                    throws com.liferay.portal.NoSuchGroupException {
392                    return getPersistence()
393                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
394            }
395    
396            /**
397            * Returns the last group in the ordered set where uuid = &#63; and companyId = &#63;.
398            *
399            * @param uuid the uuid
400            * @param companyId the company ID
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the last matching group, or <code>null</code> if a matching group could not be found
403            */
404            public static Group fetchByUuid_C_Last(java.lang.String uuid,
405                    long companyId, OrderByComparator<Group> orderByComparator) {
406                    return getPersistence()
407                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
408            }
409    
410            /**
411            * Returns the groups before and after the current group in the ordered set where uuid = &#63; and companyId = &#63;.
412            *
413            * @param groupId the primary key of the current group
414            * @param uuid the uuid
415            * @param companyId the company ID
416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
417            * @return the previous, current, and next group
418            * @throws NoSuchGroupException if a group with the primary key could not be found
419            */
420            public static Group[] findByUuid_C_PrevAndNext(long groupId,
421                    java.lang.String uuid, long companyId,
422                    OrderByComparator<Group> orderByComparator)
423                    throws com.liferay.portal.NoSuchGroupException {
424                    return getPersistence()
425                                       .findByUuid_C_PrevAndNext(groupId, uuid, companyId,
426                            orderByComparator);
427            }
428    
429            /**
430            * Removes all the groups where uuid = &#63; and companyId = &#63; from the database.
431            *
432            * @param uuid the uuid
433            * @param companyId the company ID
434            */
435            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
436                    getPersistence().removeByUuid_C(uuid, companyId);
437            }
438    
439            /**
440            * Returns the number of groups where uuid = &#63; and companyId = &#63;.
441            *
442            * @param uuid the uuid
443            * @param companyId the company ID
444            * @return the number of matching groups
445            */
446            public static int countByUuid_C(java.lang.String uuid, long companyId) {
447                    return getPersistence().countByUuid_C(uuid, companyId);
448            }
449    
450            /**
451            * Returns all the groups where companyId = &#63;.
452            *
453            * @param companyId the company ID
454            * @return the matching groups
455            */
456            public static List<Group> findByCompanyId(long companyId) {
457                    return getPersistence().findByCompanyId(companyId);
458            }
459    
460            /**
461            * Returns a range of all the groups where companyId = &#63;.
462            *
463            * <p>
464            * 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 GroupModelImpl}. 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.
465            * </p>
466            *
467            * @param companyId the company ID
468            * @param start the lower bound of the range of groups
469            * @param end the upper bound of the range of groups (not inclusive)
470            * @return the range of matching groups
471            */
472            public static List<Group> findByCompanyId(long companyId, int start, int end) {
473                    return getPersistence().findByCompanyId(companyId, start, end);
474            }
475    
476            /**
477            * Returns an ordered range of all the groups where companyId = &#63;.
478            *
479            * <p>
480            * 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 GroupModelImpl}. 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.
481            * </p>
482            *
483            * @param companyId the company ID
484            * @param start the lower bound of the range of groups
485            * @param end the upper bound of the range of groups (not inclusive)
486            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
487            * @return the ordered range of matching groups
488            */
489            public static List<Group> findByCompanyId(long companyId, int start,
490                    int end, OrderByComparator<Group> orderByComparator) {
491                    return getPersistence()
492                                       .findByCompanyId(companyId, start, end, orderByComparator);
493            }
494    
495            /**
496            * Returns the first group in the ordered set where companyId = &#63;.
497            *
498            * @param companyId the company ID
499            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
500            * @return the first matching group
501            * @throws NoSuchGroupException if a matching group could not be found
502            */
503            public static Group findByCompanyId_First(long companyId,
504                    OrderByComparator<Group> orderByComparator)
505                    throws com.liferay.portal.NoSuchGroupException {
506                    return getPersistence()
507                                       .findByCompanyId_First(companyId, orderByComparator);
508            }
509    
510            /**
511            * Returns the first group in the ordered set where companyId = &#63;.
512            *
513            * @param companyId the company ID
514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
515            * @return the first matching group, or <code>null</code> if a matching group could not be found
516            */
517            public static Group fetchByCompanyId_First(long companyId,
518                    OrderByComparator<Group> orderByComparator) {
519                    return getPersistence()
520                                       .fetchByCompanyId_First(companyId, orderByComparator);
521            }
522    
523            /**
524            * Returns the last group in the ordered set where companyId = &#63;.
525            *
526            * @param companyId the company ID
527            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
528            * @return the last matching group
529            * @throws NoSuchGroupException if a matching group could not be found
530            */
531            public static Group findByCompanyId_Last(long companyId,
532                    OrderByComparator<Group> orderByComparator)
533                    throws com.liferay.portal.NoSuchGroupException {
534                    return getPersistence()
535                                       .findByCompanyId_Last(companyId, orderByComparator);
536            }
537    
538            /**
539            * Returns the last group in the ordered set where companyId = &#63;.
540            *
541            * @param companyId the company ID
542            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
543            * @return the last matching group, or <code>null</code> if a matching group could not be found
544            */
545            public static Group fetchByCompanyId_Last(long companyId,
546                    OrderByComparator<Group> orderByComparator) {
547                    return getPersistence()
548                                       .fetchByCompanyId_Last(companyId, orderByComparator);
549            }
550    
551            /**
552            * Returns the groups before and after the current group in the ordered set where companyId = &#63;.
553            *
554            * @param groupId the primary key of the current group
555            * @param companyId the company ID
556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
557            * @return the previous, current, and next group
558            * @throws NoSuchGroupException if a group with the primary key could not be found
559            */
560            public static Group[] findByCompanyId_PrevAndNext(long groupId,
561                    long companyId, OrderByComparator<Group> orderByComparator)
562                    throws com.liferay.portal.NoSuchGroupException {
563                    return getPersistence()
564                                       .findByCompanyId_PrevAndNext(groupId, companyId,
565                            orderByComparator);
566            }
567    
568            /**
569            * Removes all the groups where companyId = &#63; from the database.
570            *
571            * @param companyId the company ID
572            */
573            public static void removeByCompanyId(long companyId) {
574                    getPersistence().removeByCompanyId(companyId);
575            }
576    
577            /**
578            * Returns the number of groups where companyId = &#63;.
579            *
580            * @param companyId the company ID
581            * @return the number of matching groups
582            */
583            public static int countByCompanyId(long companyId) {
584                    return getPersistence().countByCompanyId(companyId);
585            }
586    
587            /**
588            * Returns the group where liveGroupId = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
589            *
590            * @param liveGroupId the live group ID
591            * @return the matching group
592            * @throws NoSuchGroupException if a matching group could not be found
593            */
594            public static Group findByLiveGroupId(long liveGroupId)
595                    throws com.liferay.portal.NoSuchGroupException {
596                    return getPersistence().findByLiveGroupId(liveGroupId);
597            }
598    
599            /**
600            * Returns the group where liveGroupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
601            *
602            * @param liveGroupId the live group ID
603            * @return the matching group, or <code>null</code> if a matching group could not be found
604            */
605            public static Group fetchByLiveGroupId(long liveGroupId) {
606                    return getPersistence().fetchByLiveGroupId(liveGroupId);
607            }
608    
609            /**
610            * Returns the group where liveGroupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
611            *
612            * @param liveGroupId the live group ID
613            * @param retrieveFromCache whether to use the finder cache
614            * @return the matching group, or <code>null</code> if a matching group could not be found
615            */
616            public static Group fetchByLiveGroupId(long liveGroupId,
617                    boolean retrieveFromCache) {
618                    return getPersistence()
619                                       .fetchByLiveGroupId(liveGroupId, retrieveFromCache);
620            }
621    
622            /**
623            * Removes the group where liveGroupId = &#63; from the database.
624            *
625            * @param liveGroupId the live group ID
626            * @return the group that was removed
627            */
628            public static Group removeByLiveGroupId(long liveGroupId)
629                    throws com.liferay.portal.NoSuchGroupException {
630                    return getPersistence().removeByLiveGroupId(liveGroupId);
631            }
632    
633            /**
634            * Returns the number of groups where liveGroupId = &#63;.
635            *
636            * @param liveGroupId the live group ID
637            * @return the number of matching groups
638            */
639            public static int countByLiveGroupId(long liveGroupId) {
640                    return getPersistence().countByLiveGroupId(liveGroupId);
641            }
642    
643            /**
644            * Returns all the groups where companyId = &#63; and classNameId = &#63;.
645            *
646            * @param companyId the company ID
647            * @param classNameId the class name ID
648            * @return the matching groups
649            */
650            public static List<Group> findByC_C(long companyId, long classNameId) {
651                    return getPersistence().findByC_C(companyId, classNameId);
652            }
653    
654            /**
655            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63;.
656            *
657            * <p>
658            * 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 GroupModelImpl}. 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.
659            * </p>
660            *
661            * @param companyId the company ID
662            * @param classNameId the class name ID
663            * @param start the lower bound of the range of groups
664            * @param end the upper bound of the range of groups (not inclusive)
665            * @return the range of matching groups
666            */
667            public static List<Group> findByC_C(long companyId, long classNameId,
668                    int start, int end) {
669                    return getPersistence().findByC_C(companyId, classNameId, start, end);
670            }
671    
672            /**
673            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63;.
674            *
675            * <p>
676            * 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 GroupModelImpl}. 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.
677            * </p>
678            *
679            * @param companyId the company ID
680            * @param classNameId the class name ID
681            * @param start the lower bound of the range of groups
682            * @param end the upper bound of the range of groups (not inclusive)
683            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
684            * @return the ordered range of matching groups
685            */
686            public static List<Group> findByC_C(long companyId, long classNameId,
687                    int start, int end, OrderByComparator<Group> orderByComparator) {
688                    return getPersistence()
689                                       .findByC_C(companyId, classNameId, start, end,
690                            orderByComparator);
691            }
692    
693            /**
694            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
695            *
696            * @param companyId the company ID
697            * @param classNameId the class name ID
698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
699            * @return the first matching group
700            * @throws NoSuchGroupException if a matching group could not be found
701            */
702            public static Group findByC_C_First(long companyId, long classNameId,
703                    OrderByComparator<Group> orderByComparator)
704                    throws com.liferay.portal.NoSuchGroupException {
705                    return getPersistence()
706                                       .findByC_C_First(companyId, classNameId, orderByComparator);
707            }
708    
709            /**
710            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
711            *
712            * @param companyId the company ID
713            * @param classNameId the class name ID
714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
715            * @return the first matching group, or <code>null</code> if a matching group could not be found
716            */
717            public static Group fetchByC_C_First(long companyId, long classNameId,
718                    OrderByComparator<Group> orderByComparator) {
719                    return getPersistence()
720                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
721            }
722    
723            /**
724            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
725            *
726            * @param companyId the company ID
727            * @param classNameId the class name ID
728            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
729            * @return the last matching group
730            * @throws NoSuchGroupException if a matching group could not be found
731            */
732            public static Group findByC_C_Last(long companyId, long classNameId,
733                    OrderByComparator<Group> orderByComparator)
734                    throws com.liferay.portal.NoSuchGroupException {
735                    return getPersistence()
736                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
737            }
738    
739            /**
740            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
741            *
742            * @param companyId the company ID
743            * @param classNameId the class name ID
744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
745            * @return the last matching group, or <code>null</code> if a matching group could not be found
746            */
747            public static Group fetchByC_C_Last(long companyId, long classNameId,
748                    OrderByComparator<Group> orderByComparator) {
749                    return getPersistence()
750                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
751            }
752    
753            /**
754            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63;.
755            *
756            * @param groupId the primary key of the current group
757            * @param companyId the company ID
758            * @param classNameId the class name ID
759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
760            * @return the previous, current, and next group
761            * @throws NoSuchGroupException if a group with the primary key could not be found
762            */
763            public static Group[] findByC_C_PrevAndNext(long groupId, long companyId,
764                    long classNameId, OrderByComparator<Group> orderByComparator)
765                    throws com.liferay.portal.NoSuchGroupException {
766                    return getPersistence()
767                                       .findByC_C_PrevAndNext(groupId, companyId, classNameId,
768                            orderByComparator);
769            }
770    
771            /**
772            * Removes all the groups where companyId = &#63; and classNameId = &#63; from the database.
773            *
774            * @param companyId the company ID
775            * @param classNameId the class name ID
776            */
777            public static void removeByC_C(long companyId, long classNameId) {
778                    getPersistence().removeByC_C(companyId, classNameId);
779            }
780    
781            /**
782            * Returns the number of groups where companyId = &#63; and classNameId = &#63;.
783            *
784            * @param companyId the company ID
785            * @param classNameId the class name ID
786            * @return the number of matching groups
787            */
788            public static int countByC_C(long companyId, long classNameId) {
789                    return getPersistence().countByC_C(companyId, classNameId);
790            }
791    
792            /**
793            * Returns all the groups where companyId = &#63; and parentGroupId = &#63;.
794            *
795            * @param companyId the company ID
796            * @param parentGroupId the parent group ID
797            * @return the matching groups
798            */
799            public static List<Group> findByC_P(long companyId, long parentGroupId) {
800                    return getPersistence().findByC_P(companyId, parentGroupId);
801            }
802    
803            /**
804            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63;.
805            *
806            * <p>
807            * 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 GroupModelImpl}. 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.
808            * </p>
809            *
810            * @param companyId the company ID
811            * @param parentGroupId the parent group ID
812            * @param start the lower bound of the range of groups
813            * @param end the upper bound of the range of groups (not inclusive)
814            * @return the range of matching groups
815            */
816            public static List<Group> findByC_P(long companyId, long parentGroupId,
817                    int start, int end) {
818                    return getPersistence().findByC_P(companyId, parentGroupId, start, end);
819            }
820    
821            /**
822            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63;.
823            *
824            * <p>
825            * 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 GroupModelImpl}. 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.
826            * </p>
827            *
828            * @param companyId the company ID
829            * @param parentGroupId the parent group ID
830            * @param start the lower bound of the range of groups
831            * @param end the upper bound of the range of groups (not inclusive)
832            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
833            * @return the ordered range of matching groups
834            */
835            public static List<Group> findByC_P(long companyId, long parentGroupId,
836                    int start, int end, OrderByComparator<Group> orderByComparator) {
837                    return getPersistence()
838                                       .findByC_P(companyId, parentGroupId, start, end,
839                            orderByComparator);
840            }
841    
842            /**
843            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
844            *
845            * @param companyId the company ID
846            * @param parentGroupId the parent group ID
847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
848            * @return the first matching group
849            * @throws NoSuchGroupException if a matching group could not be found
850            */
851            public static Group findByC_P_First(long companyId, long parentGroupId,
852                    OrderByComparator<Group> orderByComparator)
853                    throws com.liferay.portal.NoSuchGroupException {
854                    return getPersistence()
855                                       .findByC_P_First(companyId, parentGroupId, orderByComparator);
856            }
857    
858            /**
859            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
860            *
861            * @param companyId the company ID
862            * @param parentGroupId the parent group ID
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the first matching group, or <code>null</code> if a matching group could not be found
865            */
866            public static Group fetchByC_P_First(long companyId, long parentGroupId,
867                    OrderByComparator<Group> orderByComparator) {
868                    return getPersistence()
869                                       .fetchByC_P_First(companyId, parentGroupId, orderByComparator);
870            }
871    
872            /**
873            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
874            *
875            * @param companyId the company ID
876            * @param parentGroupId the parent group ID
877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
878            * @return the last matching group
879            * @throws NoSuchGroupException if a matching group could not be found
880            */
881            public static Group findByC_P_Last(long companyId, long parentGroupId,
882                    OrderByComparator<Group> orderByComparator)
883                    throws com.liferay.portal.NoSuchGroupException {
884                    return getPersistence()
885                                       .findByC_P_Last(companyId, parentGroupId, orderByComparator);
886            }
887    
888            /**
889            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
890            *
891            * @param companyId the company ID
892            * @param parentGroupId the parent group ID
893            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
894            * @return the last matching group, or <code>null</code> if a matching group could not be found
895            */
896            public static Group fetchByC_P_Last(long companyId, long parentGroupId,
897                    OrderByComparator<Group> orderByComparator) {
898                    return getPersistence()
899                                       .fetchByC_P_Last(companyId, parentGroupId, orderByComparator);
900            }
901    
902            /**
903            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
904            *
905            * @param groupId the primary key of the current group
906            * @param companyId the company ID
907            * @param parentGroupId the parent group ID
908            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
909            * @return the previous, current, and next group
910            * @throws NoSuchGroupException if a group with the primary key could not be found
911            */
912            public static Group[] findByC_P_PrevAndNext(long groupId, long companyId,
913                    long parentGroupId, OrderByComparator<Group> orderByComparator)
914                    throws com.liferay.portal.NoSuchGroupException {
915                    return getPersistence()
916                                       .findByC_P_PrevAndNext(groupId, companyId, parentGroupId,
917                            orderByComparator);
918            }
919    
920            /**
921            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; from the database.
922            *
923            * @param companyId the company ID
924            * @param parentGroupId the parent group ID
925            */
926            public static void removeByC_P(long companyId, long parentGroupId) {
927                    getPersistence().removeByC_P(companyId, parentGroupId);
928            }
929    
930            /**
931            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63;.
932            *
933            * @param companyId the company ID
934            * @param parentGroupId the parent group ID
935            * @return the number of matching groups
936            */
937            public static int countByC_P(long companyId, long parentGroupId) {
938                    return getPersistence().countByC_P(companyId, parentGroupId);
939            }
940    
941            /**
942            * Returns the group where companyId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
943            *
944            * @param companyId the company ID
945            * @param groupKey the group key
946            * @return the matching group
947            * @throws NoSuchGroupException if a matching group could not be found
948            */
949            public static Group findByC_GK(long companyId, java.lang.String groupKey)
950                    throws com.liferay.portal.NoSuchGroupException {
951                    return getPersistence().findByC_GK(companyId, groupKey);
952            }
953    
954            /**
955            * Returns the group where companyId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
956            *
957            * @param companyId the company ID
958            * @param groupKey the group key
959            * @return the matching group, or <code>null</code> if a matching group could not be found
960            */
961            public static Group fetchByC_GK(long companyId, java.lang.String groupKey) {
962                    return getPersistence().fetchByC_GK(companyId, groupKey);
963            }
964    
965            /**
966            * Returns the group where companyId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
967            *
968            * @param companyId the company ID
969            * @param groupKey the group key
970            * @param retrieveFromCache whether to use the finder cache
971            * @return the matching group, or <code>null</code> if a matching group could not be found
972            */
973            public static Group fetchByC_GK(long companyId, java.lang.String groupKey,
974                    boolean retrieveFromCache) {
975                    return getPersistence()
976                                       .fetchByC_GK(companyId, groupKey, retrieveFromCache);
977            }
978    
979            /**
980            * Removes the group where companyId = &#63; and groupKey = &#63; from the database.
981            *
982            * @param companyId the company ID
983            * @param groupKey the group key
984            * @return the group that was removed
985            */
986            public static Group removeByC_GK(long companyId, java.lang.String groupKey)
987                    throws com.liferay.portal.NoSuchGroupException {
988                    return getPersistence().removeByC_GK(companyId, groupKey);
989            }
990    
991            /**
992            * Returns the number of groups where companyId = &#63; and groupKey = &#63;.
993            *
994            * @param companyId the company ID
995            * @param groupKey the group key
996            * @return the number of matching groups
997            */
998            public static int countByC_GK(long companyId, java.lang.String groupKey) {
999                    return getPersistence().countByC_GK(companyId, groupKey);
1000            }
1001    
1002            /**
1003            * Returns the group where companyId = &#63; and friendlyURL = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1004            *
1005            * @param companyId the company ID
1006            * @param friendlyURL the friendly u r l
1007            * @return the matching group
1008            * @throws NoSuchGroupException if a matching group could not be found
1009            */
1010            public static Group findByC_F(long companyId, java.lang.String friendlyURL)
1011                    throws com.liferay.portal.NoSuchGroupException {
1012                    return getPersistence().findByC_F(companyId, friendlyURL);
1013            }
1014    
1015            /**
1016            * Returns the group where companyId = &#63; and friendlyURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1017            *
1018            * @param companyId the company ID
1019            * @param friendlyURL the friendly u r l
1020            * @return the matching group, or <code>null</code> if a matching group could not be found
1021            */
1022            public static Group fetchByC_F(long companyId, java.lang.String friendlyURL) {
1023                    return getPersistence().fetchByC_F(companyId, friendlyURL);
1024            }
1025    
1026            /**
1027            * Returns the group where companyId = &#63; and friendlyURL = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1028            *
1029            * @param companyId the company ID
1030            * @param friendlyURL the friendly u r l
1031            * @param retrieveFromCache whether to use the finder cache
1032            * @return the matching group, or <code>null</code> if a matching group could not be found
1033            */
1034            public static Group fetchByC_F(long companyId,
1035                    java.lang.String friendlyURL, boolean retrieveFromCache) {
1036                    return getPersistence()
1037                                       .fetchByC_F(companyId, friendlyURL, retrieveFromCache);
1038            }
1039    
1040            /**
1041            * Removes the group where companyId = &#63; and friendlyURL = &#63; from the database.
1042            *
1043            * @param companyId the company ID
1044            * @param friendlyURL the friendly u r l
1045            * @return the group that was removed
1046            */
1047            public static Group removeByC_F(long companyId, java.lang.String friendlyURL)
1048                    throws com.liferay.portal.NoSuchGroupException {
1049                    return getPersistence().removeByC_F(companyId, friendlyURL);
1050            }
1051    
1052            /**
1053            * Returns the number of groups where companyId = &#63; and friendlyURL = &#63;.
1054            *
1055            * @param companyId the company ID
1056            * @param friendlyURL the friendly u r l
1057            * @return the number of matching groups
1058            */
1059            public static int countByC_F(long companyId, java.lang.String friendlyURL) {
1060                    return getPersistence().countByC_F(companyId, friendlyURL);
1061            }
1062    
1063            /**
1064            * Returns all the groups where companyId = &#63; and site = &#63;.
1065            *
1066            * @param companyId the company ID
1067            * @param site the site
1068            * @return the matching groups
1069            */
1070            public static List<Group> findByC_S(long companyId, boolean site) {
1071                    return getPersistence().findByC_S(companyId, site);
1072            }
1073    
1074            /**
1075            * Returns a range of all the groups where companyId = &#63; and site = &#63;.
1076            *
1077            * <p>
1078            * 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 GroupModelImpl}. 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.
1079            * </p>
1080            *
1081            * @param companyId the company ID
1082            * @param site the site
1083            * @param start the lower bound of the range of groups
1084            * @param end the upper bound of the range of groups (not inclusive)
1085            * @return the range of matching groups
1086            */
1087            public static List<Group> findByC_S(long companyId, boolean site,
1088                    int start, int end) {
1089                    return getPersistence().findByC_S(companyId, site, start, end);
1090            }
1091    
1092            /**
1093            * Returns an ordered range of all the groups where companyId = &#63; and site = &#63;.
1094            *
1095            * <p>
1096            * 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 GroupModelImpl}. 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.
1097            * </p>
1098            *
1099            * @param companyId the company ID
1100            * @param site the site
1101            * @param start the lower bound of the range of groups
1102            * @param end the upper bound of the range of groups (not inclusive)
1103            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1104            * @return the ordered range of matching groups
1105            */
1106            public static List<Group> findByC_S(long companyId, boolean site,
1107                    int start, int end, OrderByComparator<Group> orderByComparator) {
1108                    return getPersistence()
1109                                       .findByC_S(companyId, site, start, end, orderByComparator);
1110            }
1111    
1112            /**
1113            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
1114            *
1115            * @param companyId the company ID
1116            * @param site the site
1117            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1118            * @return the first matching group
1119            * @throws NoSuchGroupException if a matching group could not be found
1120            */
1121            public static Group findByC_S_First(long companyId, boolean site,
1122                    OrderByComparator<Group> orderByComparator)
1123                    throws com.liferay.portal.NoSuchGroupException {
1124                    return getPersistence()
1125                                       .findByC_S_First(companyId, site, orderByComparator);
1126            }
1127    
1128            /**
1129            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
1130            *
1131            * @param companyId the company ID
1132            * @param site the site
1133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1134            * @return the first matching group, or <code>null</code> if a matching group could not be found
1135            */
1136            public static Group fetchByC_S_First(long companyId, boolean site,
1137                    OrderByComparator<Group> orderByComparator) {
1138                    return getPersistence()
1139                                       .fetchByC_S_First(companyId, site, orderByComparator);
1140            }
1141    
1142            /**
1143            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
1144            *
1145            * @param companyId the company ID
1146            * @param site the site
1147            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1148            * @return the last matching group
1149            * @throws NoSuchGroupException if a matching group could not be found
1150            */
1151            public static Group findByC_S_Last(long companyId, boolean site,
1152                    OrderByComparator<Group> orderByComparator)
1153                    throws com.liferay.portal.NoSuchGroupException {
1154                    return getPersistence()
1155                                       .findByC_S_Last(companyId, site, orderByComparator);
1156            }
1157    
1158            /**
1159            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
1160            *
1161            * @param companyId the company ID
1162            * @param site the site
1163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1164            * @return the last matching group, or <code>null</code> if a matching group could not be found
1165            */
1166            public static Group fetchByC_S_Last(long companyId, boolean site,
1167                    OrderByComparator<Group> orderByComparator) {
1168                    return getPersistence()
1169                                       .fetchByC_S_Last(companyId, site, orderByComparator);
1170            }
1171    
1172            /**
1173            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and site = &#63;.
1174            *
1175            * @param groupId the primary key of the current group
1176            * @param companyId the company ID
1177            * @param site the site
1178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1179            * @return the previous, current, and next group
1180            * @throws NoSuchGroupException if a group with the primary key could not be found
1181            */
1182            public static Group[] findByC_S_PrevAndNext(long groupId, long companyId,
1183                    boolean site, OrderByComparator<Group> orderByComparator)
1184                    throws com.liferay.portal.NoSuchGroupException {
1185                    return getPersistence()
1186                                       .findByC_S_PrevAndNext(groupId, companyId, site,
1187                            orderByComparator);
1188            }
1189    
1190            /**
1191            * Removes all the groups where companyId = &#63; and site = &#63; from the database.
1192            *
1193            * @param companyId the company ID
1194            * @param site the site
1195            */
1196            public static void removeByC_S(long companyId, boolean site) {
1197                    getPersistence().removeByC_S(companyId, site);
1198            }
1199    
1200            /**
1201            * Returns the number of groups where companyId = &#63; and site = &#63;.
1202            *
1203            * @param companyId the company ID
1204            * @param site the site
1205            * @return the number of matching groups
1206            */
1207            public static int countByC_S(long companyId, boolean site) {
1208                    return getPersistence().countByC_S(companyId, site);
1209            }
1210    
1211            /**
1212            * Returns all the groups where type = &#63; and active = &#63;.
1213            *
1214            * @param type the type
1215            * @param active the active
1216            * @return the matching groups
1217            */
1218            public static List<Group> findByT_A(int type, boolean active) {
1219                    return getPersistence().findByT_A(type, active);
1220            }
1221    
1222            /**
1223            * Returns a range of all the groups where type = &#63; and active = &#63;.
1224            *
1225            * <p>
1226            * 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 GroupModelImpl}. 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.
1227            * </p>
1228            *
1229            * @param type the type
1230            * @param active the active
1231            * @param start the lower bound of the range of groups
1232            * @param end the upper bound of the range of groups (not inclusive)
1233            * @return the range of matching groups
1234            */
1235            public static List<Group> findByT_A(int type, boolean active, int start,
1236                    int end) {
1237                    return getPersistence().findByT_A(type, active, start, end);
1238            }
1239    
1240            /**
1241            * Returns an ordered range of all the groups where type = &#63; and active = &#63;.
1242            *
1243            * <p>
1244            * 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 GroupModelImpl}. 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.
1245            * </p>
1246            *
1247            * @param type the type
1248            * @param active the active
1249            * @param start the lower bound of the range of groups
1250            * @param end the upper bound of the range of groups (not inclusive)
1251            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1252            * @return the ordered range of matching groups
1253            */
1254            public static List<Group> findByT_A(int type, boolean active, int start,
1255                    int end, OrderByComparator<Group> orderByComparator) {
1256                    return getPersistence()
1257                                       .findByT_A(type, active, start, end, orderByComparator);
1258            }
1259    
1260            /**
1261            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1262            *
1263            * @param type the type
1264            * @param active the active
1265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1266            * @return the first matching group
1267            * @throws NoSuchGroupException if a matching group could not be found
1268            */
1269            public static Group findByT_A_First(int type, boolean active,
1270                    OrderByComparator<Group> orderByComparator)
1271                    throws com.liferay.portal.NoSuchGroupException {
1272                    return getPersistence().findByT_A_First(type, active, orderByComparator);
1273            }
1274    
1275            /**
1276            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1277            *
1278            * @param type the type
1279            * @param active the active
1280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1281            * @return the first matching group, or <code>null</code> if a matching group could not be found
1282            */
1283            public static Group fetchByT_A_First(int type, boolean active,
1284                    OrderByComparator<Group> orderByComparator) {
1285                    return getPersistence().fetchByT_A_First(type, active, orderByComparator);
1286            }
1287    
1288            /**
1289            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1290            *
1291            * @param type the type
1292            * @param active the active
1293            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1294            * @return the last matching group
1295            * @throws NoSuchGroupException if a matching group could not be found
1296            */
1297            public static Group findByT_A_Last(int type, boolean active,
1298                    OrderByComparator<Group> orderByComparator)
1299                    throws com.liferay.portal.NoSuchGroupException {
1300                    return getPersistence().findByT_A_Last(type, active, orderByComparator);
1301            }
1302    
1303            /**
1304            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1305            *
1306            * @param type the type
1307            * @param active the active
1308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1309            * @return the last matching group, or <code>null</code> if a matching group could not be found
1310            */
1311            public static Group fetchByT_A_Last(int type, boolean active,
1312                    OrderByComparator<Group> orderByComparator) {
1313                    return getPersistence().fetchByT_A_Last(type, active, orderByComparator);
1314            }
1315    
1316            /**
1317            * Returns the groups before and after the current group in the ordered set where type = &#63; and active = &#63;.
1318            *
1319            * @param groupId the primary key of the current group
1320            * @param type the type
1321            * @param active the active
1322            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1323            * @return the previous, current, and next group
1324            * @throws NoSuchGroupException if a group with the primary key could not be found
1325            */
1326            public static Group[] findByT_A_PrevAndNext(long groupId, int type,
1327                    boolean active, OrderByComparator<Group> orderByComparator)
1328                    throws com.liferay.portal.NoSuchGroupException {
1329                    return getPersistence()
1330                                       .findByT_A_PrevAndNext(groupId, type, active,
1331                            orderByComparator);
1332            }
1333    
1334            /**
1335            * Removes all the groups where type = &#63; and active = &#63; from the database.
1336            *
1337            * @param type the type
1338            * @param active the active
1339            */
1340            public static void removeByT_A(int type, boolean active) {
1341                    getPersistence().removeByT_A(type, active);
1342            }
1343    
1344            /**
1345            * Returns the number of groups where type = &#63; and active = &#63;.
1346            *
1347            * @param type the type
1348            * @param active the active
1349            * @return the number of matching groups
1350            */
1351            public static int countByT_A(int type, boolean active) {
1352                    return getPersistence().countByT_A(type, active);
1353            }
1354    
1355            /**
1356            * Returns all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1357            *
1358            * @param groupId the group ID
1359            * @param companyId the company ID
1360            * @param parentGroupId the parent group ID
1361            * @return the matching groups
1362            */
1363            public static List<Group> findByG_C_P(long groupId, long companyId,
1364                    long parentGroupId) {
1365                    return getPersistence().findByG_C_P(groupId, companyId, parentGroupId);
1366            }
1367    
1368            /**
1369            * Returns a range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1370            *
1371            * <p>
1372            * 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 GroupModelImpl}. 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.
1373            * </p>
1374            *
1375            * @param groupId the group ID
1376            * @param companyId the company ID
1377            * @param parentGroupId the parent group ID
1378            * @param start the lower bound of the range of groups
1379            * @param end the upper bound of the range of groups (not inclusive)
1380            * @return the range of matching groups
1381            */
1382            public static List<Group> findByG_C_P(long groupId, long companyId,
1383                    long parentGroupId, int start, int end) {
1384                    return getPersistence()
1385                                       .findByG_C_P(groupId, companyId, parentGroupId, start, end);
1386            }
1387    
1388            /**
1389            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1390            *
1391            * <p>
1392            * 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 GroupModelImpl}. 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.
1393            * </p>
1394            *
1395            * @param groupId the group ID
1396            * @param companyId the company ID
1397            * @param parentGroupId the parent group ID
1398            * @param start the lower bound of the range of groups
1399            * @param end the upper bound of the range of groups (not inclusive)
1400            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1401            * @return the ordered range of matching groups
1402            */
1403            public static List<Group> findByG_C_P(long groupId, long companyId,
1404                    long parentGroupId, int start, int end,
1405                    OrderByComparator<Group> orderByComparator) {
1406                    return getPersistence()
1407                                       .findByG_C_P(groupId, companyId, parentGroupId, start, end,
1408                            orderByComparator);
1409            }
1410    
1411            /**
1412            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1413            *
1414            * @param groupId the group ID
1415            * @param companyId the company ID
1416            * @param parentGroupId the parent group ID
1417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1418            * @return the first matching group
1419            * @throws NoSuchGroupException if a matching group could not be found
1420            */
1421            public static Group findByG_C_P_First(long groupId, long companyId,
1422                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1423                    throws com.liferay.portal.NoSuchGroupException {
1424                    return getPersistence()
1425                                       .findByG_C_P_First(groupId, companyId, parentGroupId,
1426                            orderByComparator);
1427            }
1428    
1429            /**
1430            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1431            *
1432            * @param groupId the group ID
1433            * @param companyId the company ID
1434            * @param parentGroupId the parent group ID
1435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1436            * @return the first matching group, or <code>null</code> if a matching group could not be found
1437            */
1438            public static Group fetchByG_C_P_First(long groupId, long companyId,
1439                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
1440                    return getPersistence()
1441                                       .fetchByG_C_P_First(groupId, companyId, parentGroupId,
1442                            orderByComparator);
1443            }
1444    
1445            /**
1446            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1447            *
1448            * @param groupId the group ID
1449            * @param companyId the company ID
1450            * @param parentGroupId the parent group ID
1451            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1452            * @return the last matching group
1453            * @throws NoSuchGroupException if a matching group could not be found
1454            */
1455            public static Group findByG_C_P_Last(long groupId, long companyId,
1456                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1457                    throws com.liferay.portal.NoSuchGroupException {
1458                    return getPersistence()
1459                                       .findByG_C_P_Last(groupId, companyId, parentGroupId,
1460                            orderByComparator);
1461            }
1462    
1463            /**
1464            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1465            *
1466            * @param groupId the group ID
1467            * @param companyId the company ID
1468            * @param parentGroupId the parent group ID
1469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1470            * @return the last matching group, or <code>null</code> if a matching group could not be found
1471            */
1472            public static Group fetchByG_C_P_Last(long groupId, long companyId,
1473                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
1474                    return getPersistence()
1475                                       .fetchByG_C_P_Last(groupId, companyId, parentGroupId,
1476                            orderByComparator);
1477            }
1478    
1479            /**
1480            * Removes all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63; from the database.
1481            *
1482            * @param groupId the group ID
1483            * @param companyId the company ID
1484            * @param parentGroupId the parent group ID
1485            */
1486            public static void removeByG_C_P(long groupId, long companyId,
1487                    long parentGroupId) {
1488                    getPersistence().removeByG_C_P(groupId, companyId, parentGroupId);
1489            }
1490    
1491            /**
1492            * Returns the number of groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1493            *
1494            * @param groupId the group ID
1495            * @param companyId the company ID
1496            * @param parentGroupId the parent group ID
1497            * @return the number of matching groups
1498            */
1499            public static int countByG_C_P(long groupId, long companyId,
1500                    long parentGroupId) {
1501                    return getPersistence().countByG_C_P(groupId, companyId, parentGroupId);
1502            }
1503    
1504            /**
1505            * Returns the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1506            *
1507            * @param companyId the company ID
1508            * @param classNameId the class name ID
1509            * @param classPK the class p k
1510            * @return the matching group
1511            * @throws NoSuchGroupException if a matching group could not be found
1512            */
1513            public static Group findByC_C_C(long companyId, long classNameId,
1514                    long classPK) throws com.liferay.portal.NoSuchGroupException {
1515                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
1516            }
1517    
1518            /**
1519            * Returns the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1520            *
1521            * @param companyId the company ID
1522            * @param classNameId the class name ID
1523            * @param classPK the class p k
1524            * @return the matching group, or <code>null</code> if a matching group could not be found
1525            */
1526            public static Group fetchByC_C_C(long companyId, long classNameId,
1527                    long classPK) {
1528                    return getPersistence().fetchByC_C_C(companyId, classNameId, classPK);
1529            }
1530    
1531            /**
1532            * Returns the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1533            *
1534            * @param companyId the company ID
1535            * @param classNameId the class name ID
1536            * @param classPK the class p k
1537            * @param retrieveFromCache whether to use the finder cache
1538            * @return the matching group, or <code>null</code> if a matching group could not be found
1539            */
1540            public static Group fetchByC_C_C(long companyId, long classNameId,
1541                    long classPK, boolean retrieveFromCache) {
1542                    return getPersistence()
1543                                       .fetchByC_C_C(companyId, classNameId, classPK,
1544                            retrieveFromCache);
1545            }
1546    
1547            /**
1548            * Removes the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1549            *
1550            * @param companyId the company ID
1551            * @param classNameId the class name ID
1552            * @param classPK the class p k
1553            * @return the group that was removed
1554            */
1555            public static Group removeByC_C_C(long companyId, long classNameId,
1556                    long classPK) throws com.liferay.portal.NoSuchGroupException {
1557                    return getPersistence().removeByC_C_C(companyId, classNameId, classPK);
1558            }
1559    
1560            /**
1561            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1562            *
1563            * @param companyId the company ID
1564            * @param classNameId the class name ID
1565            * @param classPK the class p k
1566            * @return the number of matching groups
1567            */
1568            public static int countByC_C_C(long companyId, long classNameId,
1569                    long classPK) {
1570                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
1571            }
1572    
1573            /**
1574            * Returns all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1575            *
1576            * @param companyId the company ID
1577            * @param classNameId the class name ID
1578            * @param parentGroupId the parent group ID
1579            * @return the matching groups
1580            */
1581            public static List<Group> findByC_C_P(long companyId, long classNameId,
1582                    long parentGroupId) {
1583                    return getPersistence()
1584                                       .findByC_C_P(companyId, classNameId, parentGroupId);
1585            }
1586    
1587            /**
1588            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1589            *
1590            * <p>
1591            * 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 GroupModelImpl}. 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.
1592            * </p>
1593            *
1594            * @param companyId the company ID
1595            * @param classNameId the class name ID
1596            * @param parentGroupId the parent group ID
1597            * @param start the lower bound of the range of groups
1598            * @param end the upper bound of the range of groups (not inclusive)
1599            * @return the range of matching groups
1600            */
1601            public static List<Group> findByC_C_P(long companyId, long classNameId,
1602                    long parentGroupId, int start, int end) {
1603                    return getPersistence()
1604                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1605                            end);
1606            }
1607    
1608            /**
1609            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1610            *
1611            * <p>
1612            * 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 GroupModelImpl}. 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.
1613            * </p>
1614            *
1615            * @param companyId the company ID
1616            * @param classNameId the class name ID
1617            * @param parentGroupId the parent group ID
1618            * @param start the lower bound of the range of groups
1619            * @param end the upper bound of the range of groups (not inclusive)
1620            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1621            * @return the ordered range of matching groups
1622            */
1623            public static List<Group> findByC_C_P(long companyId, long classNameId,
1624                    long parentGroupId, int start, int end,
1625                    OrderByComparator<Group> orderByComparator) {
1626                    return getPersistence()
1627                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1628                            end, orderByComparator);
1629            }
1630    
1631            /**
1632            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1633            *
1634            * @param companyId the company ID
1635            * @param classNameId the class name ID
1636            * @param parentGroupId the parent group ID
1637            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1638            * @return the first matching group
1639            * @throws NoSuchGroupException if a matching group could not be found
1640            */
1641            public static Group findByC_C_P_First(long companyId, long classNameId,
1642                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1643                    throws com.liferay.portal.NoSuchGroupException {
1644                    return getPersistence()
1645                                       .findByC_C_P_First(companyId, classNameId, parentGroupId,
1646                            orderByComparator);
1647            }
1648    
1649            /**
1650            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1651            *
1652            * @param companyId the company ID
1653            * @param classNameId the class name ID
1654            * @param parentGroupId the parent group ID
1655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1656            * @return the first matching group, or <code>null</code> if a matching group could not be found
1657            */
1658            public static Group fetchByC_C_P_First(long companyId, long classNameId,
1659                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
1660                    return getPersistence()
1661                                       .fetchByC_C_P_First(companyId, classNameId, parentGroupId,
1662                            orderByComparator);
1663            }
1664    
1665            /**
1666            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1667            *
1668            * @param companyId the company ID
1669            * @param classNameId the class name ID
1670            * @param parentGroupId the parent group ID
1671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1672            * @return the last matching group
1673            * @throws NoSuchGroupException if a matching group could not be found
1674            */
1675            public static Group findByC_C_P_Last(long companyId, long classNameId,
1676                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1677                    throws com.liferay.portal.NoSuchGroupException {
1678                    return getPersistence()
1679                                       .findByC_C_P_Last(companyId, classNameId, parentGroupId,
1680                            orderByComparator);
1681            }
1682    
1683            /**
1684            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1685            *
1686            * @param companyId the company ID
1687            * @param classNameId the class name ID
1688            * @param parentGroupId the parent group ID
1689            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1690            * @return the last matching group, or <code>null</code> if a matching group could not be found
1691            */
1692            public static Group fetchByC_C_P_Last(long companyId, long classNameId,
1693                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
1694                    return getPersistence()
1695                                       .fetchByC_C_P_Last(companyId, classNameId, parentGroupId,
1696                            orderByComparator);
1697            }
1698    
1699            /**
1700            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1701            *
1702            * @param groupId the primary key of the current group
1703            * @param companyId the company ID
1704            * @param classNameId the class name ID
1705            * @param parentGroupId the parent group ID
1706            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1707            * @return the previous, current, and next group
1708            * @throws NoSuchGroupException if a group with the primary key could not be found
1709            */
1710            public static Group[] findByC_C_P_PrevAndNext(long groupId, long companyId,
1711                    long classNameId, long parentGroupId,
1712                    OrderByComparator<Group> orderByComparator)
1713                    throws com.liferay.portal.NoSuchGroupException {
1714                    return getPersistence()
1715                                       .findByC_C_P_PrevAndNext(groupId, companyId, classNameId,
1716                            parentGroupId, orderByComparator);
1717            }
1718    
1719            /**
1720            * Removes all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
1721            *
1722            * @param companyId the company ID
1723            * @param classNameId the class name ID
1724            * @param parentGroupId the parent group ID
1725            */
1726            public static void removeByC_C_P(long companyId, long classNameId,
1727                    long parentGroupId) {
1728                    getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId);
1729            }
1730    
1731            /**
1732            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1733            *
1734            * @param companyId the company ID
1735            * @param classNameId the class name ID
1736            * @param parentGroupId the parent group ID
1737            * @return the number of matching groups
1738            */
1739            public static int countByC_C_P(long companyId, long classNameId,
1740                    long parentGroupId) {
1741                    return getPersistence()
1742                                       .countByC_C_P(companyId, classNameId, parentGroupId);
1743            }
1744    
1745            /**
1746            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1747            *
1748            * @param companyId the company ID
1749            * @param parentGroupId the parent group ID
1750            * @param site the site
1751            * @return the matching groups
1752            */
1753            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
1754                    boolean site) {
1755                    return getPersistence().findByC_P_S(companyId, parentGroupId, site);
1756            }
1757    
1758            /**
1759            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1760            *
1761            * <p>
1762            * 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 GroupModelImpl}. 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.
1763            * </p>
1764            *
1765            * @param companyId the company ID
1766            * @param parentGroupId the parent group ID
1767            * @param site the site
1768            * @param start the lower bound of the range of groups
1769            * @param end the upper bound of the range of groups (not inclusive)
1770            * @return the range of matching groups
1771            */
1772            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
1773                    boolean site, int start, int end) {
1774                    return getPersistence()
1775                                       .findByC_P_S(companyId, parentGroupId, site, start, end);
1776            }
1777    
1778            /**
1779            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1780            *
1781            * <p>
1782            * 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 GroupModelImpl}. 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.
1783            * </p>
1784            *
1785            * @param companyId the company ID
1786            * @param parentGroupId the parent group ID
1787            * @param site the site
1788            * @param start the lower bound of the range of groups
1789            * @param end the upper bound of the range of groups (not inclusive)
1790            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1791            * @return the ordered range of matching groups
1792            */
1793            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
1794                    boolean site, int start, int end,
1795                    OrderByComparator<Group> orderByComparator) {
1796                    return getPersistence()
1797                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
1798                            orderByComparator);
1799            }
1800    
1801            /**
1802            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1803            *
1804            * @param companyId the company ID
1805            * @param parentGroupId the parent group ID
1806            * @param site the site
1807            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1808            * @return the first matching group
1809            * @throws NoSuchGroupException if a matching group could not be found
1810            */
1811            public static Group findByC_P_S_First(long companyId, long parentGroupId,
1812                    boolean site, OrderByComparator<Group> orderByComparator)
1813                    throws com.liferay.portal.NoSuchGroupException {
1814                    return getPersistence()
1815                                       .findByC_P_S_First(companyId, parentGroupId, site,
1816                            orderByComparator);
1817            }
1818    
1819            /**
1820            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1821            *
1822            * @param companyId the company ID
1823            * @param parentGroupId the parent group ID
1824            * @param site the site
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the first matching group, or <code>null</code> if a matching group could not be found
1827            */
1828            public static Group fetchByC_P_S_First(long companyId, long parentGroupId,
1829                    boolean site, OrderByComparator<Group> orderByComparator) {
1830                    return getPersistence()
1831                                       .fetchByC_P_S_First(companyId, parentGroupId, site,
1832                            orderByComparator);
1833            }
1834    
1835            /**
1836            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1837            *
1838            * @param companyId the company ID
1839            * @param parentGroupId the parent group ID
1840            * @param site the site
1841            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1842            * @return the last matching group
1843            * @throws NoSuchGroupException if a matching group could not be found
1844            */
1845            public static Group findByC_P_S_Last(long companyId, long parentGroupId,
1846                    boolean site, OrderByComparator<Group> orderByComparator)
1847                    throws com.liferay.portal.NoSuchGroupException {
1848                    return getPersistence()
1849                                       .findByC_P_S_Last(companyId, parentGroupId, site,
1850                            orderByComparator);
1851            }
1852    
1853            /**
1854            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1855            *
1856            * @param companyId the company ID
1857            * @param parentGroupId the parent group ID
1858            * @param site the site
1859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1860            * @return the last matching group, or <code>null</code> if a matching group could not be found
1861            */
1862            public static Group fetchByC_P_S_Last(long companyId, long parentGroupId,
1863                    boolean site, OrderByComparator<Group> orderByComparator) {
1864                    return getPersistence()
1865                                       .fetchByC_P_S_Last(companyId, parentGroupId, site,
1866                            orderByComparator);
1867            }
1868    
1869            /**
1870            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1871            *
1872            * @param groupId the primary key of the current group
1873            * @param companyId the company ID
1874            * @param parentGroupId the parent group ID
1875            * @param site the site
1876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1877            * @return the previous, current, and next group
1878            * @throws NoSuchGroupException if a group with the primary key could not be found
1879            */
1880            public static Group[] findByC_P_S_PrevAndNext(long groupId, long companyId,
1881                    long parentGroupId, boolean site,
1882                    OrderByComparator<Group> orderByComparator)
1883                    throws com.liferay.portal.NoSuchGroupException {
1884                    return getPersistence()
1885                                       .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId,
1886                            site, orderByComparator);
1887            }
1888    
1889            /**
1890            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; from the database.
1891            *
1892            * @param companyId the company ID
1893            * @param parentGroupId the parent group ID
1894            * @param site the site
1895            */
1896            public static void removeByC_P_S(long companyId, long parentGroupId,
1897                    boolean site) {
1898                    getPersistence().removeByC_P_S(companyId, parentGroupId, site);
1899            }
1900    
1901            /**
1902            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1903            *
1904            * @param companyId the company ID
1905            * @param parentGroupId the parent group ID
1906            * @param site the site
1907            * @return the number of matching groups
1908            */
1909            public static int countByC_P_S(long companyId, long parentGroupId,
1910                    boolean site) {
1911                    return getPersistence().countByC_P_S(companyId, parentGroupId, site);
1912            }
1913    
1914            /**
1915            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1916            *
1917            * @param companyId the company ID
1918            * @param liveGroupId the live group ID
1919            * @param groupKey the group key
1920            * @return the matching group
1921            * @throws NoSuchGroupException if a matching group could not be found
1922            */
1923            public static Group findByC_L_GK(long companyId, long liveGroupId,
1924                    java.lang.String groupKey)
1925                    throws com.liferay.portal.NoSuchGroupException {
1926                    return getPersistence().findByC_L_GK(companyId, liveGroupId, groupKey);
1927            }
1928    
1929            /**
1930            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1931            *
1932            * @param companyId the company ID
1933            * @param liveGroupId the live group ID
1934            * @param groupKey the group key
1935            * @return the matching group, or <code>null</code> if a matching group could not be found
1936            */
1937            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
1938                    java.lang.String groupKey) {
1939                    return getPersistence().fetchByC_L_GK(companyId, liveGroupId, groupKey);
1940            }
1941    
1942            /**
1943            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1944            *
1945            * @param companyId the company ID
1946            * @param liveGroupId the live group ID
1947            * @param groupKey the group key
1948            * @param retrieveFromCache whether to use the finder cache
1949            * @return the matching group, or <code>null</code> if a matching group could not be found
1950            */
1951            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
1952                    java.lang.String groupKey, boolean retrieveFromCache) {
1953                    return getPersistence()
1954                                       .fetchByC_L_GK(companyId, liveGroupId, groupKey,
1955                            retrieveFromCache);
1956            }
1957    
1958            /**
1959            * Removes the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
1960            *
1961            * @param companyId the company ID
1962            * @param liveGroupId the live group ID
1963            * @param groupKey the group key
1964            * @return the group that was removed
1965            */
1966            public static Group removeByC_L_GK(long companyId, long liveGroupId,
1967                    java.lang.String groupKey)
1968                    throws com.liferay.portal.NoSuchGroupException {
1969                    return getPersistence().removeByC_L_GK(companyId, liveGroupId, groupKey);
1970            }
1971    
1972            /**
1973            * Returns the number of groups where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
1974            *
1975            * @param companyId the company ID
1976            * @param liveGroupId the live group ID
1977            * @param groupKey the group key
1978            * @return the number of matching groups
1979            */
1980            public static int countByC_L_GK(long companyId, long liveGroupId,
1981                    java.lang.String groupKey) {
1982                    return getPersistence().countByC_L_GK(companyId, liveGroupId, groupKey);
1983            }
1984    
1985            /**
1986            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1987            *
1988            * @param companyId the company ID
1989            * @param classNameId the class name ID
1990            * @param liveGroupId the live group ID
1991            * @param groupKey the group key
1992            * @return the matching group
1993            * @throws NoSuchGroupException if a matching group could not be found
1994            */
1995            public static Group findByC_C_L_GK(long companyId, long classNameId,
1996                    long liveGroupId, java.lang.String groupKey)
1997                    throws com.liferay.portal.NoSuchGroupException {
1998                    return getPersistence()
1999                                       .findByC_C_L_GK(companyId, classNameId, liveGroupId, groupKey);
2000            }
2001    
2002            /**
2003            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2004            *
2005            * @param companyId the company ID
2006            * @param classNameId the class name ID
2007            * @param liveGroupId the live group ID
2008            * @param groupKey the group key
2009            * @return the matching group, or <code>null</code> if a matching group could not be found
2010            */
2011            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2012                    long liveGroupId, java.lang.String groupKey) {
2013                    return getPersistence()
2014                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2015                            groupKey);
2016            }
2017    
2018            /**
2019            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2020            *
2021            * @param companyId the company ID
2022            * @param classNameId the class name ID
2023            * @param liveGroupId the live group ID
2024            * @param groupKey the group key
2025            * @param retrieveFromCache whether to use the finder cache
2026            * @return the matching group, or <code>null</code> if a matching group could not be found
2027            */
2028            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2029                    long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache) {
2030                    return getPersistence()
2031                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2032                            groupKey, retrieveFromCache);
2033            }
2034    
2035            /**
2036            * Removes the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
2037            *
2038            * @param companyId the company ID
2039            * @param classNameId the class name ID
2040            * @param liveGroupId the live group ID
2041            * @param groupKey the group key
2042            * @return the group that was removed
2043            */
2044            public static Group removeByC_C_L_GK(long companyId, long classNameId,
2045                    long liveGroupId, java.lang.String groupKey)
2046                    throws com.liferay.portal.NoSuchGroupException {
2047                    return getPersistence()
2048                                       .removeByC_C_L_GK(companyId, classNameId, liveGroupId,
2049                            groupKey);
2050            }
2051    
2052            /**
2053            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
2054            *
2055            * @param companyId the company ID
2056            * @param classNameId the class name ID
2057            * @param liveGroupId the live group ID
2058            * @param groupKey the group key
2059            * @return the number of matching groups
2060            */
2061            public static int countByC_C_L_GK(long companyId, long classNameId,
2062                    long liveGroupId, java.lang.String groupKey) {
2063                    return getPersistence()
2064                                       .countByC_C_L_GK(companyId, classNameId, liveGroupId,
2065                            groupKey);
2066            }
2067    
2068            /**
2069            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2070            *
2071            * @param companyId the company ID
2072            * @param parentGroupId the parent group ID
2073            * @param site the site
2074            * @param inheritContent the inherit content
2075            * @return the matching groups
2076            */
2077            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2078                    boolean site, boolean inheritContent) {
2079                    return getPersistence()
2080                                       .findByC_P_S_I(companyId, parentGroupId, site, inheritContent);
2081            }
2082    
2083            /**
2084            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2085            *
2086            * <p>
2087            * 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 GroupModelImpl}. 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.
2088            * </p>
2089            *
2090            * @param companyId the company ID
2091            * @param parentGroupId the parent group ID
2092            * @param site the site
2093            * @param inheritContent the inherit content
2094            * @param start the lower bound of the range of groups
2095            * @param end the upper bound of the range of groups (not inclusive)
2096            * @return the range of matching groups
2097            */
2098            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2099                    boolean site, boolean inheritContent, int start, int end) {
2100                    return getPersistence()
2101                                       .findByC_P_S_I(companyId, parentGroupId, site,
2102                            inheritContent, start, end);
2103            }
2104    
2105            /**
2106            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2107            *
2108            * <p>
2109            * 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 GroupModelImpl}. 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.
2110            * </p>
2111            *
2112            * @param companyId the company ID
2113            * @param parentGroupId the parent group ID
2114            * @param site the site
2115            * @param inheritContent the inherit content
2116            * @param start the lower bound of the range of groups
2117            * @param end the upper bound of the range of groups (not inclusive)
2118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2119            * @return the ordered range of matching groups
2120            */
2121            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2122                    boolean site, boolean inheritContent, int start, int end,
2123                    OrderByComparator<Group> orderByComparator) {
2124                    return getPersistence()
2125                                       .findByC_P_S_I(companyId, parentGroupId, site,
2126                            inheritContent, start, end, orderByComparator);
2127            }
2128    
2129            /**
2130            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2131            *
2132            * @param companyId the company ID
2133            * @param parentGroupId the parent group ID
2134            * @param site the site
2135            * @param inheritContent the inherit content
2136            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2137            * @return the first matching group
2138            * @throws NoSuchGroupException if a matching group could not be found
2139            */
2140            public static Group findByC_P_S_I_First(long companyId, long parentGroupId,
2141                    boolean site, boolean inheritContent,
2142                    OrderByComparator<Group> orderByComparator)
2143                    throws com.liferay.portal.NoSuchGroupException {
2144                    return getPersistence()
2145                                       .findByC_P_S_I_First(companyId, parentGroupId, site,
2146                            inheritContent, orderByComparator);
2147            }
2148    
2149            /**
2150            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2151            *
2152            * @param companyId the company ID
2153            * @param parentGroupId the parent group ID
2154            * @param site the site
2155            * @param inheritContent the inherit content
2156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2157            * @return the first matching group, or <code>null</code> if a matching group could not be found
2158            */
2159            public static Group fetchByC_P_S_I_First(long companyId,
2160                    long parentGroupId, boolean site, boolean inheritContent,
2161                    OrderByComparator<Group> orderByComparator) {
2162                    return getPersistence()
2163                                       .fetchByC_P_S_I_First(companyId, parentGroupId, site,
2164                            inheritContent, orderByComparator);
2165            }
2166    
2167            /**
2168            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2169            *
2170            * @param companyId the company ID
2171            * @param parentGroupId the parent group ID
2172            * @param site the site
2173            * @param inheritContent the inherit content
2174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2175            * @return the last matching group
2176            * @throws NoSuchGroupException if a matching group could not be found
2177            */
2178            public static Group findByC_P_S_I_Last(long companyId, long parentGroupId,
2179                    boolean site, boolean inheritContent,
2180                    OrderByComparator<Group> orderByComparator)
2181                    throws com.liferay.portal.NoSuchGroupException {
2182                    return getPersistence()
2183                                       .findByC_P_S_I_Last(companyId, parentGroupId, site,
2184                            inheritContent, orderByComparator);
2185            }
2186    
2187            /**
2188            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2189            *
2190            * @param companyId the company ID
2191            * @param parentGroupId the parent group ID
2192            * @param site the site
2193            * @param inheritContent the inherit content
2194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2195            * @return the last matching group, or <code>null</code> if a matching group could not be found
2196            */
2197            public static Group fetchByC_P_S_I_Last(long companyId, long parentGroupId,
2198                    boolean site, boolean inheritContent,
2199                    OrderByComparator<Group> orderByComparator) {
2200                    return getPersistence()
2201                                       .fetchByC_P_S_I_Last(companyId, parentGroupId, site,
2202                            inheritContent, orderByComparator);
2203            }
2204    
2205            /**
2206            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2207            *
2208            * @param groupId the primary key of the current group
2209            * @param companyId the company ID
2210            * @param parentGroupId the parent group ID
2211            * @param site the site
2212            * @param inheritContent the inherit content
2213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2214            * @return the previous, current, and next group
2215            * @throws NoSuchGroupException if a group with the primary key could not be found
2216            */
2217            public static Group[] findByC_P_S_I_PrevAndNext(long groupId,
2218                    long companyId, long parentGroupId, boolean site,
2219                    boolean inheritContent, OrderByComparator<Group> orderByComparator)
2220                    throws com.liferay.portal.NoSuchGroupException {
2221                    return getPersistence()
2222                                       .findByC_P_S_I_PrevAndNext(groupId, companyId,
2223                            parentGroupId, site, inheritContent, orderByComparator);
2224            }
2225    
2226            /**
2227            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63; from the database.
2228            *
2229            * @param companyId the company ID
2230            * @param parentGroupId the parent group ID
2231            * @param site the site
2232            * @param inheritContent the inherit content
2233            */
2234            public static void removeByC_P_S_I(long companyId, long parentGroupId,
2235                    boolean site, boolean inheritContent) {
2236                    getPersistence()
2237                            .removeByC_P_S_I(companyId, parentGroupId, site, inheritContent);
2238            }
2239    
2240            /**
2241            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2242            *
2243            * @param companyId the company ID
2244            * @param parentGroupId the parent group ID
2245            * @param site the site
2246            * @param inheritContent the inherit content
2247            * @return the number of matching groups
2248            */
2249            public static int countByC_P_S_I(long companyId, long parentGroupId,
2250                    boolean site, boolean inheritContent) {
2251                    return getPersistence()
2252                                       .countByC_P_S_I(companyId, parentGroupId, site,
2253                            inheritContent);
2254            }
2255    
2256            /**
2257            * Caches the group in the entity cache if it is enabled.
2258            *
2259            * @param group the group
2260            */
2261            public static void cacheResult(Group group) {
2262                    getPersistence().cacheResult(group);
2263            }
2264    
2265            /**
2266            * Caches the groups in the entity cache if it is enabled.
2267            *
2268            * @param groups the groups
2269            */
2270            public static void cacheResult(List<Group> groups) {
2271                    getPersistence().cacheResult(groups);
2272            }
2273    
2274            /**
2275            * Creates a new group with the primary key. Does not add the group to the database.
2276            *
2277            * @param groupId the primary key for the new group
2278            * @return the new group
2279            */
2280            public static Group create(long groupId) {
2281                    return getPersistence().create(groupId);
2282            }
2283    
2284            /**
2285            * Removes the group with the primary key from the database. Also notifies the appropriate model listeners.
2286            *
2287            * @param groupId the primary key of the group
2288            * @return the group that was removed
2289            * @throws NoSuchGroupException if a group with the primary key could not be found
2290            */
2291            public static Group remove(long groupId)
2292                    throws com.liferay.portal.NoSuchGroupException {
2293                    return getPersistence().remove(groupId);
2294            }
2295    
2296            public static Group updateImpl(Group group) {
2297                    return getPersistence().updateImpl(group);
2298            }
2299    
2300            /**
2301            * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found.
2302            *
2303            * @param groupId the primary key of the group
2304            * @return the group
2305            * @throws NoSuchGroupException if a group with the primary key could not be found
2306            */
2307            public static Group findByPrimaryKey(long groupId)
2308                    throws com.liferay.portal.NoSuchGroupException {
2309                    return getPersistence().findByPrimaryKey(groupId);
2310            }
2311    
2312            /**
2313            * Returns the group with the primary key or returns <code>null</code> if it could not be found.
2314            *
2315            * @param groupId the primary key of the group
2316            * @return the group, or <code>null</code> if a group with the primary key could not be found
2317            */
2318            public static Group fetchByPrimaryKey(long groupId) {
2319                    return getPersistence().fetchByPrimaryKey(groupId);
2320            }
2321    
2322            public static java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys(
2323                    java.util.Set<java.io.Serializable> primaryKeys) {
2324                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2325            }
2326    
2327            /**
2328            * Returns all the groups.
2329            *
2330            * @return the groups
2331            */
2332            public static List<Group> findAll() {
2333                    return getPersistence().findAll();
2334            }
2335    
2336            /**
2337            * Returns a range of all the groups.
2338            *
2339            * <p>
2340            * 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 GroupModelImpl}. 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.
2341            * </p>
2342            *
2343            * @param start the lower bound of the range of groups
2344            * @param end the upper bound of the range of groups (not inclusive)
2345            * @return the range of groups
2346            */
2347            public static List<Group> findAll(int start, int end) {
2348                    return getPersistence().findAll(start, end);
2349            }
2350    
2351            /**
2352            * Returns an ordered range of all the groups.
2353            *
2354            * <p>
2355            * 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 GroupModelImpl}. 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.
2356            * </p>
2357            *
2358            * @param start the lower bound of the range of groups
2359            * @param end the upper bound of the range of groups (not inclusive)
2360            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2361            * @return the ordered range of groups
2362            */
2363            public static List<Group> findAll(int start, int end,
2364                    OrderByComparator<Group> orderByComparator) {
2365                    return getPersistence().findAll(start, end, orderByComparator);
2366            }
2367    
2368            /**
2369            * Removes all the groups from the database.
2370            */
2371            public static void removeAll() {
2372                    getPersistence().removeAll();
2373            }
2374    
2375            /**
2376            * Returns the number of groups.
2377            *
2378            * @return the number of groups
2379            */
2380            public static int countAll() {
2381                    return getPersistence().countAll();
2382            }
2383    
2384            /**
2385            * Returns the primaryKeys of organizations associated with the group.
2386            *
2387            * @param pk the primary key of the group
2388            * @return long[] of the primaryKeys of organizations associated with the group
2389            */
2390            public static long[] getOrganizationPrimaryKeys(long pk) {
2391                    return getPersistence().getOrganizationPrimaryKeys(pk);
2392            }
2393    
2394            /**
2395            * Returns all the organizations associated with the group.
2396            *
2397            * @param pk the primary key of the group
2398            * @return the organizations associated with the group
2399            */
2400            public static List<com.liferay.portal.model.Organization> getOrganizations(
2401                    long pk) {
2402                    return getPersistence().getOrganizations(pk);
2403            }
2404    
2405            /**
2406            * Returns a range of all the organizations associated with the group.
2407            *
2408            * <p>
2409            * 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 GroupModelImpl}. 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.
2410            * </p>
2411            *
2412            * @param pk the primary key of the group
2413            * @param start the lower bound of the range of groups
2414            * @param end the upper bound of the range of groups (not inclusive)
2415            * @return the range of organizations associated with the group
2416            */
2417            public static List<com.liferay.portal.model.Organization> getOrganizations(
2418                    long pk, int start, int end) {
2419                    return getPersistence().getOrganizations(pk, start, end);
2420            }
2421    
2422            /**
2423            * Returns an ordered range of all the organizations associated with the group.
2424            *
2425            * <p>
2426            * 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 GroupModelImpl}. 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.
2427            * </p>
2428            *
2429            * @param pk the primary key of the group
2430            * @param start the lower bound of the range of groups
2431            * @param end the upper bound of the range of groups (not inclusive)
2432            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2433            * @return the ordered range of organizations associated with the group
2434            */
2435            public static List<com.liferay.portal.model.Organization> getOrganizations(
2436                    long pk, int start, int end,
2437                    OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) {
2438                    return getPersistence()
2439                                       .getOrganizations(pk, start, end, orderByComparator);
2440            }
2441    
2442            /**
2443            * Returns the number of organizations associated with the group.
2444            *
2445            * @param pk the primary key of the group
2446            * @return the number of organizations associated with the group
2447            */
2448            public static int getOrganizationsSize(long pk) {
2449                    return getPersistence().getOrganizationsSize(pk);
2450            }
2451    
2452            /**
2453            * Returns <code>true</code> if the organization is associated with the group.
2454            *
2455            * @param pk the primary key of the group
2456            * @param organizationPK the primary key of the organization
2457            * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise
2458            */
2459            public static boolean containsOrganization(long pk, long organizationPK) {
2460                    return getPersistence().containsOrganization(pk, organizationPK);
2461            }
2462    
2463            /**
2464            * Returns <code>true</code> if the group has any organizations associated with it.
2465            *
2466            * @param pk the primary key of the group to check for associations with organizations
2467            * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise
2468            */
2469            public static boolean containsOrganizations(long pk) {
2470                    return getPersistence().containsOrganizations(pk);
2471            }
2472    
2473            /**
2474            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2475            *
2476            * @param pk the primary key of the group
2477            * @param organizationPK the primary key of the organization
2478            */
2479            public static void addOrganization(long pk, long organizationPK) {
2480                    getPersistence().addOrganization(pk, organizationPK);
2481            }
2482    
2483            /**
2484            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2485            *
2486            * @param pk the primary key of the group
2487            * @param organization the organization
2488            */
2489            public static void addOrganization(long pk,
2490                    com.liferay.portal.model.Organization organization) {
2491                    getPersistence().addOrganization(pk, organization);
2492            }
2493    
2494            /**
2495            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2496            *
2497            * @param pk the primary key of the group
2498            * @param organizationPKs the primary keys of the organizations
2499            */
2500            public static void addOrganizations(long pk, long[] organizationPKs) {
2501                    getPersistence().addOrganizations(pk, organizationPKs);
2502            }
2503    
2504            /**
2505            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2506            *
2507            * @param pk the primary key of the group
2508            * @param organizations the organizations
2509            */
2510            public static void addOrganizations(long pk,
2511                    List<com.liferay.portal.model.Organization> organizations) {
2512                    getPersistence().addOrganizations(pk, organizations);
2513            }
2514    
2515            /**
2516            * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2517            *
2518            * @param pk the primary key of the group to clear the associated organizations from
2519            */
2520            public static void clearOrganizations(long pk) {
2521                    getPersistence().clearOrganizations(pk);
2522            }
2523    
2524            /**
2525            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2526            *
2527            * @param pk the primary key of the group
2528            * @param organizationPK the primary key of the organization
2529            */
2530            public static void removeOrganization(long pk, long organizationPK) {
2531                    getPersistence().removeOrganization(pk, organizationPK);
2532            }
2533    
2534            /**
2535            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2536            *
2537            * @param pk the primary key of the group
2538            * @param organization the organization
2539            */
2540            public static void removeOrganization(long pk,
2541                    com.liferay.portal.model.Organization organization) {
2542                    getPersistence().removeOrganization(pk, organization);
2543            }
2544    
2545            /**
2546            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2547            *
2548            * @param pk the primary key of the group
2549            * @param organizationPKs the primary keys of the organizations
2550            */
2551            public static void removeOrganizations(long pk, long[] organizationPKs) {
2552                    getPersistence().removeOrganizations(pk, organizationPKs);
2553            }
2554    
2555            /**
2556            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2557            *
2558            * @param pk the primary key of the group
2559            * @param organizations the organizations
2560            */
2561            public static void removeOrganizations(long pk,
2562                    List<com.liferay.portal.model.Organization> organizations) {
2563                    getPersistence().removeOrganizations(pk, organizations);
2564            }
2565    
2566            /**
2567            * Sets the organizations associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2568            *
2569            * @param pk the primary key of the group
2570            * @param organizationPKs the primary keys of the organizations to be associated with the group
2571            */
2572            public static void setOrganizations(long pk, long[] organizationPKs) {
2573                    getPersistence().setOrganizations(pk, organizationPKs);
2574            }
2575    
2576            /**
2577            * Sets the organizations associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2578            *
2579            * @param pk the primary key of the group
2580            * @param organizations the organizations to be associated with the group
2581            */
2582            public static void setOrganizations(long pk,
2583                    List<com.liferay.portal.model.Organization> organizations) {
2584                    getPersistence().setOrganizations(pk, organizations);
2585            }
2586    
2587            /**
2588            * Returns the primaryKeys of roles associated with the group.
2589            *
2590            * @param pk the primary key of the group
2591            * @return long[] of the primaryKeys of roles associated with the group
2592            */
2593            public static long[] getRolePrimaryKeys(long pk) {
2594                    return getPersistence().getRolePrimaryKeys(pk);
2595            }
2596    
2597            /**
2598            * Returns all the roles associated with the group.
2599            *
2600            * @param pk the primary key of the group
2601            * @return the roles associated with the group
2602            */
2603            public static List<com.liferay.portal.model.Role> getRoles(long pk) {
2604                    return getPersistence().getRoles(pk);
2605            }
2606    
2607            /**
2608            * Returns a range of all the roles associated with the group.
2609            *
2610            * <p>
2611            * 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 GroupModelImpl}. 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.
2612            * </p>
2613            *
2614            * @param pk the primary key of the group
2615            * @param start the lower bound of the range of groups
2616            * @param end the upper bound of the range of groups (not inclusive)
2617            * @return the range of roles associated with the group
2618            */
2619            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2620                    int start, int end) {
2621                    return getPersistence().getRoles(pk, start, end);
2622            }
2623    
2624            /**
2625            * Returns an ordered range of all the roles associated with the group.
2626            *
2627            * <p>
2628            * 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 GroupModelImpl}. 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.
2629            * </p>
2630            *
2631            * @param pk the primary key of the group
2632            * @param start the lower bound of the range of groups
2633            * @param end the upper bound of the range of groups (not inclusive)
2634            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2635            * @return the ordered range of roles associated with the group
2636            */
2637            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2638                    int start, int end,
2639                    OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
2640                    return getPersistence().getRoles(pk, start, end, orderByComparator);
2641            }
2642    
2643            /**
2644            * Returns the number of roles associated with the group.
2645            *
2646            * @param pk the primary key of the group
2647            * @return the number of roles associated with the group
2648            */
2649            public static int getRolesSize(long pk) {
2650                    return getPersistence().getRolesSize(pk);
2651            }
2652    
2653            /**
2654            * Returns <code>true</code> if the role is associated with the group.
2655            *
2656            * @param pk the primary key of the group
2657            * @param rolePK the primary key of the role
2658            * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise
2659            */
2660            public static boolean containsRole(long pk, long rolePK) {
2661                    return getPersistence().containsRole(pk, rolePK);
2662            }
2663    
2664            /**
2665            * Returns <code>true</code> if the group has any roles associated with it.
2666            *
2667            * @param pk the primary key of the group to check for associations with roles
2668            * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise
2669            */
2670            public static boolean containsRoles(long pk) {
2671                    return getPersistence().containsRoles(pk);
2672            }
2673    
2674            /**
2675            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2676            *
2677            * @param pk the primary key of the group
2678            * @param rolePK the primary key of the role
2679            */
2680            public static void addRole(long pk, long rolePK) {
2681                    getPersistence().addRole(pk, rolePK);
2682            }
2683    
2684            /**
2685            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2686            *
2687            * @param pk the primary key of the group
2688            * @param role the role
2689            */
2690            public static void addRole(long pk, com.liferay.portal.model.Role role) {
2691                    getPersistence().addRole(pk, role);
2692            }
2693    
2694            /**
2695            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2696            *
2697            * @param pk the primary key of the group
2698            * @param rolePKs the primary keys of the roles
2699            */
2700            public static void addRoles(long pk, long[] rolePKs) {
2701                    getPersistence().addRoles(pk, rolePKs);
2702            }
2703    
2704            /**
2705            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2706            *
2707            * @param pk the primary key of the group
2708            * @param roles the roles
2709            */
2710            public static void addRoles(long pk,
2711                    List<com.liferay.portal.model.Role> roles) {
2712                    getPersistence().addRoles(pk, roles);
2713            }
2714    
2715            /**
2716            * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2717            *
2718            * @param pk the primary key of the group to clear the associated roles from
2719            */
2720            public static void clearRoles(long pk) {
2721                    getPersistence().clearRoles(pk);
2722            }
2723    
2724            /**
2725            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2726            *
2727            * @param pk the primary key of the group
2728            * @param rolePK the primary key of the role
2729            */
2730            public static void removeRole(long pk, long rolePK) {
2731                    getPersistence().removeRole(pk, rolePK);
2732            }
2733    
2734            /**
2735            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2736            *
2737            * @param pk the primary key of the group
2738            * @param role the role
2739            */
2740            public static void removeRole(long pk, com.liferay.portal.model.Role role) {
2741                    getPersistence().removeRole(pk, role);
2742            }
2743    
2744            /**
2745            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2746            *
2747            * @param pk the primary key of the group
2748            * @param rolePKs the primary keys of the roles
2749            */
2750            public static void removeRoles(long pk, long[] rolePKs) {
2751                    getPersistence().removeRoles(pk, rolePKs);
2752            }
2753    
2754            /**
2755            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2756            *
2757            * @param pk the primary key of the group
2758            * @param roles the roles
2759            */
2760            public static void removeRoles(long pk,
2761                    List<com.liferay.portal.model.Role> roles) {
2762                    getPersistence().removeRoles(pk, roles);
2763            }
2764    
2765            /**
2766            * Sets the roles associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2767            *
2768            * @param pk the primary key of the group
2769            * @param rolePKs the primary keys of the roles to be associated with the group
2770            */
2771            public static void setRoles(long pk, long[] rolePKs) {
2772                    getPersistence().setRoles(pk, rolePKs);
2773            }
2774    
2775            /**
2776            * Sets the roles associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2777            *
2778            * @param pk the primary key of the group
2779            * @param roles the roles to be associated with the group
2780            */
2781            public static void setRoles(long pk,
2782                    List<com.liferay.portal.model.Role> roles) {
2783                    getPersistence().setRoles(pk, roles);
2784            }
2785    
2786            /**
2787            * Returns the primaryKeys of user groups associated with the group.
2788            *
2789            * @param pk the primary key of the group
2790            * @return long[] of the primaryKeys of user groups associated with the group
2791            */
2792            public static long[] getUserGroupPrimaryKeys(long pk) {
2793                    return getPersistence().getUserGroupPrimaryKeys(pk);
2794            }
2795    
2796            /**
2797            * Returns all the user groups associated with the group.
2798            *
2799            * @param pk the primary key of the group
2800            * @return the user groups associated with the group
2801            */
2802            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
2803                    long pk) {
2804                    return getPersistence().getUserGroups(pk);
2805            }
2806    
2807            /**
2808            * Returns a range of all the user groups associated with the group.
2809            *
2810            * <p>
2811            * 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 GroupModelImpl}. 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.
2812            * </p>
2813            *
2814            * @param pk the primary key of the group
2815            * @param start the lower bound of the range of groups
2816            * @param end the upper bound of the range of groups (not inclusive)
2817            * @return the range of user groups associated with the group
2818            */
2819            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
2820                    long pk, int start, int end) {
2821                    return getPersistence().getUserGroups(pk, start, end);
2822            }
2823    
2824            /**
2825            * Returns an ordered range of all the user groups associated with the group.
2826            *
2827            * <p>
2828            * 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 GroupModelImpl}. 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.
2829            * </p>
2830            *
2831            * @param pk the primary key of the group
2832            * @param start the lower bound of the range of groups
2833            * @param end the upper bound of the range of groups (not inclusive)
2834            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2835            * @return the ordered range of user groups associated with the group
2836            */
2837            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
2838                    long pk, int start, int end,
2839                    OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
2840                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
2841            }
2842    
2843            /**
2844            * Returns the number of user groups associated with the group.
2845            *
2846            * @param pk the primary key of the group
2847            * @return the number of user groups associated with the group
2848            */
2849            public static int getUserGroupsSize(long pk) {
2850                    return getPersistence().getUserGroupsSize(pk);
2851            }
2852    
2853            /**
2854            * Returns <code>true</code> if the user group is associated with the group.
2855            *
2856            * @param pk the primary key of the group
2857            * @param userGroupPK the primary key of the user group
2858            * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise
2859            */
2860            public static boolean containsUserGroup(long pk, long userGroupPK) {
2861                    return getPersistence().containsUserGroup(pk, userGroupPK);
2862            }
2863    
2864            /**
2865            * Returns <code>true</code> if the group has any user groups associated with it.
2866            *
2867            * @param pk the primary key of the group to check for associations with user groups
2868            * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise
2869            */
2870            public static boolean containsUserGroups(long pk) {
2871                    return getPersistence().containsUserGroups(pk);
2872            }
2873    
2874            /**
2875            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2876            *
2877            * @param pk the primary key of the group
2878            * @param userGroupPK the primary key of the user group
2879            */
2880            public static void addUserGroup(long pk, long userGroupPK) {
2881                    getPersistence().addUserGroup(pk, userGroupPK);
2882            }
2883    
2884            /**
2885            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2886            *
2887            * @param pk the primary key of the group
2888            * @param userGroup the user group
2889            */
2890            public static void addUserGroup(long pk,
2891                    com.liferay.portal.model.UserGroup userGroup) {
2892                    getPersistence().addUserGroup(pk, userGroup);
2893            }
2894    
2895            /**
2896            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2897            *
2898            * @param pk the primary key of the group
2899            * @param userGroupPKs the primary keys of the user groups
2900            */
2901            public static void addUserGroups(long pk, long[] userGroupPKs) {
2902                    getPersistence().addUserGroups(pk, userGroupPKs);
2903            }
2904    
2905            /**
2906            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2907            *
2908            * @param pk the primary key of the group
2909            * @param userGroups the user groups
2910            */
2911            public static void addUserGroups(long pk,
2912                    List<com.liferay.portal.model.UserGroup> userGroups) {
2913                    getPersistence().addUserGroups(pk, userGroups);
2914            }
2915    
2916            /**
2917            * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2918            *
2919            * @param pk the primary key of the group to clear the associated user groups from
2920            */
2921            public static void clearUserGroups(long pk) {
2922                    getPersistence().clearUserGroups(pk);
2923            }
2924    
2925            /**
2926            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2927            *
2928            * @param pk the primary key of the group
2929            * @param userGroupPK the primary key of the user group
2930            */
2931            public static void removeUserGroup(long pk, long userGroupPK) {
2932                    getPersistence().removeUserGroup(pk, userGroupPK);
2933            }
2934    
2935            /**
2936            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2937            *
2938            * @param pk the primary key of the group
2939            * @param userGroup the user group
2940            */
2941            public static void removeUserGroup(long pk,
2942                    com.liferay.portal.model.UserGroup userGroup) {
2943                    getPersistence().removeUserGroup(pk, userGroup);
2944            }
2945    
2946            /**
2947            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2948            *
2949            * @param pk the primary key of the group
2950            * @param userGroupPKs the primary keys of the user groups
2951            */
2952            public static void removeUserGroups(long pk, long[] userGroupPKs) {
2953                    getPersistence().removeUserGroups(pk, userGroupPKs);
2954            }
2955    
2956            /**
2957            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2958            *
2959            * @param pk the primary key of the group
2960            * @param userGroups the user groups
2961            */
2962            public static void removeUserGroups(long pk,
2963                    List<com.liferay.portal.model.UserGroup> userGroups) {
2964                    getPersistence().removeUserGroups(pk, userGroups);
2965            }
2966    
2967            /**
2968            * Sets the user groups associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2969            *
2970            * @param pk the primary key of the group
2971            * @param userGroupPKs the primary keys of the user groups to be associated with the group
2972            */
2973            public static void setUserGroups(long pk, long[] userGroupPKs) {
2974                    getPersistence().setUserGroups(pk, userGroupPKs);
2975            }
2976    
2977            /**
2978            * Sets the user groups associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2979            *
2980            * @param pk the primary key of the group
2981            * @param userGroups the user groups to be associated with the group
2982            */
2983            public static void setUserGroups(long pk,
2984                    List<com.liferay.portal.model.UserGroup> userGroups) {
2985                    getPersistence().setUserGroups(pk, userGroups);
2986            }
2987    
2988            /**
2989            * Returns the primaryKeys of users associated with the group.
2990            *
2991            * @param pk the primary key of the group
2992            * @return long[] of the primaryKeys of users associated with the group
2993            */
2994            public static long[] getUserPrimaryKeys(long pk) {
2995                    return getPersistence().getUserPrimaryKeys(pk);
2996            }
2997    
2998            /**
2999            * Returns all the users associated with the group.
3000            *
3001            * @param pk the primary key of the group
3002            * @return the users associated with the group
3003            */
3004            public static List<com.liferay.portal.model.User> getUsers(long pk) {
3005                    return getPersistence().getUsers(pk);
3006            }
3007    
3008            /**
3009            * Returns a range of all the users associated with the group.
3010            *
3011            * <p>
3012            * 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 GroupModelImpl}. 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.
3013            * </p>
3014            *
3015            * @param pk the primary key of the group
3016            * @param start the lower bound of the range of groups
3017            * @param end the upper bound of the range of groups (not inclusive)
3018            * @return the range of users associated with the group
3019            */
3020            public static List<com.liferay.portal.model.User> getUsers(long pk,
3021                    int start, int end) {
3022                    return getPersistence().getUsers(pk, start, end);
3023            }
3024    
3025            /**
3026            * Returns an ordered range of all the users associated with the group.
3027            *
3028            * <p>
3029            * 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 GroupModelImpl}. 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.
3030            * </p>
3031            *
3032            * @param pk the primary key of the group
3033            * @param start the lower bound of the range of groups
3034            * @param end the upper bound of the range of groups (not inclusive)
3035            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3036            * @return the ordered range of users associated with the group
3037            */
3038            public static List<com.liferay.portal.model.User> getUsers(long pk,
3039                    int start, int end,
3040                    OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
3041                    return getPersistence().getUsers(pk, start, end, orderByComparator);
3042            }
3043    
3044            /**
3045            * Returns the number of users associated with the group.
3046            *
3047            * @param pk the primary key of the group
3048            * @return the number of users associated with the group
3049            */
3050            public static int getUsersSize(long pk) {
3051                    return getPersistence().getUsersSize(pk);
3052            }
3053    
3054            /**
3055            * Returns <code>true</code> if the user is associated with the group.
3056            *
3057            * @param pk the primary key of the group
3058            * @param userPK the primary key of the user
3059            * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise
3060            */
3061            public static boolean containsUser(long pk, long userPK) {
3062                    return getPersistence().containsUser(pk, userPK);
3063            }
3064    
3065            /**
3066            * Returns <code>true</code> if the group has any users associated with it.
3067            *
3068            * @param pk the primary key of the group to check for associations with users
3069            * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise
3070            */
3071            public static boolean containsUsers(long pk) {
3072                    return getPersistence().containsUsers(pk);
3073            }
3074    
3075            /**
3076            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3077            *
3078            * @param pk the primary key of the group
3079            * @param userPK the primary key of the user
3080            */
3081            public static void addUser(long pk, long userPK) {
3082                    getPersistence().addUser(pk, userPK);
3083            }
3084    
3085            /**
3086            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3087            *
3088            * @param pk the primary key of the group
3089            * @param user the user
3090            */
3091            public static void addUser(long pk, com.liferay.portal.model.User user) {
3092                    getPersistence().addUser(pk, user);
3093            }
3094    
3095            /**
3096            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3097            *
3098            * @param pk the primary key of the group
3099            * @param userPKs the primary keys of the users
3100            */
3101            public static void addUsers(long pk, long[] userPKs) {
3102                    getPersistence().addUsers(pk, userPKs);
3103            }
3104    
3105            /**
3106            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3107            *
3108            * @param pk the primary key of the group
3109            * @param users the users
3110            */
3111            public static void addUsers(long pk,
3112                    List<com.liferay.portal.model.User> users) {
3113                    getPersistence().addUsers(pk, users);
3114            }
3115    
3116            /**
3117            * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3118            *
3119            * @param pk the primary key of the group to clear the associated users from
3120            */
3121            public static void clearUsers(long pk) {
3122                    getPersistence().clearUsers(pk);
3123            }
3124    
3125            /**
3126            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3127            *
3128            * @param pk the primary key of the group
3129            * @param userPK the primary key of the user
3130            */
3131            public static void removeUser(long pk, long userPK) {
3132                    getPersistence().removeUser(pk, userPK);
3133            }
3134    
3135            /**
3136            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3137            *
3138            * @param pk the primary key of the group
3139            * @param user the user
3140            */
3141            public static void removeUser(long pk, com.liferay.portal.model.User user) {
3142                    getPersistence().removeUser(pk, user);
3143            }
3144    
3145            /**
3146            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3147            *
3148            * @param pk the primary key of the group
3149            * @param userPKs the primary keys of the users
3150            */
3151            public static void removeUsers(long pk, long[] userPKs) {
3152                    getPersistence().removeUsers(pk, userPKs);
3153            }
3154    
3155            /**
3156            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3157            *
3158            * @param pk the primary key of the group
3159            * @param users the users
3160            */
3161            public static void removeUsers(long pk,
3162                    List<com.liferay.portal.model.User> users) {
3163                    getPersistence().removeUsers(pk, users);
3164            }
3165    
3166            /**
3167            * Sets the users associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3168            *
3169            * @param pk the primary key of the group
3170            * @param userPKs the primary keys of the users to be associated with the group
3171            */
3172            public static void setUsers(long pk, long[] userPKs) {
3173                    getPersistence().setUsers(pk, userPKs);
3174            }
3175    
3176            /**
3177            * Sets the users associated with the group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3178            *
3179            * @param pk the primary key of the group
3180            * @param users the users to be associated with the group
3181            */
3182            public static void setUsers(long pk,
3183                    List<com.liferay.portal.model.User> users) {
3184                    getPersistence().setUsers(pk, users);
3185            }
3186    
3187            public static GroupPersistence getPersistence() {
3188                    if (_persistence == null) {
3189                            _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName());
3190    
3191                            ReferenceRegistry.registerReference(GroupUtil.class, "_persistence");
3192                    }
3193    
3194                    return _persistence;
3195            }
3196    
3197            /**
3198             * @deprecated As of 6.2.0
3199             */
3200            @Deprecated
3201            public void setPersistence(GroupPersistence persistence) {
3202            }
3203    
3204            private static GroupPersistence _persistence;
3205    }