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.kernel.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.model.Group;
022    import com.liferay.portal.kernel.service.ServiceContext;
023    import com.liferay.portal.kernel.util.OrderByComparator;
024    import com.liferay.portal.kernel.util.ReferenceRegistry;
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 BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see BasePersistence#clearCache(com.liferay.portal.kernel.model.BaseModel)
057             */
058            public static void clearCache(Group group) {
059                    getPersistence().clearCache(group);
060            }
061    
062            /**
063             * @see BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery) {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see 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 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 BasePersistence#update(com.liferay.portal.kernel.model.BaseModel)
096             */
097            public static Group update(Group group) {
098                    return getPersistence().update(group);
099            }
100    
101            /**
102             * @see BasePersistence#update(com.liferay.portal.kernel.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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.kernel.exception.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 companyId = &#63; and active = &#63;.
1349            *
1350            * @param companyId the company ID
1351            * @param active the active
1352            * @return the matching groups
1353            */
1354            public static List<Group> findByC_A(long companyId, boolean active) {
1355                    return getPersistence().findByC_A(companyId, active);
1356            }
1357    
1358            /**
1359            * Returns a range of all the groups where companyId = &#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 companyId the company ID
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> findByC_A(long companyId, boolean active,
1372                    int start, int end) {
1373                    return getPersistence().findByC_A(companyId, active, start, end);
1374            }
1375    
1376            /**
1377            * Returns an ordered range of all the groups where companyId = &#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 companyId the company ID
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> findByC_A(long companyId, boolean active,
1391                    int start, int end, OrderByComparator<Group> orderByComparator) {
1392                    return getPersistence()
1393                                       .findByC_A(companyId, active, start, end, orderByComparator);
1394            }
1395    
1396            /**
1397            * Returns an ordered range of all the groups where companyId = &#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 companyId the company ID
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> findByC_A(long companyId, boolean active,
1412                    int start, int end, OrderByComparator<Group> orderByComparator,
1413                    boolean retrieveFromCache) {
1414                    return getPersistence()
1415                                       .findByC_A(companyId, active, start, end, orderByComparator,
1416                            retrieveFromCache);
1417            }
1418    
1419            /**
1420            * Returns the first group in the ordered set where companyId = &#63; and active = &#63;.
1421            *
1422            * @param companyId the company ID
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 findByC_A_First(long companyId, boolean active,
1429                    OrderByComparator<Group> orderByComparator)
1430                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1431                    return getPersistence()
1432                                       .findByC_A_First(companyId, active, orderByComparator);
1433            }
1434    
1435            /**
1436            * Returns the first group in the ordered set where companyId = &#63; and active = &#63;.
1437            *
1438            * @param companyId the company ID
1439            * @param active the active
1440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1441            * @return the first matching group, or <code>null</code> if a matching group could not be found
1442            */
1443            public static Group fetchByC_A_First(long companyId, boolean active,
1444                    OrderByComparator<Group> orderByComparator) {
1445                    return getPersistence()
1446                                       .fetchByC_A_First(companyId, active, orderByComparator);
1447            }
1448    
1449            /**
1450            * Returns the last group in the ordered set where companyId = &#63; and active = &#63;.
1451            *
1452            * @param companyId the company ID
1453            * @param active the active
1454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1455            * @return the last matching group
1456            * @throws NoSuchGroupException if a matching group could not be found
1457            */
1458            public static Group findByC_A_Last(long companyId, boolean active,
1459                    OrderByComparator<Group> orderByComparator)
1460                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1461                    return getPersistence()
1462                                       .findByC_A_Last(companyId, active, orderByComparator);
1463            }
1464    
1465            /**
1466            * Returns the last group in the ordered set where companyId = &#63; and active = &#63;.
1467            *
1468            * @param companyId the company ID
1469            * @param active the active
1470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1471            * @return the last matching group, or <code>null</code> if a matching group could not be found
1472            */
1473            public static Group fetchByC_A_Last(long companyId, boolean active,
1474                    OrderByComparator<Group> orderByComparator) {
1475                    return getPersistence()
1476                                       .fetchByC_A_Last(companyId, active, orderByComparator);
1477            }
1478    
1479            /**
1480            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and active = &#63;.
1481            *
1482            * @param groupId the primary key of the current group
1483            * @param companyId the company ID
1484            * @param active the active
1485            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1486            * @return the previous, current, and next group
1487            * @throws NoSuchGroupException if a group with the primary key could not be found
1488            */
1489            public static Group[] findByC_A_PrevAndNext(long groupId, long companyId,
1490                    boolean active, OrderByComparator<Group> orderByComparator)
1491                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1492                    return getPersistence()
1493                                       .findByC_A_PrevAndNext(groupId, companyId, active,
1494                            orderByComparator);
1495            }
1496    
1497            /**
1498            * Removes all the groups where companyId = &#63; and active = &#63; from the database.
1499            *
1500            * @param companyId the company ID
1501            * @param active the active
1502            */
1503            public static void removeByC_A(long companyId, boolean active) {
1504                    getPersistence().removeByC_A(companyId, active);
1505            }
1506    
1507            /**
1508            * Returns the number of groups where companyId = &#63; and active = &#63;.
1509            *
1510            * @param companyId the company ID
1511            * @param active the active
1512            * @return the number of matching groups
1513            */
1514            public static int countByC_A(long companyId, boolean active) {
1515                    return getPersistence().countByC_A(companyId, active);
1516            }
1517    
1518            /**
1519            * Returns all the groups where classNameId = &#63; and classPK = &#63;.
1520            *
1521            * @param classNameId the class name ID
1522            * @param classPK the class p k
1523            * @return the matching groups
1524            */
1525            public static List<Group> findByC_CPK(long classNameId, long classPK) {
1526                    return getPersistence().findByC_CPK(classNameId, classPK);
1527            }
1528    
1529            /**
1530            * Returns a range of all the groups where classNameId = &#63; and classPK = &#63;.
1531            *
1532            * <p>
1533            * 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.
1534            * </p>
1535            *
1536            * @param classNameId the class name ID
1537            * @param classPK the class p k
1538            * @param start the lower bound of the range of groups
1539            * @param end the upper bound of the range of groups (not inclusive)
1540            * @return the range of matching groups
1541            */
1542            public static List<Group> findByC_CPK(long classNameId, long classPK,
1543                    int start, int end) {
1544                    return getPersistence().findByC_CPK(classNameId, classPK, start, end);
1545            }
1546    
1547            /**
1548            * Returns an ordered range of all the groups where classNameId = &#63; and classPK = &#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 classNameId the class name ID
1555            * @param classPK the class p k
1556            * @param start the lower bound of the range of groups
1557            * @param end the upper bound of the range of groups (not inclusive)
1558            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1559            * @return the ordered range of matching groups
1560            */
1561            public static List<Group> findByC_CPK(long classNameId, long classPK,
1562                    int start, int end, OrderByComparator<Group> orderByComparator) {
1563                    return getPersistence()
1564                                       .findByC_CPK(classNameId, classPK, start, end,
1565                            orderByComparator);
1566            }
1567    
1568            /**
1569            * Returns an ordered range of all the groups where classNameId = &#63; and classPK = &#63;.
1570            *
1571            * <p>
1572            * 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.
1573            * </p>
1574            *
1575            * @param classNameId the class name ID
1576            * @param classPK the class p k
1577            * @param start the lower bound of the range of groups
1578            * @param end the upper bound of the range of groups (not inclusive)
1579            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1580            * @param retrieveFromCache whether to retrieve from the finder cache
1581            * @return the ordered range of matching groups
1582            */
1583            public static List<Group> findByC_CPK(long classNameId, long classPK,
1584                    int start, int end, OrderByComparator<Group> orderByComparator,
1585                    boolean retrieveFromCache) {
1586                    return getPersistence()
1587                                       .findByC_CPK(classNameId, classPK, start, end,
1588                            orderByComparator, retrieveFromCache);
1589            }
1590    
1591            /**
1592            * Returns the first group in the ordered set where classNameId = &#63; and classPK = &#63;.
1593            *
1594            * @param classNameId the class name ID
1595            * @param classPK the class p k
1596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1597            * @return the first matching group
1598            * @throws NoSuchGroupException if a matching group could not be found
1599            */
1600            public static Group findByC_CPK_First(long classNameId, long classPK,
1601                    OrderByComparator<Group> orderByComparator)
1602                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1603                    return getPersistence()
1604                                       .findByC_CPK_First(classNameId, classPK, orderByComparator);
1605            }
1606    
1607            /**
1608            * Returns the first group in the ordered set where classNameId = &#63; and classPK = &#63;.
1609            *
1610            * @param classNameId the class name ID
1611            * @param classPK the class p k
1612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1613            * @return the first matching group, or <code>null</code> if a matching group could not be found
1614            */
1615            public static Group fetchByC_CPK_First(long classNameId, long classPK,
1616                    OrderByComparator<Group> orderByComparator) {
1617                    return getPersistence()
1618                                       .fetchByC_CPK_First(classNameId, classPK, orderByComparator);
1619            }
1620    
1621            /**
1622            * Returns the last group in the ordered set where classNameId = &#63; and classPK = &#63;.
1623            *
1624            * @param classNameId the class name ID
1625            * @param classPK the class p k
1626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1627            * @return the last matching group
1628            * @throws NoSuchGroupException if a matching group could not be found
1629            */
1630            public static Group findByC_CPK_Last(long classNameId, long classPK,
1631                    OrderByComparator<Group> orderByComparator)
1632                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1633                    return getPersistence()
1634                                       .findByC_CPK_Last(classNameId, classPK, orderByComparator);
1635            }
1636    
1637            /**
1638            * Returns the last group in the ordered set where classNameId = &#63; and classPK = &#63;.
1639            *
1640            * @param classNameId the class name ID
1641            * @param classPK the class p k
1642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1643            * @return the last matching group, or <code>null</code> if a matching group could not be found
1644            */
1645            public static Group fetchByC_CPK_Last(long classNameId, long classPK,
1646                    OrderByComparator<Group> orderByComparator) {
1647                    return getPersistence()
1648                                       .fetchByC_CPK_Last(classNameId, classPK, orderByComparator);
1649            }
1650    
1651            /**
1652            * Returns the groups before and after the current group in the ordered set where classNameId = &#63; and classPK = &#63;.
1653            *
1654            * @param groupId the primary key of the current group
1655            * @param classNameId the class name ID
1656            * @param classPK the class p k
1657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1658            * @return the previous, current, and next group
1659            * @throws NoSuchGroupException if a group with the primary key could not be found
1660            */
1661            public static Group[] findByC_CPK_PrevAndNext(long groupId,
1662                    long classNameId, long classPK,
1663                    OrderByComparator<Group> orderByComparator)
1664                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1665                    return getPersistence()
1666                                       .findByC_CPK_PrevAndNext(groupId, classNameId, classPK,
1667                            orderByComparator);
1668            }
1669    
1670            /**
1671            * Removes all the groups where classNameId = &#63; and classPK = &#63; from the database.
1672            *
1673            * @param classNameId the class name ID
1674            * @param classPK the class p k
1675            */
1676            public static void removeByC_CPK(long classNameId, long classPK) {
1677                    getPersistence().removeByC_CPK(classNameId, classPK);
1678            }
1679    
1680            /**
1681            * Returns the number of groups where classNameId = &#63; and classPK = &#63;.
1682            *
1683            * @param classNameId the class name ID
1684            * @param classPK the class p k
1685            * @return the number of matching groups
1686            */
1687            public static int countByC_CPK(long classNameId, long classPK) {
1688                    return getPersistence().countByC_CPK(classNameId, classPK);
1689            }
1690    
1691            /**
1692            * Returns all the groups where type = &#63; and active = &#63;.
1693            *
1694            * @param type the type
1695            * @param active the active
1696            * @return the matching groups
1697            */
1698            public static List<Group> findByT_A(int type, boolean active) {
1699                    return getPersistence().findByT_A(type, active);
1700            }
1701    
1702            /**
1703            * Returns a range of all the groups where type = &#63; and active = &#63;.
1704            *
1705            * <p>
1706            * 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.
1707            * </p>
1708            *
1709            * @param type the type
1710            * @param active the active
1711            * @param start the lower bound of the range of groups
1712            * @param end the upper bound of the range of groups (not inclusive)
1713            * @return the range of matching groups
1714            */
1715            public static List<Group> findByT_A(int type, boolean active, int start,
1716                    int end) {
1717                    return getPersistence().findByT_A(type, active, start, end);
1718            }
1719    
1720            /**
1721            * Returns an ordered range of all the groups where type = &#63; and active = &#63;.
1722            *
1723            * <p>
1724            * 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.
1725            * </p>
1726            *
1727            * @param type the type
1728            * @param active the active
1729            * @param start the lower bound of the range of groups
1730            * @param end the upper bound of the range of groups (not inclusive)
1731            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1732            * @return the ordered range of matching groups
1733            */
1734            public static List<Group> findByT_A(int type, boolean active, int start,
1735                    int end, OrderByComparator<Group> orderByComparator) {
1736                    return getPersistence()
1737                                       .findByT_A(type, active, start, end, orderByComparator);
1738            }
1739    
1740            /**
1741            * Returns an ordered range of all the groups where type = &#63; and active = &#63;.
1742            *
1743            * <p>
1744            * 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.
1745            * </p>
1746            *
1747            * @param type the type
1748            * @param active the active
1749            * @param start the lower bound of the range of groups
1750            * @param end the upper bound of the range of groups (not inclusive)
1751            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1752            * @param retrieveFromCache whether to retrieve from the finder cache
1753            * @return the ordered range of matching groups
1754            */
1755            public static List<Group> findByT_A(int type, boolean active, int start,
1756                    int end, OrderByComparator<Group> orderByComparator,
1757                    boolean retrieveFromCache) {
1758                    return getPersistence()
1759                                       .findByT_A(type, active, start, end, orderByComparator,
1760                            retrieveFromCache);
1761            }
1762    
1763            /**
1764            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1765            *
1766            * @param type the type
1767            * @param active the active
1768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1769            * @return the first matching group
1770            * @throws NoSuchGroupException if a matching group could not be found
1771            */
1772            public static Group findByT_A_First(int type, boolean active,
1773                    OrderByComparator<Group> orderByComparator)
1774                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1775                    return getPersistence().findByT_A_First(type, active, orderByComparator);
1776            }
1777    
1778            /**
1779            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1780            *
1781            * @param type the type
1782            * @param active the active
1783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1784            * @return the first matching group, or <code>null</code> if a matching group could not be found
1785            */
1786            public static Group fetchByT_A_First(int type, boolean active,
1787                    OrderByComparator<Group> orderByComparator) {
1788                    return getPersistence().fetchByT_A_First(type, active, orderByComparator);
1789            }
1790    
1791            /**
1792            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1793            *
1794            * @param type the type
1795            * @param active the active
1796            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1797            * @return the last matching group
1798            * @throws NoSuchGroupException if a matching group could not be found
1799            */
1800            public static Group findByT_A_Last(int type, boolean active,
1801                    OrderByComparator<Group> orderByComparator)
1802                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1803                    return getPersistence().findByT_A_Last(type, active, orderByComparator);
1804            }
1805    
1806            /**
1807            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1808            *
1809            * @param type the type
1810            * @param active the active
1811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1812            * @return the last matching group, or <code>null</code> if a matching group could not be found
1813            */
1814            public static Group fetchByT_A_Last(int type, boolean active,
1815                    OrderByComparator<Group> orderByComparator) {
1816                    return getPersistence().fetchByT_A_Last(type, active, orderByComparator);
1817            }
1818    
1819            /**
1820            * Returns the groups before and after the current group in the ordered set where type = &#63; and active = &#63;.
1821            *
1822            * @param groupId the primary key of the current group
1823            * @param type the type
1824            * @param active the active
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the previous, current, and next group
1827            * @throws NoSuchGroupException if a group with the primary key could not be found
1828            */
1829            public static Group[] findByT_A_PrevAndNext(long groupId, int type,
1830                    boolean active, OrderByComparator<Group> orderByComparator)
1831                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1832                    return getPersistence()
1833                                       .findByT_A_PrevAndNext(groupId, type, active,
1834                            orderByComparator);
1835            }
1836    
1837            /**
1838            * Removes all the groups where type = &#63; and active = &#63; from the database.
1839            *
1840            * @param type the type
1841            * @param active the active
1842            */
1843            public static void removeByT_A(int type, boolean active) {
1844                    getPersistence().removeByT_A(type, active);
1845            }
1846    
1847            /**
1848            * Returns the number of groups where type = &#63; and active = &#63;.
1849            *
1850            * @param type the type
1851            * @param active the active
1852            * @return the number of matching groups
1853            */
1854            public static int countByT_A(int type, boolean active) {
1855                    return getPersistence().countByT_A(type, active);
1856            }
1857    
1858            /**
1859            * Returns all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1860            *
1861            * @param groupId the group ID
1862            * @param companyId the company ID
1863            * @param parentGroupId the parent group ID
1864            * @return the matching groups
1865            */
1866            public static List<Group> findByG_C_P(long groupId, long companyId,
1867                    long parentGroupId) {
1868                    return getPersistence().findByG_C_P(groupId, companyId, parentGroupId);
1869            }
1870    
1871            /**
1872            * Returns a range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1873            *
1874            * <p>
1875            * 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.
1876            * </p>
1877            *
1878            * @param groupId the group ID
1879            * @param companyId the company ID
1880            * @param parentGroupId the parent group ID
1881            * @param start the lower bound of the range of groups
1882            * @param end the upper bound of the range of groups (not inclusive)
1883            * @return the range of matching groups
1884            */
1885            public static List<Group> findByG_C_P(long groupId, long companyId,
1886                    long parentGroupId, int start, int end) {
1887                    return getPersistence()
1888                                       .findByG_C_P(groupId, companyId, parentGroupId, start, end);
1889            }
1890    
1891            /**
1892            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1893            *
1894            * <p>
1895            * 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.
1896            * </p>
1897            *
1898            * @param groupId the group ID
1899            * @param companyId the company ID
1900            * @param parentGroupId the parent group ID
1901            * @param start the lower bound of the range of groups
1902            * @param end the upper bound of the range of groups (not inclusive)
1903            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1904            * @return the ordered range of matching groups
1905            */
1906            public static List<Group> findByG_C_P(long groupId, long companyId,
1907                    long parentGroupId, int start, int end,
1908                    OrderByComparator<Group> orderByComparator) {
1909                    return getPersistence()
1910                                       .findByG_C_P(groupId, companyId, parentGroupId, start, end,
1911                            orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1916            *
1917            * <p>
1918            * 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.
1919            * </p>
1920            *
1921            * @param groupId the group ID
1922            * @param companyId the company ID
1923            * @param parentGroupId the parent group ID
1924            * @param start the lower bound of the range of groups
1925            * @param end the upper bound of the range of groups (not inclusive)
1926            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1927            * @param retrieveFromCache whether to retrieve from the finder cache
1928            * @return the ordered range of matching groups
1929            */
1930            public static List<Group> findByG_C_P(long groupId, long companyId,
1931                    long parentGroupId, int start, int end,
1932                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
1933                    return getPersistence()
1934                                       .findByG_C_P(groupId, companyId, parentGroupId, start, end,
1935                            orderByComparator, retrieveFromCache);
1936            }
1937    
1938            /**
1939            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1940            *
1941            * @param groupId the group ID
1942            * @param companyId the company ID
1943            * @param parentGroupId the parent group ID
1944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1945            * @return the first matching group
1946            * @throws NoSuchGroupException if a matching group could not be found
1947            */
1948            public static Group findByG_C_P_First(long groupId, long companyId,
1949                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1950                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1951                    return getPersistence()
1952                                       .findByG_C_P_First(groupId, companyId, parentGroupId,
1953                            orderByComparator);
1954            }
1955    
1956            /**
1957            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1958            *
1959            * @param groupId the group ID
1960            * @param companyId the company ID
1961            * @param parentGroupId the parent group ID
1962            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1963            * @return the first matching group, or <code>null</code> if a matching group could not be found
1964            */
1965            public static Group fetchByG_C_P_First(long groupId, long companyId,
1966                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
1967                    return getPersistence()
1968                                       .fetchByG_C_P_First(groupId, companyId, parentGroupId,
1969                            orderByComparator);
1970            }
1971    
1972            /**
1973            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1974            *
1975            * @param groupId the group ID
1976            * @param companyId the company ID
1977            * @param parentGroupId the parent group ID
1978            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1979            * @return the last matching group
1980            * @throws NoSuchGroupException if a matching group could not be found
1981            */
1982            public static Group findByG_C_P_Last(long groupId, long companyId,
1983                    long parentGroupId, OrderByComparator<Group> orderByComparator)
1984                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
1985                    return getPersistence()
1986                                       .findByG_C_P_Last(groupId, companyId, parentGroupId,
1987                            orderByComparator);
1988            }
1989    
1990            /**
1991            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1992            *
1993            * @param groupId the group ID
1994            * @param companyId the company ID
1995            * @param parentGroupId the parent group ID
1996            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1997            * @return the last matching group, or <code>null</code> if a matching group could not be found
1998            */
1999            public static Group fetchByG_C_P_Last(long groupId, long companyId,
2000                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
2001                    return getPersistence()
2002                                       .fetchByG_C_P_Last(groupId, companyId, parentGroupId,
2003                            orderByComparator);
2004            }
2005    
2006            /**
2007            * Removes all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63; from the database.
2008            *
2009            * @param groupId the group ID
2010            * @param companyId the company ID
2011            * @param parentGroupId the parent group ID
2012            */
2013            public static void removeByG_C_P(long groupId, long companyId,
2014                    long parentGroupId) {
2015                    getPersistence().removeByG_C_P(groupId, companyId, parentGroupId);
2016            }
2017    
2018            /**
2019            * Returns the number of groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
2020            *
2021            * @param groupId the group ID
2022            * @param companyId the company ID
2023            * @param parentGroupId the parent group ID
2024            * @return the number of matching groups
2025            */
2026            public static int countByG_C_P(long groupId, long companyId,
2027                    long parentGroupId) {
2028                    return getPersistence().countByG_C_P(groupId, companyId, parentGroupId);
2029            }
2030    
2031            /**
2032            * Returns the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
2033            *
2034            * @param companyId the company ID
2035            * @param classNameId the class name ID
2036            * @param classPK the class p k
2037            * @return the matching group
2038            * @throws NoSuchGroupException if a matching group could not be found
2039            */
2040            public static Group findByC_C_C(long companyId, long classNameId,
2041                    long classPK)
2042                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2043                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
2044            }
2045    
2046            /**
2047            * 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.
2048            *
2049            * @param companyId the company ID
2050            * @param classNameId the class name ID
2051            * @param classPK the class p k
2052            * @return the matching group, or <code>null</code> if a matching group could not be found
2053            */
2054            public static Group fetchByC_C_C(long companyId, long classNameId,
2055                    long classPK) {
2056                    return getPersistence().fetchByC_C_C(companyId, classNameId, classPK);
2057            }
2058    
2059            /**
2060            * 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.
2061            *
2062            * @param companyId the company ID
2063            * @param classNameId the class name ID
2064            * @param classPK the class p k
2065            * @param retrieveFromCache whether to retrieve from the finder cache
2066            * @return the matching group, or <code>null</code> if a matching group could not be found
2067            */
2068            public static Group fetchByC_C_C(long companyId, long classNameId,
2069                    long classPK, boolean retrieveFromCache) {
2070                    return getPersistence()
2071                                       .fetchByC_C_C(companyId, classNameId, classPK,
2072                            retrieveFromCache);
2073            }
2074    
2075            /**
2076            * Removes the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
2077            *
2078            * @param companyId the company ID
2079            * @param classNameId the class name ID
2080            * @param classPK the class p k
2081            * @return the group that was removed
2082            */
2083            public static Group removeByC_C_C(long companyId, long classNameId,
2084                    long classPK)
2085                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2086                    return getPersistence().removeByC_C_C(companyId, classNameId, classPK);
2087            }
2088    
2089            /**
2090            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
2091            *
2092            * @param companyId the company ID
2093            * @param classNameId the class name ID
2094            * @param classPK the class p k
2095            * @return the number of matching groups
2096            */
2097            public static int countByC_C_C(long companyId, long classNameId,
2098                    long classPK) {
2099                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
2100            }
2101    
2102            /**
2103            * Returns all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2104            *
2105            * @param companyId the company ID
2106            * @param classNameId the class name ID
2107            * @param parentGroupId the parent group ID
2108            * @return the matching groups
2109            */
2110            public static List<Group> findByC_C_P(long companyId, long classNameId,
2111                    long parentGroupId) {
2112                    return getPersistence()
2113                                       .findByC_C_P(companyId, classNameId, parentGroupId);
2114            }
2115    
2116            /**
2117            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2118            *
2119            * <p>
2120            * 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.
2121            * </p>
2122            *
2123            * @param companyId the company ID
2124            * @param classNameId the class name ID
2125            * @param parentGroupId the parent group ID
2126            * @param start the lower bound of the range of groups
2127            * @param end the upper bound of the range of groups (not inclusive)
2128            * @return the range of matching groups
2129            */
2130            public static List<Group> findByC_C_P(long companyId, long classNameId,
2131                    long parentGroupId, int start, int end) {
2132                    return getPersistence()
2133                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
2134                            end);
2135            }
2136    
2137            /**
2138            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2139            *
2140            * <p>
2141            * 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.
2142            * </p>
2143            *
2144            * @param companyId the company ID
2145            * @param classNameId the class name ID
2146            * @param parentGroupId the parent group ID
2147            * @param start the lower bound of the range of groups
2148            * @param end the upper bound of the range of groups (not inclusive)
2149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2150            * @return the ordered range of matching groups
2151            */
2152            public static List<Group> findByC_C_P(long companyId, long classNameId,
2153                    long parentGroupId, int start, int end,
2154                    OrderByComparator<Group> orderByComparator) {
2155                    return getPersistence()
2156                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
2157                            end, orderByComparator);
2158            }
2159    
2160            /**
2161            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2162            *
2163            * <p>
2164            * 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.
2165            * </p>
2166            *
2167            * @param companyId the company ID
2168            * @param classNameId the class name ID
2169            * @param parentGroupId the parent group ID
2170            * @param start the lower bound of the range of groups
2171            * @param end the upper bound of the range of groups (not inclusive)
2172            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2173            * @param retrieveFromCache whether to retrieve from the finder cache
2174            * @return the ordered range of matching groups
2175            */
2176            public static List<Group> findByC_C_P(long companyId, long classNameId,
2177                    long parentGroupId, int start, int end,
2178                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2179                    return getPersistence()
2180                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
2181                            end, orderByComparator, retrieveFromCache);
2182            }
2183    
2184            /**
2185            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2186            *
2187            * @param companyId the company ID
2188            * @param classNameId the class name ID
2189            * @param parentGroupId the parent group ID
2190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2191            * @return the first matching group
2192            * @throws NoSuchGroupException if a matching group could not be found
2193            */
2194            public static Group findByC_C_P_First(long companyId, long classNameId,
2195                    long parentGroupId, OrderByComparator<Group> orderByComparator)
2196                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2197                    return getPersistence()
2198                                       .findByC_C_P_First(companyId, classNameId, parentGroupId,
2199                            orderByComparator);
2200            }
2201    
2202            /**
2203            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2204            *
2205            * @param companyId the company ID
2206            * @param classNameId the class name ID
2207            * @param parentGroupId the parent group ID
2208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2209            * @return the first matching group, or <code>null</code> if a matching group could not be found
2210            */
2211            public static Group fetchByC_C_P_First(long companyId, long classNameId,
2212                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
2213                    return getPersistence()
2214                                       .fetchByC_C_P_First(companyId, classNameId, parentGroupId,
2215                            orderByComparator);
2216            }
2217    
2218            /**
2219            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2220            *
2221            * @param companyId the company ID
2222            * @param classNameId the class name ID
2223            * @param parentGroupId the parent group ID
2224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2225            * @return the last matching group
2226            * @throws NoSuchGroupException if a matching group could not be found
2227            */
2228            public static Group findByC_C_P_Last(long companyId, long classNameId,
2229                    long parentGroupId, OrderByComparator<Group> orderByComparator)
2230                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2231                    return getPersistence()
2232                                       .findByC_C_P_Last(companyId, classNameId, parentGroupId,
2233                            orderByComparator);
2234            }
2235    
2236            /**
2237            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2238            *
2239            * @param companyId the company ID
2240            * @param classNameId the class name ID
2241            * @param parentGroupId the parent group ID
2242            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2243            * @return the last matching group, or <code>null</code> if a matching group could not be found
2244            */
2245            public static Group fetchByC_C_P_Last(long companyId, long classNameId,
2246                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
2247                    return getPersistence()
2248                                       .fetchByC_C_P_Last(companyId, classNameId, parentGroupId,
2249                            orderByComparator);
2250            }
2251    
2252            /**
2253            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2254            *
2255            * @param groupId the primary key of the current group
2256            * @param companyId the company ID
2257            * @param classNameId the class name ID
2258            * @param parentGroupId the parent group ID
2259            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2260            * @return the previous, current, and next group
2261            * @throws NoSuchGroupException if a group with the primary key could not be found
2262            */
2263            public static Group[] findByC_C_P_PrevAndNext(long groupId, long companyId,
2264                    long classNameId, long parentGroupId,
2265                    OrderByComparator<Group> orderByComparator)
2266                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2267                    return getPersistence()
2268                                       .findByC_C_P_PrevAndNext(groupId, companyId, classNameId,
2269                            parentGroupId, orderByComparator);
2270            }
2271    
2272            /**
2273            * Removes all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
2274            *
2275            * @param companyId the company ID
2276            * @param classNameId the class name ID
2277            * @param parentGroupId the parent group ID
2278            */
2279            public static void removeByC_C_P(long companyId, long classNameId,
2280                    long parentGroupId) {
2281                    getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId);
2282            }
2283    
2284            /**
2285            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2286            *
2287            * @param companyId the company ID
2288            * @param classNameId the class name ID
2289            * @param parentGroupId the parent group ID
2290            * @return the number of matching groups
2291            */
2292            public static int countByC_C_P(long companyId, long classNameId,
2293                    long parentGroupId) {
2294                    return getPersistence()
2295                                       .countByC_C_P(companyId, classNameId, parentGroupId);
2296            }
2297    
2298            /**
2299            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2300            *
2301            * @param companyId the company ID
2302            * @param parentGroupId the parent group ID
2303            * @param site the site
2304            * @return the matching groups
2305            */
2306            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2307                    boolean site) {
2308                    return getPersistence().findByC_P_S(companyId, parentGroupId, site);
2309            }
2310    
2311            /**
2312            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2313            *
2314            * <p>
2315            * 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.
2316            * </p>
2317            *
2318            * @param companyId the company ID
2319            * @param parentGroupId the parent group ID
2320            * @param site the site
2321            * @param start the lower bound of the range of groups
2322            * @param end the upper bound of the range of groups (not inclusive)
2323            * @return the range of matching groups
2324            */
2325            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2326                    boolean site, int start, int end) {
2327                    return getPersistence()
2328                                       .findByC_P_S(companyId, parentGroupId, site, start, end);
2329            }
2330    
2331            /**
2332            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2333            *
2334            * <p>
2335            * 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.
2336            * </p>
2337            *
2338            * @param companyId the company ID
2339            * @param parentGroupId the parent group ID
2340            * @param site the site
2341            * @param start the lower bound of the range of groups
2342            * @param end the upper bound of the range of groups (not inclusive)
2343            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2344            * @return the ordered range of matching groups
2345            */
2346            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2347                    boolean site, int start, int end,
2348                    OrderByComparator<Group> orderByComparator) {
2349                    return getPersistence()
2350                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
2351                            orderByComparator);
2352            }
2353    
2354            /**
2355            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2356            *
2357            * <p>
2358            * 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.
2359            * </p>
2360            *
2361            * @param companyId the company ID
2362            * @param parentGroupId the parent group ID
2363            * @param site the site
2364            * @param start the lower bound of the range of groups
2365            * @param end the upper bound of the range of groups (not inclusive)
2366            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2367            * @param retrieveFromCache whether to retrieve from the finder cache
2368            * @return the ordered range of matching groups
2369            */
2370            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2371                    boolean site, int start, int end,
2372                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2373                    return getPersistence()
2374                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
2375                            orderByComparator, retrieveFromCache);
2376            }
2377    
2378            /**
2379            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2380            *
2381            * @param companyId the company ID
2382            * @param parentGroupId the parent group ID
2383            * @param site the site
2384            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2385            * @return the first matching group
2386            * @throws NoSuchGroupException if a matching group could not be found
2387            */
2388            public static Group findByC_P_S_First(long companyId, long parentGroupId,
2389                    boolean site, OrderByComparator<Group> orderByComparator)
2390                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2391                    return getPersistence()
2392                                       .findByC_P_S_First(companyId, parentGroupId, site,
2393                            orderByComparator);
2394            }
2395    
2396            /**
2397            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2398            *
2399            * @param companyId the company ID
2400            * @param parentGroupId the parent group ID
2401            * @param site the site
2402            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2403            * @return the first matching group, or <code>null</code> if a matching group could not be found
2404            */
2405            public static Group fetchByC_P_S_First(long companyId, long parentGroupId,
2406                    boolean site, OrderByComparator<Group> orderByComparator) {
2407                    return getPersistence()
2408                                       .fetchByC_P_S_First(companyId, parentGroupId, site,
2409                            orderByComparator);
2410            }
2411    
2412            /**
2413            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2414            *
2415            * @param companyId the company ID
2416            * @param parentGroupId the parent group ID
2417            * @param site the site
2418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2419            * @return the last matching group
2420            * @throws NoSuchGroupException if a matching group could not be found
2421            */
2422            public static Group findByC_P_S_Last(long companyId, long parentGroupId,
2423                    boolean site, OrderByComparator<Group> orderByComparator)
2424                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2425                    return getPersistence()
2426                                       .findByC_P_S_Last(companyId, parentGroupId, site,
2427                            orderByComparator);
2428            }
2429    
2430            /**
2431            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2432            *
2433            * @param companyId the company ID
2434            * @param parentGroupId the parent group ID
2435            * @param site the site
2436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2437            * @return the last matching group, or <code>null</code> if a matching group could not be found
2438            */
2439            public static Group fetchByC_P_S_Last(long companyId, long parentGroupId,
2440                    boolean site, OrderByComparator<Group> orderByComparator) {
2441                    return getPersistence()
2442                                       .fetchByC_P_S_Last(companyId, parentGroupId, site,
2443                            orderByComparator);
2444            }
2445    
2446            /**
2447            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2448            *
2449            * @param groupId the primary key of the current group
2450            * @param companyId the company ID
2451            * @param parentGroupId the parent group ID
2452            * @param site the site
2453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2454            * @return the previous, current, and next group
2455            * @throws NoSuchGroupException if a group with the primary key could not be found
2456            */
2457            public static Group[] findByC_P_S_PrevAndNext(long groupId, long companyId,
2458                    long parentGroupId, boolean site,
2459                    OrderByComparator<Group> orderByComparator)
2460                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2461                    return getPersistence()
2462                                       .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId,
2463                            site, orderByComparator);
2464            }
2465    
2466            /**
2467            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; from the database.
2468            *
2469            * @param companyId the company ID
2470            * @param parentGroupId the parent group ID
2471            * @param site the site
2472            */
2473            public static void removeByC_P_S(long companyId, long parentGroupId,
2474                    boolean site) {
2475                    getPersistence().removeByC_P_S(companyId, parentGroupId, site);
2476            }
2477    
2478            /**
2479            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2480            *
2481            * @param companyId the company ID
2482            * @param parentGroupId the parent group ID
2483            * @param site the site
2484            * @return the number of matching groups
2485            */
2486            public static int countByC_P_S(long companyId, long parentGroupId,
2487                    boolean site) {
2488                    return getPersistence().countByC_P_S(companyId, parentGroupId, site);
2489            }
2490    
2491            /**
2492            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
2493            *
2494            * @param companyId the company ID
2495            * @param liveGroupId the live group ID
2496            * @param groupKey the group key
2497            * @return the matching group
2498            * @throws NoSuchGroupException if a matching group could not be found
2499            */
2500            public static Group findByC_L_GK(long companyId, long liveGroupId,
2501                    java.lang.String groupKey)
2502                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2503                    return getPersistence().findByC_L_GK(companyId, liveGroupId, groupKey);
2504            }
2505    
2506            /**
2507            * 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.
2508            *
2509            * @param companyId the company ID
2510            * @param liveGroupId the live group ID
2511            * @param groupKey the group key
2512            * @return the matching group, or <code>null</code> if a matching group could not be found
2513            */
2514            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
2515                    java.lang.String groupKey) {
2516                    return getPersistence().fetchByC_L_GK(companyId, liveGroupId, groupKey);
2517            }
2518    
2519            /**
2520            * 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.
2521            *
2522            * @param companyId the company ID
2523            * @param liveGroupId the live group ID
2524            * @param groupKey the group key
2525            * @param retrieveFromCache whether to retrieve from the finder cache
2526            * @return the matching group, or <code>null</code> if a matching group could not be found
2527            */
2528            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
2529                    java.lang.String groupKey, boolean retrieveFromCache) {
2530                    return getPersistence()
2531                                       .fetchByC_L_GK(companyId, liveGroupId, groupKey,
2532                            retrieveFromCache);
2533            }
2534    
2535            /**
2536            * Removes the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
2537            *
2538            * @param companyId the company ID
2539            * @param liveGroupId the live group ID
2540            * @param groupKey the group key
2541            * @return the group that was removed
2542            */
2543            public static Group removeByC_L_GK(long companyId, long liveGroupId,
2544                    java.lang.String groupKey)
2545                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2546                    return getPersistence().removeByC_L_GK(companyId, liveGroupId, groupKey);
2547            }
2548    
2549            /**
2550            * Returns the number of groups where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
2551            *
2552            * @param companyId the company ID
2553            * @param liveGroupId the live group ID
2554            * @param groupKey the group key
2555            * @return the number of matching groups
2556            */
2557            public static int countByC_L_GK(long companyId, long liveGroupId,
2558                    java.lang.String groupKey) {
2559                    return getPersistence().countByC_L_GK(companyId, liveGroupId, groupKey);
2560            }
2561    
2562            /**
2563            * Returns all the groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2564            *
2565            * @param groupId the group ID
2566            * @param companyId the company ID
2567            * @param classNameId the class name ID
2568            * @param parentGroupId the parent group ID
2569            * @return the matching groups
2570            */
2571            public static List<Group> findByG_C_C_P(long groupId, long companyId,
2572                    long classNameId, long parentGroupId) {
2573                    return getPersistence()
2574                                       .findByG_C_C_P(groupId, companyId, classNameId, parentGroupId);
2575            }
2576    
2577            /**
2578            * Returns a range of all the groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2579            *
2580            * <p>
2581            * 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.
2582            * </p>
2583            *
2584            * @param groupId the group ID
2585            * @param companyId the company ID
2586            * @param classNameId the class name ID
2587            * @param parentGroupId the parent group ID
2588            * @param start the lower bound of the range of groups
2589            * @param end the upper bound of the range of groups (not inclusive)
2590            * @return the range of matching groups
2591            */
2592            public static List<Group> findByG_C_C_P(long groupId, long companyId,
2593                    long classNameId, long parentGroupId, int start, int end) {
2594                    return getPersistence()
2595                                       .findByG_C_C_P(groupId, companyId, classNameId,
2596                            parentGroupId, start, end);
2597            }
2598    
2599            /**
2600            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2601            *
2602            * <p>
2603            * 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.
2604            * </p>
2605            *
2606            * @param groupId the group ID
2607            * @param companyId the company ID
2608            * @param classNameId the class name ID
2609            * @param parentGroupId the parent group ID
2610            * @param start the lower bound of the range of groups
2611            * @param end the upper bound of the range of groups (not inclusive)
2612            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2613            * @return the ordered range of matching groups
2614            */
2615            public static List<Group> findByG_C_C_P(long groupId, long companyId,
2616                    long classNameId, long parentGroupId, int start, int end,
2617                    OrderByComparator<Group> orderByComparator) {
2618                    return getPersistence()
2619                                       .findByG_C_C_P(groupId, companyId, classNameId,
2620                            parentGroupId, start, end, orderByComparator);
2621            }
2622    
2623            /**
2624            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2625            *
2626            * <p>
2627            * 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.
2628            * </p>
2629            *
2630            * @param groupId the group ID
2631            * @param companyId the company ID
2632            * @param classNameId the class name ID
2633            * @param parentGroupId the parent group ID
2634            * @param start the lower bound of the range of groups
2635            * @param end the upper bound of the range of groups (not inclusive)
2636            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2637            * @param retrieveFromCache whether to retrieve from the finder cache
2638            * @return the ordered range of matching groups
2639            */
2640            public static List<Group> findByG_C_C_P(long groupId, long companyId,
2641                    long classNameId, long parentGroupId, int start, int end,
2642                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2643                    return getPersistence()
2644                                       .findByG_C_C_P(groupId, companyId, classNameId,
2645                            parentGroupId, start, end, orderByComparator, retrieveFromCache);
2646            }
2647    
2648            /**
2649            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2650            *
2651            * @param groupId the group ID
2652            * @param companyId the company ID
2653            * @param classNameId the class name ID
2654            * @param parentGroupId the parent group ID
2655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2656            * @return the first matching group
2657            * @throws NoSuchGroupException if a matching group could not be found
2658            */
2659            public static Group findByG_C_C_P_First(long groupId, long companyId,
2660                    long classNameId, long parentGroupId,
2661                    OrderByComparator<Group> orderByComparator)
2662                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2663                    return getPersistence()
2664                                       .findByG_C_C_P_First(groupId, companyId, classNameId,
2665                            parentGroupId, orderByComparator);
2666            }
2667    
2668            /**
2669            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2670            *
2671            * @param groupId the group ID
2672            * @param companyId the company ID
2673            * @param classNameId the class name ID
2674            * @param parentGroupId the parent group ID
2675            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2676            * @return the first matching group, or <code>null</code> if a matching group could not be found
2677            */
2678            public static Group fetchByG_C_C_P_First(long groupId, long companyId,
2679                    long classNameId, long parentGroupId,
2680                    OrderByComparator<Group> orderByComparator) {
2681                    return getPersistence()
2682                                       .fetchByG_C_C_P_First(groupId, companyId, classNameId,
2683                            parentGroupId, orderByComparator);
2684            }
2685    
2686            /**
2687            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2688            *
2689            * @param groupId the group ID
2690            * @param companyId the company ID
2691            * @param classNameId the class name ID
2692            * @param parentGroupId the parent group ID
2693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2694            * @return the last matching group
2695            * @throws NoSuchGroupException if a matching group could not be found
2696            */
2697            public static Group findByG_C_C_P_Last(long groupId, long companyId,
2698                    long classNameId, long parentGroupId,
2699                    OrderByComparator<Group> orderByComparator)
2700                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2701                    return getPersistence()
2702                                       .findByG_C_C_P_Last(groupId, companyId, classNameId,
2703                            parentGroupId, orderByComparator);
2704            }
2705    
2706            /**
2707            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2708            *
2709            * @param groupId the group ID
2710            * @param companyId the company ID
2711            * @param classNameId the class name ID
2712            * @param parentGroupId the parent group ID
2713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2714            * @return the last matching group, or <code>null</code> if a matching group could not be found
2715            */
2716            public static Group fetchByG_C_C_P_Last(long groupId, long companyId,
2717                    long classNameId, long parentGroupId,
2718                    OrderByComparator<Group> orderByComparator) {
2719                    return getPersistence()
2720                                       .fetchByG_C_C_P_Last(groupId, companyId, classNameId,
2721                            parentGroupId, orderByComparator);
2722            }
2723    
2724            /**
2725            * Removes all the groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
2726            *
2727            * @param groupId the group ID
2728            * @param companyId the company ID
2729            * @param classNameId the class name ID
2730            * @param parentGroupId the parent group ID
2731            */
2732            public static void removeByG_C_C_P(long groupId, long companyId,
2733                    long classNameId, long parentGroupId) {
2734                    getPersistence()
2735                            .removeByG_C_C_P(groupId, companyId, classNameId, parentGroupId);
2736            }
2737    
2738            /**
2739            * Returns the number of groups where groupId &gt; &#63; and companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2740            *
2741            * @param groupId the group ID
2742            * @param companyId the company ID
2743            * @param classNameId the class name ID
2744            * @param parentGroupId the parent group ID
2745            * @return the number of matching groups
2746            */
2747            public static int countByG_C_C_P(long groupId, long companyId,
2748                    long classNameId, long parentGroupId) {
2749                    return getPersistence()
2750                                       .countByG_C_C_P(groupId, companyId, classNameId,
2751                            parentGroupId);
2752            }
2753    
2754            /**
2755            * 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.
2756            *
2757            * @param companyId the company ID
2758            * @param classNameId the class name ID
2759            * @param liveGroupId the live group ID
2760            * @param groupKey the group key
2761            * @return the matching group
2762            * @throws NoSuchGroupException if a matching group could not be found
2763            */
2764            public static Group findByC_C_L_GK(long companyId, long classNameId,
2765                    long liveGroupId, java.lang.String groupKey)
2766                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2767                    return getPersistence()
2768                                       .findByC_C_L_GK(companyId, classNameId, liveGroupId, groupKey);
2769            }
2770    
2771            /**
2772            * 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.
2773            *
2774            * @param companyId the company ID
2775            * @param classNameId the class name ID
2776            * @param liveGroupId the live group ID
2777            * @param groupKey the group key
2778            * @return the matching group, or <code>null</code> if a matching group could not be found
2779            */
2780            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2781                    long liveGroupId, java.lang.String groupKey) {
2782                    return getPersistence()
2783                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2784                            groupKey);
2785            }
2786    
2787            /**
2788            * 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.
2789            *
2790            * @param companyId the company ID
2791            * @param classNameId the class name ID
2792            * @param liveGroupId the live group ID
2793            * @param groupKey the group key
2794            * @param retrieveFromCache whether to retrieve from the finder cache
2795            * @return the matching group, or <code>null</code> if a matching group could not be found
2796            */
2797            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2798                    long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache) {
2799                    return getPersistence()
2800                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2801                            groupKey, retrieveFromCache);
2802            }
2803    
2804            /**
2805            * Removes the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
2806            *
2807            * @param companyId the company ID
2808            * @param classNameId the class name ID
2809            * @param liveGroupId the live group ID
2810            * @param groupKey the group key
2811            * @return the group that was removed
2812            */
2813            public static Group removeByC_C_L_GK(long companyId, long classNameId,
2814                    long liveGroupId, java.lang.String groupKey)
2815                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2816                    return getPersistence()
2817                                       .removeByC_C_L_GK(companyId, classNameId, liveGroupId,
2818                            groupKey);
2819            }
2820    
2821            /**
2822            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
2823            *
2824            * @param companyId the company ID
2825            * @param classNameId the class name ID
2826            * @param liveGroupId the live group ID
2827            * @param groupKey the group key
2828            * @return the number of matching groups
2829            */
2830            public static int countByC_C_L_GK(long companyId, long classNameId,
2831                    long liveGroupId, java.lang.String groupKey) {
2832                    return getPersistence()
2833                                       .countByC_C_L_GK(companyId, classNameId, liveGroupId,
2834                            groupKey);
2835            }
2836    
2837            /**
2838            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2839            *
2840            * @param companyId the company ID
2841            * @param parentGroupId the parent group ID
2842            * @param site the site
2843            * @param inheritContent the inherit content
2844            * @return the matching groups
2845            */
2846            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2847                    boolean site, boolean inheritContent) {
2848                    return getPersistence()
2849                                       .findByC_P_S_I(companyId, parentGroupId, site, inheritContent);
2850            }
2851    
2852            /**
2853            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2854            *
2855            * <p>
2856            * 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.
2857            * </p>
2858            *
2859            * @param companyId the company ID
2860            * @param parentGroupId the parent group ID
2861            * @param site the site
2862            * @param inheritContent the inherit content
2863            * @param start the lower bound of the range of groups
2864            * @param end the upper bound of the range of groups (not inclusive)
2865            * @return the range of matching groups
2866            */
2867            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2868                    boolean site, boolean inheritContent, int start, int end) {
2869                    return getPersistence()
2870                                       .findByC_P_S_I(companyId, parentGroupId, site,
2871                            inheritContent, start, end);
2872            }
2873    
2874            /**
2875            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2876            *
2877            * <p>
2878            * 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.
2879            * </p>
2880            *
2881            * @param companyId the company ID
2882            * @param parentGroupId the parent group ID
2883            * @param site the site
2884            * @param inheritContent the inherit content
2885            * @param start the lower bound of the range of groups
2886            * @param end the upper bound of the range of groups (not inclusive)
2887            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2888            * @return the ordered range of matching groups
2889            */
2890            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2891                    boolean site, boolean inheritContent, int start, int end,
2892                    OrderByComparator<Group> orderByComparator) {
2893                    return getPersistence()
2894                                       .findByC_P_S_I(companyId, parentGroupId, site,
2895                            inheritContent, start, end, orderByComparator);
2896            }
2897    
2898            /**
2899            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2900            *
2901            * <p>
2902            * 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.
2903            * </p>
2904            *
2905            * @param companyId the company ID
2906            * @param parentGroupId the parent group ID
2907            * @param site the site
2908            * @param inheritContent the inherit content
2909            * @param start the lower bound of the range of groups
2910            * @param end the upper bound of the range of groups (not inclusive)
2911            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2912            * @param retrieveFromCache whether to retrieve from the finder cache
2913            * @return the ordered range of matching groups
2914            */
2915            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2916                    boolean site, boolean inheritContent, int start, int end,
2917                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2918                    return getPersistence()
2919                                       .findByC_P_S_I(companyId, parentGroupId, site,
2920                            inheritContent, start, end, orderByComparator, retrieveFromCache);
2921            }
2922    
2923            /**
2924            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2925            *
2926            * @param companyId the company ID
2927            * @param parentGroupId the parent group ID
2928            * @param site the site
2929            * @param inheritContent the inherit content
2930            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2931            * @return the first matching group
2932            * @throws NoSuchGroupException if a matching group could not be found
2933            */
2934            public static Group findByC_P_S_I_First(long companyId, long parentGroupId,
2935                    boolean site, boolean inheritContent,
2936                    OrderByComparator<Group> orderByComparator)
2937                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2938                    return getPersistence()
2939                                       .findByC_P_S_I_First(companyId, parentGroupId, site,
2940                            inheritContent, orderByComparator);
2941            }
2942    
2943            /**
2944            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2945            *
2946            * @param companyId the company ID
2947            * @param parentGroupId the parent group ID
2948            * @param site the site
2949            * @param inheritContent the inherit content
2950            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2951            * @return the first matching group, or <code>null</code> if a matching group could not be found
2952            */
2953            public static Group fetchByC_P_S_I_First(long companyId,
2954                    long parentGroupId, boolean site, boolean inheritContent,
2955                    OrderByComparator<Group> orderByComparator) {
2956                    return getPersistence()
2957                                       .fetchByC_P_S_I_First(companyId, parentGroupId, site,
2958                            inheritContent, orderByComparator);
2959            }
2960    
2961            /**
2962            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2963            *
2964            * @param companyId the company ID
2965            * @param parentGroupId the parent group ID
2966            * @param site the site
2967            * @param inheritContent the inherit content
2968            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2969            * @return the last matching group
2970            * @throws NoSuchGroupException if a matching group could not be found
2971            */
2972            public static Group findByC_P_S_I_Last(long companyId, long parentGroupId,
2973                    boolean site, boolean inheritContent,
2974                    OrderByComparator<Group> orderByComparator)
2975                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
2976                    return getPersistence()
2977                                       .findByC_P_S_I_Last(companyId, parentGroupId, site,
2978                            inheritContent, orderByComparator);
2979            }
2980    
2981            /**
2982            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2983            *
2984            * @param companyId the company ID
2985            * @param parentGroupId the parent group ID
2986            * @param site the site
2987            * @param inheritContent the inherit content
2988            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2989            * @return the last matching group, or <code>null</code> if a matching group could not be found
2990            */
2991            public static Group fetchByC_P_S_I_Last(long companyId, long parentGroupId,
2992                    boolean site, boolean inheritContent,
2993                    OrderByComparator<Group> orderByComparator) {
2994                    return getPersistence()
2995                                       .fetchByC_P_S_I_Last(companyId, parentGroupId, site,
2996                            inheritContent, orderByComparator);
2997            }
2998    
2999            /**
3000            * 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;.
3001            *
3002            * @param groupId the primary key of the current group
3003            * @param companyId the company ID
3004            * @param parentGroupId the parent group ID
3005            * @param site the site
3006            * @param inheritContent the inherit content
3007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3008            * @return the previous, current, and next group
3009            * @throws NoSuchGroupException if a group with the primary key could not be found
3010            */
3011            public static Group[] findByC_P_S_I_PrevAndNext(long groupId,
3012                    long companyId, long parentGroupId, boolean site,
3013                    boolean inheritContent, OrderByComparator<Group> orderByComparator)
3014                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
3015                    return getPersistence()
3016                                       .findByC_P_S_I_PrevAndNext(groupId, companyId,
3017                            parentGroupId, site, inheritContent, orderByComparator);
3018            }
3019    
3020            /**
3021            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63; from the database.
3022            *
3023            * @param companyId the company ID
3024            * @param parentGroupId the parent group ID
3025            * @param site the site
3026            * @param inheritContent the inherit content
3027            */
3028            public static void removeByC_P_S_I(long companyId, long parentGroupId,
3029                    boolean site, boolean inheritContent) {
3030                    getPersistence()
3031                            .removeByC_P_S_I(companyId, parentGroupId, site, inheritContent);
3032            }
3033    
3034            /**
3035            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
3036            *
3037            * @param companyId the company ID
3038            * @param parentGroupId the parent group ID
3039            * @param site the site
3040            * @param inheritContent the inherit content
3041            * @return the number of matching groups
3042            */
3043            public static int countByC_P_S_I(long companyId, long parentGroupId,
3044                    boolean site, boolean inheritContent) {
3045                    return getPersistence()
3046                                       .countByC_P_S_I(companyId, parentGroupId, site,
3047                            inheritContent);
3048            }
3049    
3050            /**
3051            * Caches the group in the entity cache if it is enabled.
3052            *
3053            * @param group the group
3054            */
3055            public static void cacheResult(Group group) {
3056                    getPersistence().cacheResult(group);
3057            }
3058    
3059            /**
3060            * Caches the groups in the entity cache if it is enabled.
3061            *
3062            * @param groups the groups
3063            */
3064            public static void cacheResult(List<Group> groups) {
3065                    getPersistence().cacheResult(groups);
3066            }
3067    
3068            /**
3069            * Creates a new group with the primary key. Does not add the group to the database.
3070            *
3071            * @param groupId the primary key for the new group
3072            * @return the new group
3073            */
3074            public static Group create(long groupId) {
3075                    return getPersistence().create(groupId);
3076            }
3077    
3078            /**
3079            * Removes the group with the primary key from the database. Also notifies the appropriate model listeners.
3080            *
3081            * @param groupId the primary key of the group
3082            * @return the group that was removed
3083            * @throws NoSuchGroupException if a group with the primary key could not be found
3084            */
3085            public static Group remove(long groupId)
3086                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
3087                    return getPersistence().remove(groupId);
3088            }
3089    
3090            public static Group updateImpl(Group group) {
3091                    return getPersistence().updateImpl(group);
3092            }
3093    
3094            /**
3095            * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found.
3096            *
3097            * @param groupId the primary key of the group
3098            * @return the group
3099            * @throws NoSuchGroupException if a group with the primary key could not be found
3100            */
3101            public static Group findByPrimaryKey(long groupId)
3102                    throws com.liferay.portal.kernel.exception.NoSuchGroupException {
3103                    return getPersistence().findByPrimaryKey(groupId);
3104            }
3105    
3106            /**
3107            * Returns the group with the primary key or returns <code>null</code> if it could not be found.
3108            *
3109            * @param groupId the primary key of the group
3110            * @return the group, or <code>null</code> if a group with the primary key could not be found
3111            */
3112            public static Group fetchByPrimaryKey(long groupId) {
3113                    return getPersistence().fetchByPrimaryKey(groupId);
3114            }
3115    
3116            public static java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys(
3117                    java.util.Set<java.io.Serializable> primaryKeys) {
3118                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
3119            }
3120    
3121            /**
3122            * Returns all the groups.
3123            *
3124            * @return the groups
3125            */
3126            public static List<Group> findAll() {
3127                    return getPersistence().findAll();
3128            }
3129    
3130            /**
3131            * Returns a range of all the groups.
3132            *
3133            * <p>
3134            * 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.
3135            * </p>
3136            *
3137            * @param start the lower bound of the range of groups
3138            * @param end the upper bound of the range of groups (not inclusive)
3139            * @return the range of groups
3140            */
3141            public static List<Group> findAll(int start, int end) {
3142                    return getPersistence().findAll(start, end);
3143            }
3144    
3145            /**
3146            * Returns an ordered range of all the groups.
3147            *
3148            * <p>
3149            * 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.
3150            * </p>
3151            *
3152            * @param start the lower bound of the range of groups
3153            * @param end the upper bound of the range of groups (not inclusive)
3154            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3155            * @return the ordered range of groups
3156            */
3157            public static List<Group> findAll(int start, int end,
3158                    OrderByComparator<Group> orderByComparator) {
3159                    return getPersistence().findAll(start, end, orderByComparator);
3160            }
3161    
3162            /**
3163            * Returns an ordered range of all the groups.
3164            *
3165            * <p>
3166            * 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.
3167            * </p>
3168            *
3169            * @param start the lower bound of the range of groups
3170            * @param end the upper bound of the range of groups (not inclusive)
3171            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3172            * @param retrieveFromCache whether to retrieve from the finder cache
3173            * @return the ordered range of groups
3174            */
3175            public static List<Group> findAll(int start, int end,
3176                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
3177                    return getPersistence()
3178                                       .findAll(start, end, orderByComparator, retrieveFromCache);
3179            }
3180    
3181            /**
3182            * Removes all the groups from the database.
3183            */
3184            public static void removeAll() {
3185                    getPersistence().removeAll();
3186            }
3187    
3188            /**
3189            * Returns the number of groups.
3190            *
3191            * @return the number of groups
3192            */
3193            public static int countAll() {
3194                    return getPersistence().countAll();
3195            }
3196    
3197            /**
3198            * Returns the primaryKeys of organizations associated with the group.
3199            *
3200            * @param pk the primary key of the group
3201            * @return long[] of the primaryKeys of organizations associated with the group
3202            */
3203            public static long[] getOrganizationPrimaryKeys(long pk) {
3204                    return getPersistence().getOrganizationPrimaryKeys(pk);
3205            }
3206    
3207            /**
3208            * Returns all the organizations associated with the group.
3209            *
3210            * @param pk the primary key of the group
3211            * @return the organizations associated with the group
3212            */
3213            public static List<com.liferay.portal.kernel.model.Organization> getOrganizations(
3214                    long pk) {
3215                    return getPersistence().getOrganizations(pk);
3216            }
3217    
3218            /**
3219            * Returns a range of all the organizations associated with the group.
3220            *
3221            * <p>
3222            * 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.
3223            * </p>
3224            *
3225            * @param pk the primary key of the group
3226            * @param start the lower bound of the range of groups
3227            * @param end the upper bound of the range of groups (not inclusive)
3228            * @return the range of organizations associated with the group
3229            */
3230            public static List<com.liferay.portal.kernel.model.Organization> getOrganizations(
3231                    long pk, int start, int end) {
3232                    return getPersistence().getOrganizations(pk, start, end);
3233            }
3234    
3235            /**
3236            * Returns an ordered range of all the organizations associated with the group.
3237            *
3238            * <p>
3239            * 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.
3240            * </p>
3241            *
3242            * @param pk the primary key of the group
3243            * @param start the lower bound of the range of groups
3244            * @param end the upper bound of the range of groups (not inclusive)
3245            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3246            * @return the ordered range of organizations associated with the group
3247            */
3248            public static List<com.liferay.portal.kernel.model.Organization> getOrganizations(
3249                    long pk, int start, int end,
3250                    OrderByComparator<com.liferay.portal.kernel.model.Organization> orderByComparator) {
3251                    return getPersistence()
3252                                       .getOrganizations(pk, start, end, orderByComparator);
3253            }
3254    
3255            /**
3256            * Returns the number of organizations associated with the group.
3257            *
3258            * @param pk the primary key of the group
3259            * @return the number of organizations associated with the group
3260            */
3261            public static int getOrganizationsSize(long pk) {
3262                    return getPersistence().getOrganizationsSize(pk);
3263            }
3264    
3265            /**
3266            * Returns <code>true</code> if the organization is associated with the group.
3267            *
3268            * @param pk the primary key of the group
3269            * @param organizationPK the primary key of the organization
3270            * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise
3271            */
3272            public static boolean containsOrganization(long pk, long organizationPK) {
3273                    return getPersistence().containsOrganization(pk, organizationPK);
3274            }
3275    
3276            /**
3277            * Returns <code>true</code> if the group has any organizations associated with it.
3278            *
3279            * @param pk the primary key of the group to check for associations with organizations
3280            * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise
3281            */
3282            public static boolean containsOrganizations(long pk) {
3283                    return getPersistence().containsOrganizations(pk);
3284            }
3285    
3286            /**
3287            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3288            *
3289            * @param pk the primary key of the group
3290            * @param organizationPK the primary key of the organization
3291            */
3292            public static void addOrganization(long pk, long organizationPK) {
3293                    getPersistence().addOrganization(pk, organizationPK);
3294            }
3295    
3296            /**
3297            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3298            *
3299            * @param pk the primary key of the group
3300            * @param organization the organization
3301            */
3302            public static void addOrganization(long pk,
3303                    com.liferay.portal.kernel.model.Organization organization) {
3304                    getPersistence().addOrganization(pk, organization);
3305            }
3306    
3307            /**
3308            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3309            *
3310            * @param pk the primary key of the group
3311            * @param organizationPKs the primary keys of the organizations
3312            */
3313            public static void addOrganizations(long pk, long[] organizationPKs) {
3314                    getPersistence().addOrganizations(pk, organizationPKs);
3315            }
3316    
3317            /**
3318            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3319            *
3320            * @param pk the primary key of the group
3321            * @param organizations the organizations
3322            */
3323            public static void addOrganizations(long pk,
3324                    List<com.liferay.portal.kernel.model.Organization> organizations) {
3325                    getPersistence().addOrganizations(pk, organizations);
3326            }
3327    
3328            /**
3329            * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3330            *
3331            * @param pk the primary key of the group to clear the associated organizations from
3332            */
3333            public static void clearOrganizations(long pk) {
3334                    getPersistence().clearOrganizations(pk);
3335            }
3336    
3337            /**
3338            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3339            *
3340            * @param pk the primary key of the group
3341            * @param organizationPK the primary key of the organization
3342            */
3343            public static void removeOrganization(long pk, long organizationPK) {
3344                    getPersistence().removeOrganization(pk, organizationPK);
3345            }
3346    
3347            /**
3348            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3349            *
3350            * @param pk the primary key of the group
3351            * @param organization the organization
3352            */
3353            public static void removeOrganization(long pk,
3354                    com.liferay.portal.kernel.model.Organization organization) {
3355                    getPersistence().removeOrganization(pk, organization);
3356            }
3357    
3358            /**
3359            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3360            *
3361            * @param pk the primary key of the group
3362            * @param organizationPKs the primary keys of the organizations
3363            */
3364            public static void removeOrganizations(long pk, long[] organizationPKs) {
3365                    getPersistence().removeOrganizations(pk, organizationPKs);
3366            }
3367    
3368            /**
3369            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3370            *
3371            * @param pk the primary key of the group
3372            * @param organizations the organizations
3373            */
3374            public static void removeOrganizations(long pk,
3375                    List<com.liferay.portal.kernel.model.Organization> organizations) {
3376                    getPersistence().removeOrganizations(pk, organizations);
3377            }
3378    
3379            /**
3380            * 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.
3381            *
3382            * @param pk the primary key of the group
3383            * @param organizationPKs the primary keys of the organizations to be associated with the group
3384            */
3385            public static void setOrganizations(long pk, long[] organizationPKs) {
3386                    getPersistence().setOrganizations(pk, organizationPKs);
3387            }
3388    
3389            /**
3390            * 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.
3391            *
3392            * @param pk the primary key of the group
3393            * @param organizations the organizations to be associated with the group
3394            */
3395            public static void setOrganizations(long pk,
3396                    List<com.liferay.portal.kernel.model.Organization> organizations) {
3397                    getPersistence().setOrganizations(pk, organizations);
3398            }
3399    
3400            /**
3401            * Returns the primaryKeys of roles associated with the group.
3402            *
3403            * @param pk the primary key of the group
3404            * @return long[] of the primaryKeys of roles associated with the group
3405            */
3406            public static long[] getRolePrimaryKeys(long pk) {
3407                    return getPersistence().getRolePrimaryKeys(pk);
3408            }
3409    
3410            /**
3411            * Returns all the roles associated with the group.
3412            *
3413            * @param pk the primary key of the group
3414            * @return the roles associated with the group
3415            */
3416            public static List<com.liferay.portal.kernel.model.Role> getRoles(long pk) {
3417                    return getPersistence().getRoles(pk);
3418            }
3419    
3420            /**
3421            * Returns a range of all the roles associated with the group.
3422            *
3423            * <p>
3424            * 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.
3425            * </p>
3426            *
3427            * @param pk the primary key of the group
3428            * @param start the lower bound of the range of groups
3429            * @param end the upper bound of the range of groups (not inclusive)
3430            * @return the range of roles associated with the group
3431            */
3432            public static List<com.liferay.portal.kernel.model.Role> getRoles(long pk,
3433                    int start, int end) {
3434                    return getPersistence().getRoles(pk, start, end);
3435            }
3436    
3437            /**
3438            * Returns an ordered range of all the roles associated with the group.
3439            *
3440            * <p>
3441            * 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.
3442            * </p>
3443            *
3444            * @param pk the primary key of the group
3445            * @param start the lower bound of the range of groups
3446            * @param end the upper bound of the range of groups (not inclusive)
3447            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3448            * @return the ordered range of roles associated with the group
3449            */
3450            public static List<com.liferay.portal.kernel.model.Role> getRoles(long pk,
3451                    int start, int end,
3452                    OrderByComparator<com.liferay.portal.kernel.model.Role> orderByComparator) {
3453                    return getPersistence().getRoles(pk, start, end, orderByComparator);
3454            }
3455    
3456            /**
3457            * Returns the number of roles associated with the group.
3458            *
3459            * @param pk the primary key of the group
3460            * @return the number of roles associated with the group
3461            */
3462            public static int getRolesSize(long pk) {
3463                    return getPersistence().getRolesSize(pk);
3464            }
3465    
3466            /**
3467            * Returns <code>true</code> if the role is associated with the group.
3468            *
3469            * @param pk the primary key of the group
3470            * @param rolePK the primary key of the role
3471            * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise
3472            */
3473            public static boolean containsRole(long pk, long rolePK) {
3474                    return getPersistence().containsRole(pk, rolePK);
3475            }
3476    
3477            /**
3478            * Returns <code>true</code> if the group has any roles associated with it.
3479            *
3480            * @param pk the primary key of the group to check for associations with roles
3481            * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise
3482            */
3483            public static boolean containsRoles(long pk) {
3484                    return getPersistence().containsRoles(pk);
3485            }
3486    
3487            /**
3488            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3489            *
3490            * @param pk the primary key of the group
3491            * @param rolePK the primary key of the role
3492            */
3493            public static void addRole(long pk, long rolePK) {
3494                    getPersistence().addRole(pk, rolePK);
3495            }
3496    
3497            /**
3498            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3499            *
3500            * @param pk the primary key of the group
3501            * @param role the role
3502            */
3503            public static void addRole(long pk,
3504                    com.liferay.portal.kernel.model.Role role) {
3505                    getPersistence().addRole(pk, role);
3506            }
3507    
3508            /**
3509            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3510            *
3511            * @param pk the primary key of the group
3512            * @param rolePKs the primary keys of the roles
3513            */
3514            public static void addRoles(long pk, long[] rolePKs) {
3515                    getPersistence().addRoles(pk, rolePKs);
3516            }
3517    
3518            /**
3519            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3520            *
3521            * @param pk the primary key of the group
3522            * @param roles the roles
3523            */
3524            public static void addRoles(long pk,
3525                    List<com.liferay.portal.kernel.model.Role> roles) {
3526                    getPersistence().addRoles(pk, roles);
3527            }
3528    
3529            /**
3530            * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3531            *
3532            * @param pk the primary key of the group to clear the associated roles from
3533            */
3534            public static void clearRoles(long pk) {
3535                    getPersistence().clearRoles(pk);
3536            }
3537    
3538            /**
3539            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3540            *
3541            * @param pk the primary key of the group
3542            * @param rolePK the primary key of the role
3543            */
3544            public static void removeRole(long pk, long rolePK) {
3545                    getPersistence().removeRole(pk, rolePK);
3546            }
3547    
3548            /**
3549            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3550            *
3551            * @param pk the primary key of the group
3552            * @param role the role
3553            */
3554            public static void removeRole(long pk,
3555                    com.liferay.portal.kernel.model.Role role) {
3556                    getPersistence().removeRole(pk, role);
3557            }
3558    
3559            /**
3560            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3561            *
3562            * @param pk the primary key of the group
3563            * @param rolePKs the primary keys of the roles
3564            */
3565            public static void removeRoles(long pk, long[] rolePKs) {
3566                    getPersistence().removeRoles(pk, rolePKs);
3567            }
3568    
3569            /**
3570            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3571            *
3572            * @param pk the primary key of the group
3573            * @param roles the roles
3574            */
3575            public static void removeRoles(long pk,
3576                    List<com.liferay.portal.kernel.model.Role> roles) {
3577                    getPersistence().removeRoles(pk, roles);
3578            }
3579    
3580            /**
3581            * 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.
3582            *
3583            * @param pk the primary key of the group
3584            * @param rolePKs the primary keys of the roles to be associated with the group
3585            */
3586            public static void setRoles(long pk, long[] rolePKs) {
3587                    getPersistence().setRoles(pk, rolePKs);
3588            }
3589    
3590            /**
3591            * 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.
3592            *
3593            * @param pk the primary key of the group
3594            * @param roles the roles to be associated with the group
3595            */
3596            public static void setRoles(long pk,
3597                    List<com.liferay.portal.kernel.model.Role> roles) {
3598                    getPersistence().setRoles(pk, roles);
3599            }
3600    
3601            /**
3602            * Returns the primaryKeys of user groups associated with the group.
3603            *
3604            * @param pk the primary key of the group
3605            * @return long[] of the primaryKeys of user groups associated with the group
3606            */
3607            public static long[] getUserGroupPrimaryKeys(long pk) {
3608                    return getPersistence().getUserGroupPrimaryKeys(pk);
3609            }
3610    
3611            /**
3612            * Returns all the user groups associated with the group.
3613            *
3614            * @param pk the primary key of the group
3615            * @return the user groups associated with the group
3616            */
3617            public static List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
3618                    long pk) {
3619                    return getPersistence().getUserGroups(pk);
3620            }
3621    
3622            /**
3623            * Returns a range of all the user groups associated with the group.
3624            *
3625            * <p>
3626            * 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.
3627            * </p>
3628            *
3629            * @param pk the primary key of the group
3630            * @param start the lower bound of the range of groups
3631            * @param end the upper bound of the range of groups (not inclusive)
3632            * @return the range of user groups associated with the group
3633            */
3634            public static List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
3635                    long pk, int start, int end) {
3636                    return getPersistence().getUserGroups(pk, start, end);
3637            }
3638    
3639            /**
3640            * Returns an ordered range of all the user groups associated with the group.
3641            *
3642            * <p>
3643            * 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.
3644            * </p>
3645            *
3646            * @param pk the primary key of the group
3647            * @param start the lower bound of the range of groups
3648            * @param end the upper bound of the range of groups (not inclusive)
3649            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3650            * @return the ordered range of user groups associated with the group
3651            */
3652            public static List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
3653                    long pk, int start, int end,
3654                    OrderByComparator<com.liferay.portal.kernel.model.UserGroup> orderByComparator) {
3655                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
3656            }
3657    
3658            /**
3659            * Returns the number of user groups associated with the group.
3660            *
3661            * @param pk the primary key of the group
3662            * @return the number of user groups associated with the group
3663            */
3664            public static int getUserGroupsSize(long pk) {
3665                    return getPersistence().getUserGroupsSize(pk);
3666            }
3667    
3668            /**
3669            * Returns <code>true</code> if the user group is associated with the group.
3670            *
3671            * @param pk the primary key of the group
3672            * @param userGroupPK the primary key of the user group
3673            * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise
3674            */
3675            public static boolean containsUserGroup(long pk, long userGroupPK) {
3676                    return getPersistence().containsUserGroup(pk, userGroupPK);
3677            }
3678    
3679            /**
3680            * Returns <code>true</code> if the group has any user groups associated with it.
3681            *
3682            * @param pk the primary key of the group to check for associations with user groups
3683            * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise
3684            */
3685            public static boolean containsUserGroups(long pk) {
3686                    return getPersistence().containsUserGroups(pk);
3687            }
3688    
3689            /**
3690            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3691            *
3692            * @param pk the primary key of the group
3693            * @param userGroupPK the primary key of the user group
3694            */
3695            public static void addUserGroup(long pk, long userGroupPK) {
3696                    getPersistence().addUserGroup(pk, userGroupPK);
3697            }
3698    
3699            /**
3700            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3701            *
3702            * @param pk the primary key of the group
3703            * @param userGroup the user group
3704            */
3705            public static void addUserGroup(long pk,
3706                    com.liferay.portal.kernel.model.UserGroup userGroup) {
3707                    getPersistence().addUserGroup(pk, userGroup);
3708            }
3709    
3710            /**
3711            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3712            *
3713            * @param pk the primary key of the group
3714            * @param userGroupPKs the primary keys of the user groups
3715            */
3716            public static void addUserGroups(long pk, long[] userGroupPKs) {
3717                    getPersistence().addUserGroups(pk, userGroupPKs);
3718            }
3719    
3720            /**
3721            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3722            *
3723            * @param pk the primary key of the group
3724            * @param userGroups the user groups
3725            */
3726            public static void addUserGroups(long pk,
3727                    List<com.liferay.portal.kernel.model.UserGroup> userGroups) {
3728                    getPersistence().addUserGroups(pk, userGroups);
3729            }
3730    
3731            /**
3732            * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3733            *
3734            * @param pk the primary key of the group to clear the associated user groups from
3735            */
3736            public static void clearUserGroups(long pk) {
3737                    getPersistence().clearUserGroups(pk);
3738            }
3739    
3740            /**
3741            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3742            *
3743            * @param pk the primary key of the group
3744            * @param userGroupPK the primary key of the user group
3745            */
3746            public static void removeUserGroup(long pk, long userGroupPK) {
3747                    getPersistence().removeUserGroup(pk, userGroupPK);
3748            }
3749    
3750            /**
3751            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3752            *
3753            * @param pk the primary key of the group
3754            * @param userGroup the user group
3755            */
3756            public static void removeUserGroup(long pk,
3757                    com.liferay.portal.kernel.model.UserGroup userGroup) {
3758                    getPersistence().removeUserGroup(pk, userGroup);
3759            }
3760    
3761            /**
3762            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3763            *
3764            * @param pk the primary key of the group
3765            * @param userGroupPKs the primary keys of the user groups
3766            */
3767            public static void removeUserGroups(long pk, long[] userGroupPKs) {
3768                    getPersistence().removeUserGroups(pk, userGroupPKs);
3769            }
3770    
3771            /**
3772            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3773            *
3774            * @param pk the primary key of the group
3775            * @param userGroups the user groups
3776            */
3777            public static void removeUserGroups(long pk,
3778                    List<com.liferay.portal.kernel.model.UserGroup> userGroups) {
3779                    getPersistence().removeUserGroups(pk, userGroups);
3780            }
3781    
3782            /**
3783            * 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.
3784            *
3785            * @param pk the primary key of the group
3786            * @param userGroupPKs the primary keys of the user groups to be associated with the group
3787            */
3788            public static void setUserGroups(long pk, long[] userGroupPKs) {
3789                    getPersistence().setUserGroups(pk, userGroupPKs);
3790            }
3791    
3792            /**
3793            * 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.
3794            *
3795            * @param pk the primary key of the group
3796            * @param userGroups the user groups to be associated with the group
3797            */
3798            public static void setUserGroups(long pk,
3799                    List<com.liferay.portal.kernel.model.UserGroup> userGroups) {
3800                    getPersistence().setUserGroups(pk, userGroups);
3801            }
3802    
3803            /**
3804            * Returns the primaryKeys of users associated with the group.
3805            *
3806            * @param pk the primary key of the group
3807            * @return long[] of the primaryKeys of users associated with the group
3808            */
3809            public static long[] getUserPrimaryKeys(long pk) {
3810                    return getPersistence().getUserPrimaryKeys(pk);
3811            }
3812    
3813            /**
3814            * Returns all the users associated with the group.
3815            *
3816            * @param pk the primary key of the group
3817            * @return the users associated with the group
3818            */
3819            public static List<com.liferay.portal.kernel.model.User> getUsers(long pk) {
3820                    return getPersistence().getUsers(pk);
3821            }
3822    
3823            /**
3824            * Returns a range of all the users associated with the group.
3825            *
3826            * <p>
3827            * 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.
3828            * </p>
3829            *
3830            * @param pk the primary key of the group
3831            * @param start the lower bound of the range of groups
3832            * @param end the upper bound of the range of groups (not inclusive)
3833            * @return the range of users associated with the group
3834            */
3835            public static List<com.liferay.portal.kernel.model.User> getUsers(long pk,
3836                    int start, int end) {
3837                    return getPersistence().getUsers(pk, start, end);
3838            }
3839    
3840            /**
3841            * Returns an ordered range of all the users associated with the group.
3842            *
3843            * <p>
3844            * 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.
3845            * </p>
3846            *
3847            * @param pk the primary key of the group
3848            * @param start the lower bound of the range of groups
3849            * @param end the upper bound of the range of groups (not inclusive)
3850            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3851            * @return the ordered range of users associated with the group
3852            */
3853            public static List<com.liferay.portal.kernel.model.User> getUsers(long pk,
3854                    int start, int end,
3855                    OrderByComparator<com.liferay.portal.kernel.model.User> orderByComparator) {
3856                    return getPersistence().getUsers(pk, start, end, orderByComparator);
3857            }
3858    
3859            /**
3860            * Returns the number of users associated with the group.
3861            *
3862            * @param pk the primary key of the group
3863            * @return the number of users associated with the group
3864            */
3865            public static int getUsersSize(long pk) {
3866                    return getPersistence().getUsersSize(pk);
3867            }
3868    
3869            /**
3870            * Returns <code>true</code> if the user is associated with the group.
3871            *
3872            * @param pk the primary key of the group
3873            * @param userPK the primary key of the user
3874            * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise
3875            */
3876            public static boolean containsUser(long pk, long userPK) {
3877                    return getPersistence().containsUser(pk, userPK);
3878            }
3879    
3880            /**
3881            * Returns <code>true</code> if the group has any users associated with it.
3882            *
3883            * @param pk the primary key of the group to check for associations with users
3884            * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise
3885            */
3886            public static boolean containsUsers(long pk) {
3887                    return getPersistence().containsUsers(pk);
3888            }
3889    
3890            /**
3891            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3892            *
3893            * @param pk the primary key of the group
3894            * @param userPK the primary key of the user
3895            */
3896            public static void addUser(long pk, long userPK) {
3897                    getPersistence().addUser(pk, userPK);
3898            }
3899    
3900            /**
3901            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3902            *
3903            * @param pk the primary key of the group
3904            * @param user the user
3905            */
3906            public static void addUser(long pk,
3907                    com.liferay.portal.kernel.model.User user) {
3908                    getPersistence().addUser(pk, user);
3909            }
3910    
3911            /**
3912            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3913            *
3914            * @param pk the primary key of the group
3915            * @param userPKs the primary keys of the users
3916            */
3917            public static void addUsers(long pk, long[] userPKs) {
3918                    getPersistence().addUsers(pk, userPKs);
3919            }
3920    
3921            /**
3922            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3923            *
3924            * @param pk the primary key of the group
3925            * @param users the users
3926            */
3927            public static void addUsers(long pk,
3928                    List<com.liferay.portal.kernel.model.User> users) {
3929                    getPersistence().addUsers(pk, users);
3930            }
3931    
3932            /**
3933            * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3934            *
3935            * @param pk the primary key of the group to clear the associated users from
3936            */
3937            public static void clearUsers(long pk) {
3938                    getPersistence().clearUsers(pk);
3939            }
3940    
3941            /**
3942            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3943            *
3944            * @param pk the primary key of the group
3945            * @param userPK the primary key of the user
3946            */
3947            public static void removeUser(long pk, long userPK) {
3948                    getPersistence().removeUser(pk, userPK);
3949            }
3950    
3951            /**
3952            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3953            *
3954            * @param pk the primary key of the group
3955            * @param user the user
3956            */
3957            public static void removeUser(long pk,
3958                    com.liferay.portal.kernel.model.User user) {
3959                    getPersistence().removeUser(pk, user);
3960            }
3961    
3962            /**
3963            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3964            *
3965            * @param pk the primary key of the group
3966            * @param userPKs the primary keys of the users
3967            */
3968            public static void removeUsers(long pk, long[] userPKs) {
3969                    getPersistence().removeUsers(pk, userPKs);
3970            }
3971    
3972            /**
3973            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3974            *
3975            * @param pk the primary key of the group
3976            * @param users the users
3977            */
3978            public static void removeUsers(long pk,
3979                    List<com.liferay.portal.kernel.model.User> users) {
3980                    getPersistence().removeUsers(pk, users);
3981            }
3982    
3983            /**
3984            * 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.
3985            *
3986            * @param pk the primary key of the group
3987            * @param userPKs the primary keys of the users to be associated with the group
3988            */
3989            public static void setUsers(long pk, long[] userPKs) {
3990                    getPersistence().setUsers(pk, userPKs);
3991            }
3992    
3993            /**
3994            * 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.
3995            *
3996            * @param pk the primary key of the group
3997            * @param users the users to be associated with the group
3998            */
3999            public static void setUsers(long pk,
4000                    List<com.liferay.portal.kernel.model.User> users) {
4001                    getPersistence().setUsers(pk, users);
4002            }
4003    
4004            public static java.util.Set<java.lang.String> getBadColumnNames() {
4005                    return getPersistence().getBadColumnNames();
4006            }
4007    
4008            public static GroupPersistence getPersistence() {
4009                    if (_persistence == null) {
4010                            _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName());
4011    
4012                            ReferenceRegistry.registerReference(GroupUtil.class, "_persistence");
4013                    }
4014    
4015                    return _persistence;
4016            }
4017    
4018            private static GroupPersistence _persistence;
4019    }