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