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