001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.Group;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the group service. This utility wraps {@link com.liferay.portal.service.persistence.impl.GroupPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see GroupPersistence
037     * @see com.liferay.portal.service.persistence.impl.GroupPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class GroupUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(Group group) {
059                    getPersistence().clearCache(group);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery) {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery,
080                    int start, int end) {
081                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
082            }
083    
084            /**
085             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
086             */
087            public static List<Group> findWithDynamicQuery(DynamicQuery dynamicQuery,
088                    int start, int end, OrderByComparator<Group> orderByComparator) {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
096             */
097            public static Group update(Group group) {
098                    return getPersistence().update(group);
099            }
100    
101            /**
102             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
103             */
104            public static Group update(Group group, ServiceContext serviceContext) {
105                    return getPersistence().update(group, serviceContext);
106            }
107    
108            /**
109            * Returns all the groups where uuid = &#63;.
110            *
111            * @param uuid the uuid
112            * @return the matching groups
113            */
114            public static List<Group> findByUuid(java.lang.String uuid) {
115                    return getPersistence().findByUuid(uuid);
116            }
117    
118            /**
119            * Returns a range of all the groups where uuid = &#63;.
120            *
121            * <p>
122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
123            * </p>
124            *
125            * @param uuid the uuid
126            * @param start the lower bound of the range of groups
127            * @param end the upper bound of the range of groups (not inclusive)
128            * @return the range of matching groups
129            */
130            public static List<Group> findByUuid(java.lang.String uuid, int start,
131                    int end) {
132                    return getPersistence().findByUuid(uuid, start, end);
133            }
134    
135            /**
136            * Returns an ordered range of all the groups where uuid = &#63;.
137            *
138            * <p>
139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
140            * </p>
141            *
142            * @param uuid the uuid
143            * @param start the lower bound of the range of groups
144            * @param end the upper bound of the range of groups (not inclusive)
145            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
146            * @return the ordered range of matching groups
147            */
148            public static List<Group> findByUuid(java.lang.String uuid, int start,
149                    int end, OrderByComparator<Group> orderByComparator) {
150                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
151            }
152    
153            /**
154            * Returns an ordered range of all the groups where uuid = &#63;.
155            *
156            * <p>
157            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
158            * </p>
159            *
160            * @param uuid the uuid
161            * @param start the lower bound of the range of groups
162            * @param end the upper bound of the range of groups (not inclusive)
163            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
164            * @param retrieveFromCache whether to retrieve from the finder cache
165            * @return the ordered range of matching groups
166            */
167            public static List<Group> findByUuid(java.lang.String uuid, int start,
168                    int end, OrderByComparator<Group> orderByComparator,
169                    boolean retrieveFromCache) {
170                    return getPersistence()
171                                       .findByUuid(uuid, start, end, orderByComparator,
172                            retrieveFromCache);
173            }
174    
175            /**
176            * Returns the first group in the ordered set where uuid = &#63;.
177            *
178            * @param uuid the uuid
179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
180            * @return the first matching group
181            * @throws NoSuchGroupException if a matching group could not be found
182            */
183            public static Group findByUuid_First(java.lang.String uuid,
184                    OrderByComparator<Group> orderByComparator)
185                    throws com.liferay.portal.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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) throws com.liferay.portal.exception.NoSuchGroupException {
1869                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
1870            }
1871    
1872            /**
1873            * 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.
1874            *
1875            * @param companyId the company ID
1876            * @param classNameId the class name ID
1877            * @param classPK the class p k
1878            * @return the matching group, or <code>null</code> if a matching group could not be found
1879            */
1880            public static Group fetchByC_C_C(long companyId, long classNameId,
1881                    long classPK) {
1882                    return getPersistence().fetchByC_C_C(companyId, classNameId, classPK);
1883            }
1884    
1885            /**
1886            * 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.
1887            *
1888            * @param companyId the company ID
1889            * @param classNameId the class name ID
1890            * @param classPK the class p k
1891            * @param retrieveFromCache whether to retrieve from the finder cache
1892            * @return the matching group, or <code>null</code> if a matching group could not be found
1893            */
1894            public static Group fetchByC_C_C(long companyId, long classNameId,
1895                    long classPK, boolean retrieveFromCache) {
1896                    return getPersistence()
1897                                       .fetchByC_C_C(companyId, classNameId, classPK,
1898                            retrieveFromCache);
1899            }
1900    
1901            /**
1902            * Removes the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1903            *
1904            * @param companyId the company ID
1905            * @param classNameId the class name ID
1906            * @param classPK the class p k
1907            * @return the group that was removed
1908            */
1909            public static Group removeByC_C_C(long companyId, long classNameId,
1910                    long classPK) throws com.liferay.portal.exception.NoSuchGroupException {
1911                    return getPersistence().removeByC_C_C(companyId, classNameId, classPK);
1912            }
1913    
1914            /**
1915            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1916            *
1917            * @param companyId the company ID
1918            * @param classNameId the class name ID
1919            * @param classPK the class p k
1920            * @return the number of matching groups
1921            */
1922            public static int countByC_C_C(long companyId, long classNameId,
1923                    long classPK) {
1924                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
1925            }
1926    
1927            /**
1928            * Returns all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1929            *
1930            * @param companyId the company ID
1931            * @param classNameId the class name ID
1932            * @param parentGroupId the parent group ID
1933            * @return the matching groups
1934            */
1935            public static List<Group> findByC_C_P(long companyId, long classNameId,
1936                    long parentGroupId) {
1937                    return getPersistence()
1938                                       .findByC_C_P(companyId, classNameId, parentGroupId);
1939            }
1940    
1941            /**
1942            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1943            *
1944            * <p>
1945            * 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.
1946            * </p>
1947            *
1948            * @param companyId the company ID
1949            * @param classNameId the class name ID
1950            * @param parentGroupId the parent group ID
1951            * @param start the lower bound of the range of groups
1952            * @param end the upper bound of the range of groups (not inclusive)
1953            * @return the range of matching groups
1954            */
1955            public static List<Group> findByC_C_P(long companyId, long classNameId,
1956                    long parentGroupId, int start, int end) {
1957                    return getPersistence()
1958                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1959                            end);
1960            }
1961    
1962            /**
1963            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1964            *
1965            * <p>
1966            * 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.
1967            * </p>
1968            *
1969            * @param companyId the company ID
1970            * @param classNameId the class name ID
1971            * @param parentGroupId the parent group ID
1972            * @param start the lower bound of the range of groups
1973            * @param end the upper bound of the range of groups (not inclusive)
1974            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1975            * @return the ordered range of matching groups
1976            */
1977            public static List<Group> findByC_C_P(long companyId, long classNameId,
1978                    long parentGroupId, int start, int end,
1979                    OrderByComparator<Group> orderByComparator) {
1980                    return getPersistence()
1981                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1982                            end, orderByComparator);
1983            }
1984    
1985            /**
1986            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1987            *
1988            * <p>
1989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1990            * </p>
1991            *
1992            * @param companyId the company ID
1993            * @param classNameId the class name ID
1994            * @param parentGroupId the parent group ID
1995            * @param start the lower bound of the range of groups
1996            * @param end the upper bound of the range of groups (not inclusive)
1997            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1998            * @param retrieveFromCache whether to retrieve from the finder cache
1999            * @return the ordered range of matching groups
2000            */
2001            public static List<Group> findByC_C_P(long companyId, long classNameId,
2002                    long parentGroupId, int start, int end,
2003                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2004                    return getPersistence()
2005                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
2006                            end, orderByComparator, retrieveFromCache);
2007            }
2008    
2009            /**
2010            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2011            *
2012            * @param companyId the company ID
2013            * @param classNameId the class name ID
2014            * @param parentGroupId the parent group ID
2015            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2016            * @return the first matching group
2017            * @throws NoSuchGroupException if a matching group could not be found
2018            */
2019            public static Group findByC_C_P_First(long companyId, long classNameId,
2020                    long parentGroupId, OrderByComparator<Group> orderByComparator)
2021                    throws com.liferay.portal.exception.NoSuchGroupException {
2022                    return getPersistence()
2023                                       .findByC_C_P_First(companyId, classNameId, parentGroupId,
2024                            orderByComparator);
2025            }
2026    
2027            /**
2028            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2029            *
2030            * @param companyId the company ID
2031            * @param classNameId the class name ID
2032            * @param parentGroupId the parent group ID
2033            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2034            * @return the first matching group, or <code>null</code> if a matching group could not be found
2035            */
2036            public static Group fetchByC_C_P_First(long companyId, long classNameId,
2037                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
2038                    return getPersistence()
2039                                       .fetchByC_C_P_First(companyId, classNameId, parentGroupId,
2040                            orderByComparator);
2041            }
2042    
2043            /**
2044            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2045            *
2046            * @param companyId the company ID
2047            * @param classNameId the class name ID
2048            * @param parentGroupId the parent group ID
2049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2050            * @return the last matching group
2051            * @throws NoSuchGroupException if a matching group could not be found
2052            */
2053            public static Group findByC_C_P_Last(long companyId, long classNameId,
2054                    long parentGroupId, OrderByComparator<Group> orderByComparator)
2055                    throws com.liferay.portal.exception.NoSuchGroupException {
2056                    return getPersistence()
2057                                       .findByC_C_P_Last(companyId, classNameId, parentGroupId,
2058                            orderByComparator);
2059            }
2060    
2061            /**
2062            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2063            *
2064            * @param companyId the company ID
2065            * @param classNameId the class name ID
2066            * @param parentGroupId the parent group ID
2067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2068            * @return the last matching group, or <code>null</code> if a matching group could not be found
2069            */
2070            public static Group fetchByC_C_P_Last(long companyId, long classNameId,
2071                    long parentGroupId, OrderByComparator<Group> orderByComparator) {
2072                    return getPersistence()
2073                                       .fetchByC_C_P_Last(companyId, classNameId, parentGroupId,
2074                            orderByComparator);
2075            }
2076    
2077            /**
2078            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2079            *
2080            * @param groupId the primary key of the current group
2081            * @param companyId the company ID
2082            * @param classNameId the class name ID
2083            * @param parentGroupId the parent group ID
2084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2085            * @return the previous, current, and next group
2086            * @throws NoSuchGroupException if a group with the primary key could not be found
2087            */
2088            public static Group[] findByC_C_P_PrevAndNext(long groupId, long companyId,
2089                    long classNameId, long parentGroupId,
2090                    OrderByComparator<Group> orderByComparator)
2091                    throws com.liferay.portal.exception.NoSuchGroupException {
2092                    return getPersistence()
2093                                       .findByC_C_P_PrevAndNext(groupId, companyId, classNameId,
2094                            parentGroupId, orderByComparator);
2095            }
2096    
2097            /**
2098            * Removes all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
2099            *
2100            * @param companyId the company ID
2101            * @param classNameId the class name ID
2102            * @param parentGroupId the parent group ID
2103            */
2104            public static void removeByC_C_P(long companyId, long classNameId,
2105                    long parentGroupId) {
2106                    getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId);
2107            }
2108    
2109            /**
2110            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
2111            *
2112            * @param companyId the company ID
2113            * @param classNameId the class name ID
2114            * @param parentGroupId the parent group ID
2115            * @return the number of matching groups
2116            */
2117            public static int countByC_C_P(long companyId, long classNameId,
2118                    long parentGroupId) {
2119                    return getPersistence()
2120                                       .countByC_C_P(companyId, classNameId, parentGroupId);
2121            }
2122    
2123            /**
2124            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2125            *
2126            * @param companyId the company ID
2127            * @param parentGroupId the parent group ID
2128            * @param site the site
2129            * @return the matching groups
2130            */
2131            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2132                    boolean site) {
2133                    return getPersistence().findByC_P_S(companyId, parentGroupId, site);
2134            }
2135    
2136            /**
2137            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2138            *
2139            * <p>
2140            * 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.
2141            * </p>
2142            *
2143            * @param companyId the company ID
2144            * @param parentGroupId the parent group ID
2145            * @param site the site
2146            * @param start the lower bound of the range of groups
2147            * @param end the upper bound of the range of groups (not inclusive)
2148            * @return the range of matching groups
2149            */
2150            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2151                    boolean site, int start, int end) {
2152                    return getPersistence()
2153                                       .findByC_P_S(companyId, parentGroupId, site, start, end);
2154            }
2155    
2156            /**
2157            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2158            *
2159            * <p>
2160            * 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.
2161            * </p>
2162            *
2163            * @param companyId the company ID
2164            * @param parentGroupId the parent group ID
2165            * @param site the site
2166            * @param start the lower bound of the range of groups
2167            * @param end the upper bound of the range of groups (not inclusive)
2168            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2169            * @return the ordered range of matching groups
2170            */
2171            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2172                    boolean site, int start, int end,
2173                    OrderByComparator<Group> orderByComparator) {
2174                    return getPersistence()
2175                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
2176                            orderByComparator);
2177            }
2178    
2179            /**
2180            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2181            *
2182            * <p>
2183            * 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.
2184            * </p>
2185            *
2186            * @param companyId the company ID
2187            * @param parentGroupId the parent group ID
2188            * @param site the site
2189            * @param start the lower bound of the range of groups
2190            * @param end the upper bound of the range of groups (not inclusive)
2191            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2192            * @param retrieveFromCache whether to retrieve from the finder cache
2193            * @return the ordered range of matching groups
2194            */
2195            public static List<Group> findByC_P_S(long companyId, long parentGroupId,
2196                    boolean site, int start, int end,
2197                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2198                    return getPersistence()
2199                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
2200                            orderByComparator, retrieveFromCache);
2201            }
2202    
2203            /**
2204            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2205            *
2206            * @param companyId the company ID
2207            * @param parentGroupId the parent group ID
2208            * @param site the site
2209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2210            * @return the first matching group
2211            * @throws NoSuchGroupException if a matching group could not be found
2212            */
2213            public static Group findByC_P_S_First(long companyId, long parentGroupId,
2214                    boolean site, OrderByComparator<Group> orderByComparator)
2215                    throws com.liferay.portal.exception.NoSuchGroupException {
2216                    return getPersistence()
2217                                       .findByC_P_S_First(companyId, parentGroupId, site,
2218                            orderByComparator);
2219            }
2220    
2221            /**
2222            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2223            *
2224            * @param companyId the company ID
2225            * @param parentGroupId the parent group ID
2226            * @param site the site
2227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2228            * @return the first matching group, or <code>null</code> if a matching group could not be found
2229            */
2230            public static Group fetchByC_P_S_First(long companyId, long parentGroupId,
2231                    boolean site, OrderByComparator<Group> orderByComparator) {
2232                    return getPersistence()
2233                                       .fetchByC_P_S_First(companyId, parentGroupId, site,
2234                            orderByComparator);
2235            }
2236    
2237            /**
2238            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2239            *
2240            * @param companyId the company ID
2241            * @param parentGroupId the parent group ID
2242            * @param site the site
2243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2244            * @return the last matching group
2245            * @throws NoSuchGroupException if a matching group could not be found
2246            */
2247            public static Group findByC_P_S_Last(long companyId, long parentGroupId,
2248                    boolean site, OrderByComparator<Group> orderByComparator)
2249                    throws com.liferay.portal.exception.NoSuchGroupException {
2250                    return getPersistence()
2251                                       .findByC_P_S_Last(companyId, parentGroupId, site,
2252                            orderByComparator);
2253            }
2254    
2255            /**
2256            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2257            *
2258            * @param companyId the company ID
2259            * @param parentGroupId the parent group ID
2260            * @param site the site
2261            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2262            * @return the last matching group, or <code>null</code> if a matching group could not be found
2263            */
2264            public static Group fetchByC_P_S_Last(long companyId, long parentGroupId,
2265                    boolean site, OrderByComparator<Group> orderByComparator) {
2266                    return getPersistence()
2267                                       .fetchByC_P_S_Last(companyId, parentGroupId, site,
2268                            orderByComparator);
2269            }
2270    
2271            /**
2272            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2273            *
2274            * @param groupId the primary key of the current group
2275            * @param companyId the company ID
2276            * @param parentGroupId the parent group ID
2277            * @param site the site
2278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2279            * @return the previous, current, and next group
2280            * @throws NoSuchGroupException if a group with the primary key could not be found
2281            */
2282            public static Group[] findByC_P_S_PrevAndNext(long groupId, long companyId,
2283                    long parentGroupId, boolean site,
2284                    OrderByComparator<Group> orderByComparator)
2285                    throws com.liferay.portal.exception.NoSuchGroupException {
2286                    return getPersistence()
2287                                       .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId,
2288                            site, orderByComparator);
2289            }
2290    
2291            /**
2292            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; from the database.
2293            *
2294            * @param companyId the company ID
2295            * @param parentGroupId the parent group ID
2296            * @param site the site
2297            */
2298            public static void removeByC_P_S(long companyId, long parentGroupId,
2299                    boolean site) {
2300                    getPersistence().removeByC_P_S(companyId, parentGroupId, site);
2301            }
2302    
2303            /**
2304            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2305            *
2306            * @param companyId the company ID
2307            * @param parentGroupId the parent group ID
2308            * @param site the site
2309            * @return the number of matching groups
2310            */
2311            public static int countByC_P_S(long companyId, long parentGroupId,
2312                    boolean site) {
2313                    return getPersistence().countByC_P_S(companyId, parentGroupId, site);
2314            }
2315    
2316            /**
2317            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
2318            *
2319            * @param companyId the company ID
2320            * @param liveGroupId the live group ID
2321            * @param groupKey the group key
2322            * @return the matching group
2323            * @throws NoSuchGroupException if a matching group could not be found
2324            */
2325            public static Group findByC_L_GK(long companyId, long liveGroupId,
2326                    java.lang.String groupKey)
2327                    throws com.liferay.portal.exception.NoSuchGroupException {
2328                    return getPersistence().findByC_L_GK(companyId, liveGroupId, groupKey);
2329            }
2330    
2331            /**
2332            * 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.
2333            *
2334            * @param companyId the company ID
2335            * @param liveGroupId the live group ID
2336            * @param groupKey the group key
2337            * @return the matching group, or <code>null</code> if a matching group could not be found
2338            */
2339            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
2340                    java.lang.String groupKey) {
2341                    return getPersistence().fetchByC_L_GK(companyId, liveGroupId, groupKey);
2342            }
2343    
2344            /**
2345            * 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.
2346            *
2347            * @param companyId the company ID
2348            * @param liveGroupId the live group ID
2349            * @param groupKey the group key
2350            * @param retrieveFromCache whether to retrieve from the finder cache
2351            * @return the matching group, or <code>null</code> if a matching group could not be found
2352            */
2353            public static Group fetchByC_L_GK(long companyId, long liveGroupId,
2354                    java.lang.String groupKey, boolean retrieveFromCache) {
2355                    return getPersistence()
2356                                       .fetchByC_L_GK(companyId, liveGroupId, groupKey,
2357                            retrieveFromCache);
2358            }
2359    
2360            /**
2361            * Removes the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
2362            *
2363            * @param companyId the company ID
2364            * @param liveGroupId the live group ID
2365            * @param groupKey the group key
2366            * @return the group that was removed
2367            */
2368            public static Group removeByC_L_GK(long companyId, long liveGroupId,
2369                    java.lang.String groupKey)
2370                    throws com.liferay.portal.exception.NoSuchGroupException {
2371                    return getPersistence().removeByC_L_GK(companyId, liveGroupId, groupKey);
2372            }
2373    
2374            /**
2375            * Returns the number of groups where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
2376            *
2377            * @param companyId the company ID
2378            * @param liveGroupId the live group ID
2379            * @param groupKey the group key
2380            * @return the number of matching groups
2381            */
2382            public static int countByC_L_GK(long companyId, long liveGroupId,
2383                    java.lang.String groupKey) {
2384                    return getPersistence().countByC_L_GK(companyId, liveGroupId, groupKey);
2385            }
2386    
2387            /**
2388            * 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.
2389            *
2390            * @param companyId the company ID
2391            * @param classNameId the class name ID
2392            * @param liveGroupId the live group ID
2393            * @param groupKey the group key
2394            * @return the matching group
2395            * @throws NoSuchGroupException if a matching group could not be found
2396            */
2397            public static Group findByC_C_L_GK(long companyId, long classNameId,
2398                    long liveGroupId, java.lang.String groupKey)
2399                    throws com.liferay.portal.exception.NoSuchGroupException {
2400                    return getPersistence()
2401                                       .findByC_C_L_GK(companyId, classNameId, liveGroupId, groupKey);
2402            }
2403    
2404            /**
2405            * 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.
2406            *
2407            * @param companyId the company ID
2408            * @param classNameId the class name ID
2409            * @param liveGroupId the live group ID
2410            * @param groupKey the group key
2411            * @return the matching group, or <code>null</code> if a matching group could not be found
2412            */
2413            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2414                    long liveGroupId, java.lang.String groupKey) {
2415                    return getPersistence()
2416                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2417                            groupKey);
2418            }
2419    
2420            /**
2421            * 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.
2422            *
2423            * @param companyId the company ID
2424            * @param classNameId the class name ID
2425            * @param liveGroupId the live group ID
2426            * @param groupKey the group key
2427            * @param retrieveFromCache whether to retrieve from the finder cache
2428            * @return the matching group, or <code>null</code> if a matching group could not be found
2429            */
2430            public static Group fetchByC_C_L_GK(long companyId, long classNameId,
2431                    long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache) {
2432                    return getPersistence()
2433                                       .fetchByC_C_L_GK(companyId, classNameId, liveGroupId,
2434                            groupKey, retrieveFromCache);
2435            }
2436    
2437            /**
2438            * Removes the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
2439            *
2440            * @param companyId the company ID
2441            * @param classNameId the class name ID
2442            * @param liveGroupId the live group ID
2443            * @param groupKey the group key
2444            * @return the group that was removed
2445            */
2446            public static Group removeByC_C_L_GK(long companyId, long classNameId,
2447                    long liveGroupId, java.lang.String groupKey)
2448                    throws com.liferay.portal.exception.NoSuchGroupException {
2449                    return getPersistence()
2450                                       .removeByC_C_L_GK(companyId, classNameId, liveGroupId,
2451                            groupKey);
2452            }
2453    
2454            /**
2455            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
2456            *
2457            * @param companyId the company ID
2458            * @param classNameId the class name ID
2459            * @param liveGroupId the live group ID
2460            * @param groupKey the group key
2461            * @return the number of matching groups
2462            */
2463            public static int countByC_C_L_GK(long companyId, long classNameId,
2464                    long liveGroupId, java.lang.String groupKey) {
2465                    return getPersistence()
2466                                       .countByC_C_L_GK(companyId, classNameId, liveGroupId,
2467                            groupKey);
2468            }
2469    
2470            /**
2471            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2472            *
2473            * @param companyId the company ID
2474            * @param parentGroupId the parent group ID
2475            * @param site the site
2476            * @param inheritContent the inherit content
2477            * @return the matching groups
2478            */
2479            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2480                    boolean site, boolean inheritContent) {
2481                    return getPersistence()
2482                                       .findByC_P_S_I(companyId, parentGroupId, site, inheritContent);
2483            }
2484    
2485            /**
2486            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2487            *
2488            * <p>
2489            * 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.
2490            * </p>
2491            *
2492            * @param companyId the company ID
2493            * @param parentGroupId the parent group ID
2494            * @param site the site
2495            * @param inheritContent the inherit content
2496            * @param start the lower bound of the range of groups
2497            * @param end the upper bound of the range of groups (not inclusive)
2498            * @return the range of matching groups
2499            */
2500            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2501                    boolean site, boolean inheritContent, int start, int end) {
2502                    return getPersistence()
2503                                       .findByC_P_S_I(companyId, parentGroupId, site,
2504                            inheritContent, start, end);
2505            }
2506    
2507            /**
2508            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2509            *
2510            * <p>
2511            * 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.
2512            * </p>
2513            *
2514            * @param companyId the company ID
2515            * @param parentGroupId the parent group ID
2516            * @param site the site
2517            * @param inheritContent the inherit content
2518            * @param start the lower bound of the range of groups
2519            * @param end the upper bound of the range of groups (not inclusive)
2520            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2521            * @return the ordered range of matching groups
2522            */
2523            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2524                    boolean site, boolean inheritContent, int start, int end,
2525                    OrderByComparator<Group> orderByComparator) {
2526                    return getPersistence()
2527                                       .findByC_P_S_I(companyId, parentGroupId, site,
2528                            inheritContent, start, end, orderByComparator);
2529            }
2530    
2531            /**
2532            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2533            *
2534            * <p>
2535            * 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.
2536            * </p>
2537            *
2538            * @param companyId the company ID
2539            * @param parentGroupId the parent group ID
2540            * @param site the site
2541            * @param inheritContent the inherit content
2542            * @param start the lower bound of the range of groups
2543            * @param end the upper bound of the range of groups (not inclusive)
2544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2545            * @param retrieveFromCache whether to retrieve from the finder cache
2546            * @return the ordered range of matching groups
2547            */
2548            public static List<Group> findByC_P_S_I(long companyId, long parentGroupId,
2549                    boolean site, boolean inheritContent, int start, int end,
2550                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2551                    return getPersistence()
2552                                       .findByC_P_S_I(companyId, parentGroupId, site,
2553                            inheritContent, start, end, orderByComparator, retrieveFromCache);
2554            }
2555    
2556            /**
2557            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2558            *
2559            * @param companyId the company ID
2560            * @param parentGroupId the parent group ID
2561            * @param site the site
2562            * @param inheritContent the inherit content
2563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2564            * @return the first matching group
2565            * @throws NoSuchGroupException if a matching group could not be found
2566            */
2567            public static Group findByC_P_S_I_First(long companyId, long parentGroupId,
2568                    boolean site, boolean inheritContent,
2569                    OrderByComparator<Group> orderByComparator)
2570                    throws com.liferay.portal.exception.NoSuchGroupException {
2571                    return getPersistence()
2572                                       .findByC_P_S_I_First(companyId, parentGroupId, site,
2573                            inheritContent, orderByComparator);
2574            }
2575    
2576            /**
2577            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2578            *
2579            * @param companyId the company ID
2580            * @param parentGroupId the parent group ID
2581            * @param site the site
2582            * @param inheritContent the inherit content
2583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2584            * @return the first matching group, or <code>null</code> if a matching group could not be found
2585            */
2586            public static Group fetchByC_P_S_I_First(long companyId,
2587                    long parentGroupId, boolean site, boolean inheritContent,
2588                    OrderByComparator<Group> orderByComparator) {
2589                    return getPersistence()
2590                                       .fetchByC_P_S_I_First(companyId, parentGroupId, site,
2591                            inheritContent, orderByComparator);
2592            }
2593    
2594            /**
2595            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2596            *
2597            * @param companyId the company ID
2598            * @param parentGroupId the parent group ID
2599            * @param site the site
2600            * @param inheritContent the inherit content
2601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2602            * @return the last matching group
2603            * @throws NoSuchGroupException if a matching group could not be found
2604            */
2605            public static Group findByC_P_S_I_Last(long companyId, long parentGroupId,
2606                    boolean site, boolean inheritContent,
2607                    OrderByComparator<Group> orderByComparator)
2608                    throws com.liferay.portal.exception.NoSuchGroupException {
2609                    return getPersistence()
2610                                       .findByC_P_S_I_Last(companyId, parentGroupId, site,
2611                            inheritContent, orderByComparator);
2612            }
2613    
2614            /**
2615            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2616            *
2617            * @param companyId the company ID
2618            * @param parentGroupId the parent group ID
2619            * @param site the site
2620            * @param inheritContent the inherit content
2621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2622            * @return the last matching group, or <code>null</code> if a matching group could not be found
2623            */
2624            public static Group fetchByC_P_S_I_Last(long companyId, long parentGroupId,
2625                    boolean site, boolean inheritContent,
2626                    OrderByComparator<Group> orderByComparator) {
2627                    return getPersistence()
2628                                       .fetchByC_P_S_I_Last(companyId, parentGroupId, site,
2629                            inheritContent, orderByComparator);
2630            }
2631    
2632            /**
2633            * 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;.
2634            *
2635            * @param groupId the primary key of the current group
2636            * @param companyId the company ID
2637            * @param parentGroupId the parent group ID
2638            * @param site the site
2639            * @param inheritContent the inherit content
2640            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2641            * @return the previous, current, and next group
2642            * @throws NoSuchGroupException if a group with the primary key could not be found
2643            */
2644            public static Group[] findByC_P_S_I_PrevAndNext(long groupId,
2645                    long companyId, long parentGroupId, boolean site,
2646                    boolean inheritContent, OrderByComparator<Group> orderByComparator)
2647                    throws com.liferay.portal.exception.NoSuchGroupException {
2648                    return getPersistence()
2649                                       .findByC_P_S_I_PrevAndNext(groupId, companyId,
2650                            parentGroupId, site, inheritContent, orderByComparator);
2651            }
2652    
2653            /**
2654            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63; from the database.
2655            *
2656            * @param companyId the company ID
2657            * @param parentGroupId the parent group ID
2658            * @param site the site
2659            * @param inheritContent the inherit content
2660            */
2661            public static void removeByC_P_S_I(long companyId, long parentGroupId,
2662                    boolean site, boolean inheritContent) {
2663                    getPersistence()
2664                            .removeByC_P_S_I(companyId, parentGroupId, site, inheritContent);
2665            }
2666    
2667            /**
2668            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
2669            *
2670            * @param companyId the company ID
2671            * @param parentGroupId the parent group ID
2672            * @param site the site
2673            * @param inheritContent the inherit content
2674            * @return the number of matching groups
2675            */
2676            public static int countByC_P_S_I(long companyId, long parentGroupId,
2677                    boolean site, boolean inheritContent) {
2678                    return getPersistence()
2679                                       .countByC_P_S_I(companyId, parentGroupId, site,
2680                            inheritContent);
2681            }
2682    
2683            /**
2684            * Caches the group in the entity cache if it is enabled.
2685            *
2686            * @param group the group
2687            */
2688            public static void cacheResult(Group group) {
2689                    getPersistence().cacheResult(group);
2690            }
2691    
2692            /**
2693            * Caches the groups in the entity cache if it is enabled.
2694            *
2695            * @param groups the groups
2696            */
2697            public static void cacheResult(List<Group> groups) {
2698                    getPersistence().cacheResult(groups);
2699            }
2700    
2701            /**
2702            * Creates a new group with the primary key. Does not add the group to the database.
2703            *
2704            * @param groupId the primary key for the new group
2705            * @return the new group
2706            */
2707            public static Group create(long groupId) {
2708                    return getPersistence().create(groupId);
2709            }
2710    
2711            /**
2712            * Removes the group with the primary key from the database. Also notifies the appropriate model listeners.
2713            *
2714            * @param groupId the primary key of the group
2715            * @return the group that was removed
2716            * @throws NoSuchGroupException if a group with the primary key could not be found
2717            */
2718            public static Group remove(long groupId)
2719                    throws com.liferay.portal.exception.NoSuchGroupException {
2720                    return getPersistence().remove(groupId);
2721            }
2722    
2723            public static Group updateImpl(Group group) {
2724                    return getPersistence().updateImpl(group);
2725            }
2726    
2727            /**
2728            * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found.
2729            *
2730            * @param groupId the primary key of the group
2731            * @return the group
2732            * @throws NoSuchGroupException if a group with the primary key could not be found
2733            */
2734            public static Group findByPrimaryKey(long groupId)
2735                    throws com.liferay.portal.exception.NoSuchGroupException {
2736                    return getPersistence().findByPrimaryKey(groupId);
2737            }
2738    
2739            /**
2740            * Returns the group with the primary key or returns <code>null</code> if it could not be found.
2741            *
2742            * @param groupId the primary key of the group
2743            * @return the group, or <code>null</code> if a group with the primary key could not be found
2744            */
2745            public static Group fetchByPrimaryKey(long groupId) {
2746                    return getPersistence().fetchByPrimaryKey(groupId);
2747            }
2748    
2749            public static java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys(
2750                    java.util.Set<java.io.Serializable> primaryKeys) {
2751                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2752            }
2753    
2754            /**
2755            * Returns all the groups.
2756            *
2757            * @return the groups
2758            */
2759            public static List<Group> findAll() {
2760                    return getPersistence().findAll();
2761            }
2762    
2763            /**
2764            * Returns a range of all the groups.
2765            *
2766            * <p>
2767            * 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.
2768            * </p>
2769            *
2770            * @param start the lower bound of the range of groups
2771            * @param end the upper bound of the range of groups (not inclusive)
2772            * @return the range of groups
2773            */
2774            public static List<Group> findAll(int start, int end) {
2775                    return getPersistence().findAll(start, end);
2776            }
2777    
2778            /**
2779            * Returns an ordered range of all the groups.
2780            *
2781            * <p>
2782            * 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.
2783            * </p>
2784            *
2785            * @param start the lower bound of the range of groups
2786            * @param end the upper bound of the range of groups (not inclusive)
2787            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2788            * @return the ordered range of groups
2789            */
2790            public static List<Group> findAll(int start, int end,
2791                    OrderByComparator<Group> orderByComparator) {
2792                    return getPersistence().findAll(start, end, orderByComparator);
2793            }
2794    
2795            /**
2796            * Returns an ordered range of all the groups.
2797            *
2798            * <p>
2799            * 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.
2800            * </p>
2801            *
2802            * @param start the lower bound of the range of groups
2803            * @param end the upper bound of the range of groups (not inclusive)
2804            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2805            * @param retrieveFromCache whether to retrieve from the finder cache
2806            * @return the ordered range of groups
2807            */
2808            public static List<Group> findAll(int start, int end,
2809                    OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) {
2810                    return getPersistence()
2811                                       .findAll(start, end, orderByComparator, retrieveFromCache);
2812            }
2813    
2814            /**
2815            * Removes all the groups from the database.
2816            */
2817            public static void removeAll() {
2818                    getPersistence().removeAll();
2819            }
2820    
2821            /**
2822            * Returns the number of groups.
2823            *
2824            * @return the number of groups
2825            */
2826            public static int countAll() {
2827                    return getPersistence().countAll();
2828            }
2829    
2830            /**
2831            * Returns the primaryKeys of organizations associated with the group.
2832            *
2833            * @param pk the primary key of the group
2834            * @return long[] of the primaryKeys of organizations associated with the group
2835            */
2836            public static long[] getOrganizationPrimaryKeys(long pk) {
2837                    return getPersistence().getOrganizationPrimaryKeys(pk);
2838            }
2839    
2840            /**
2841            * Returns all the organizations associated with the group.
2842            *
2843            * @param pk the primary key of the group
2844            * @return the organizations associated with the group
2845            */
2846            public static List<com.liferay.portal.model.Organization> getOrganizations(
2847                    long pk) {
2848                    return getPersistence().getOrganizations(pk);
2849            }
2850    
2851            /**
2852            * Returns a range of all the organizations associated with the group.
2853            *
2854            * <p>
2855            * 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.
2856            * </p>
2857            *
2858            * @param pk the primary key of the group
2859            * @param start the lower bound of the range of groups
2860            * @param end the upper bound of the range of groups (not inclusive)
2861            * @return the range of organizations associated with the group
2862            */
2863            public static List<com.liferay.portal.model.Organization> getOrganizations(
2864                    long pk, int start, int end) {
2865                    return getPersistence().getOrganizations(pk, start, end);
2866            }
2867    
2868            /**
2869            * Returns an ordered range of all the organizations associated with the group.
2870            *
2871            * <p>
2872            * 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.
2873            * </p>
2874            *
2875            * @param pk the primary key of the group
2876            * @param start the lower bound of the range of groups
2877            * @param end the upper bound of the range of groups (not inclusive)
2878            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2879            * @return the ordered range of organizations associated with the group
2880            */
2881            public static List<com.liferay.portal.model.Organization> getOrganizations(
2882                    long pk, int start, int end,
2883                    OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) {
2884                    return getPersistence()
2885                                       .getOrganizations(pk, start, end, orderByComparator);
2886            }
2887    
2888            /**
2889            * Returns the number of organizations associated with the group.
2890            *
2891            * @param pk the primary key of the group
2892            * @return the number of organizations associated with the group
2893            */
2894            public static int getOrganizationsSize(long pk) {
2895                    return getPersistence().getOrganizationsSize(pk);
2896            }
2897    
2898            /**
2899            * Returns <code>true</code> if the organization is associated with the group.
2900            *
2901            * @param pk the primary key of the group
2902            * @param organizationPK the primary key of the organization
2903            * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise
2904            */
2905            public static boolean containsOrganization(long pk, long organizationPK) {
2906                    return getPersistence().containsOrganization(pk, organizationPK);
2907            }
2908    
2909            /**
2910            * Returns <code>true</code> if the group has any organizations associated with it.
2911            *
2912            * @param pk the primary key of the group to check for associations with organizations
2913            * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise
2914            */
2915            public static boolean containsOrganizations(long pk) {
2916                    return getPersistence().containsOrganizations(pk);
2917            }
2918    
2919            /**
2920            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2921            *
2922            * @param pk the primary key of the group
2923            * @param organizationPK the primary key of the organization
2924            */
2925            public static void addOrganization(long pk, long organizationPK) {
2926                    getPersistence().addOrganization(pk, organizationPK);
2927            }
2928    
2929            /**
2930            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2931            *
2932            * @param pk the primary key of the group
2933            * @param organization the organization
2934            */
2935            public static void addOrganization(long pk,
2936                    com.liferay.portal.model.Organization organization) {
2937                    getPersistence().addOrganization(pk, organization);
2938            }
2939    
2940            /**
2941            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2942            *
2943            * @param pk the primary key of the group
2944            * @param organizationPKs the primary keys of the organizations
2945            */
2946            public static void addOrganizations(long pk, long[] organizationPKs) {
2947                    getPersistence().addOrganizations(pk, organizationPKs);
2948            }
2949    
2950            /**
2951            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2952            *
2953            * @param pk the primary key of the group
2954            * @param organizations the organizations
2955            */
2956            public static void addOrganizations(long pk,
2957                    List<com.liferay.portal.model.Organization> organizations) {
2958                    getPersistence().addOrganizations(pk, organizations);
2959            }
2960    
2961            /**
2962            * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2963            *
2964            * @param pk the primary key of the group to clear the associated organizations from
2965            */
2966            public static void clearOrganizations(long pk) {
2967                    getPersistence().clearOrganizations(pk);
2968            }
2969    
2970            /**
2971            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2972            *
2973            * @param pk the primary key of the group
2974            * @param organizationPK the primary key of the organization
2975            */
2976            public static void removeOrganization(long pk, long organizationPK) {
2977                    getPersistence().removeOrganization(pk, organizationPK);
2978            }
2979    
2980            /**
2981            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2982            *
2983            * @param pk the primary key of the group
2984            * @param organization the organization
2985            */
2986            public static void removeOrganization(long pk,
2987                    com.liferay.portal.model.Organization organization) {
2988                    getPersistence().removeOrganization(pk, organization);
2989            }
2990    
2991            /**
2992            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2993            *
2994            * @param pk the primary key of the group
2995            * @param organizationPKs the primary keys of the organizations
2996            */
2997            public static void removeOrganizations(long pk, long[] organizationPKs) {
2998                    getPersistence().removeOrganizations(pk, organizationPKs);
2999            }
3000    
3001            /**
3002            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3003            *
3004            * @param pk the primary key of the group
3005            * @param organizations the organizations
3006            */
3007            public static void removeOrganizations(long pk,
3008                    List<com.liferay.portal.model.Organization> organizations) {
3009                    getPersistence().removeOrganizations(pk, organizations);
3010            }
3011    
3012            /**
3013            * 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.
3014            *
3015            * @param pk the primary key of the group
3016            * @param organizationPKs the primary keys of the organizations to be associated with the group
3017            */
3018            public static void setOrganizations(long pk, long[] organizationPKs) {
3019                    getPersistence().setOrganizations(pk, organizationPKs);
3020            }
3021    
3022            /**
3023            * 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.
3024            *
3025            * @param pk the primary key of the group
3026            * @param organizations the organizations to be associated with the group
3027            */
3028            public static void setOrganizations(long pk,
3029                    List<com.liferay.portal.model.Organization> organizations) {
3030                    getPersistence().setOrganizations(pk, organizations);
3031            }
3032    
3033            /**
3034            * Returns the primaryKeys of roles associated with the group.
3035            *
3036            * @param pk the primary key of the group
3037            * @return long[] of the primaryKeys of roles associated with the group
3038            */
3039            public static long[] getRolePrimaryKeys(long pk) {
3040                    return getPersistence().getRolePrimaryKeys(pk);
3041            }
3042    
3043            /**
3044            * Returns all the roles associated with the group.
3045            *
3046            * @param pk the primary key of the group
3047            * @return the roles associated with the group
3048            */
3049            public static List<com.liferay.portal.model.Role> getRoles(long pk) {
3050                    return getPersistence().getRoles(pk);
3051            }
3052    
3053            /**
3054            * Returns a range of all the roles associated with the group.
3055            *
3056            * <p>
3057            * 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.
3058            * </p>
3059            *
3060            * @param pk the primary key of the group
3061            * @param start the lower bound of the range of groups
3062            * @param end the upper bound of the range of groups (not inclusive)
3063            * @return the range of roles associated with the group
3064            */
3065            public static List<com.liferay.portal.model.Role> getRoles(long pk,
3066                    int start, int end) {
3067                    return getPersistence().getRoles(pk, start, end);
3068            }
3069    
3070            /**
3071            * Returns an ordered range of all the roles associated with the group.
3072            *
3073            * <p>
3074            * 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.
3075            * </p>
3076            *
3077            * @param pk the primary key of the group
3078            * @param start the lower bound of the range of groups
3079            * @param end the upper bound of the range of groups (not inclusive)
3080            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3081            * @return the ordered range of roles associated with the group
3082            */
3083            public static List<com.liferay.portal.model.Role> getRoles(long pk,
3084                    int start, int end,
3085                    OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
3086                    return getPersistence().getRoles(pk, start, end, orderByComparator);
3087            }
3088    
3089            /**
3090            * Returns the number of roles associated with the group.
3091            *
3092            * @param pk the primary key of the group
3093            * @return the number of roles associated with the group
3094            */
3095            public static int getRolesSize(long pk) {
3096                    return getPersistence().getRolesSize(pk);
3097            }
3098    
3099            /**
3100            * Returns <code>true</code> if the role is associated with the group.
3101            *
3102            * @param pk the primary key of the group
3103            * @param rolePK the primary key of the role
3104            * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise
3105            */
3106            public static boolean containsRole(long pk, long rolePK) {
3107                    return getPersistence().containsRole(pk, rolePK);
3108            }
3109    
3110            /**
3111            * Returns <code>true</code> if the group has any roles associated with it.
3112            *
3113            * @param pk the primary key of the group to check for associations with roles
3114            * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise
3115            */
3116            public static boolean containsRoles(long pk) {
3117                    return getPersistence().containsRoles(pk);
3118            }
3119    
3120            /**
3121            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3122            *
3123            * @param pk the primary key of the group
3124            * @param rolePK the primary key of the role
3125            */
3126            public static void addRole(long pk, long rolePK) {
3127                    getPersistence().addRole(pk, rolePK);
3128            }
3129    
3130            /**
3131            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3132            *
3133            * @param pk the primary key of the group
3134            * @param role the role
3135            */
3136            public static void addRole(long pk, com.liferay.portal.model.Role role) {
3137                    getPersistence().addRole(pk, role);
3138            }
3139    
3140            /**
3141            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3142            *
3143            * @param pk the primary key of the group
3144            * @param rolePKs the primary keys of the roles
3145            */
3146            public static void addRoles(long pk, long[] rolePKs) {
3147                    getPersistence().addRoles(pk, rolePKs);
3148            }
3149    
3150            /**
3151            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3152            *
3153            * @param pk the primary key of the group
3154            * @param roles the roles
3155            */
3156            public static void addRoles(long pk,
3157                    List<com.liferay.portal.model.Role> roles) {
3158                    getPersistence().addRoles(pk, roles);
3159            }
3160    
3161            /**
3162            * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3163            *
3164            * @param pk the primary key of the group to clear the associated roles from
3165            */
3166            public static void clearRoles(long pk) {
3167                    getPersistence().clearRoles(pk);
3168            }
3169    
3170            /**
3171            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3172            *
3173            * @param pk the primary key of the group
3174            * @param rolePK the primary key of the role
3175            */
3176            public static void removeRole(long pk, long rolePK) {
3177                    getPersistence().removeRole(pk, rolePK);
3178            }
3179    
3180            /**
3181            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3182            *
3183            * @param pk the primary key of the group
3184            * @param role the role
3185            */
3186            public static void removeRole(long pk, com.liferay.portal.model.Role role) {
3187                    getPersistence().removeRole(pk, role);
3188            }
3189    
3190            /**
3191            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3192            *
3193            * @param pk the primary key of the group
3194            * @param rolePKs the primary keys of the roles
3195            */
3196            public static void removeRoles(long pk, long[] rolePKs) {
3197                    getPersistence().removeRoles(pk, rolePKs);
3198            }
3199    
3200            /**
3201            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3202            *
3203            * @param pk the primary key of the group
3204            * @param roles the roles
3205            */
3206            public static void removeRoles(long pk,
3207                    List<com.liferay.portal.model.Role> roles) {
3208                    getPersistence().removeRoles(pk, roles);
3209            }
3210    
3211            /**
3212            * 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.
3213            *
3214            * @param pk the primary key of the group
3215            * @param rolePKs the primary keys of the roles to be associated with the group
3216            */
3217            public static void setRoles(long pk, long[] rolePKs) {
3218                    getPersistence().setRoles(pk, rolePKs);
3219            }
3220    
3221            /**
3222            * 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.
3223            *
3224            * @param pk the primary key of the group
3225            * @param roles the roles to be associated with the group
3226            */
3227            public static void setRoles(long pk,
3228                    List<com.liferay.portal.model.Role> roles) {
3229                    getPersistence().setRoles(pk, roles);
3230            }
3231    
3232            /**
3233            * Returns the primaryKeys of user groups associated with the group.
3234            *
3235            * @param pk the primary key of the group
3236            * @return long[] of the primaryKeys of user groups associated with the group
3237            */
3238            public static long[] getUserGroupPrimaryKeys(long pk) {
3239                    return getPersistence().getUserGroupPrimaryKeys(pk);
3240            }
3241    
3242            /**
3243            * Returns all the user groups associated with the group.
3244            *
3245            * @param pk the primary key of the group
3246            * @return the user groups associated with the group
3247            */
3248            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3249                    long pk) {
3250                    return getPersistence().getUserGroups(pk);
3251            }
3252    
3253            /**
3254            * Returns a range of all the user groups associated with the group.
3255            *
3256            * <p>
3257            * 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.
3258            * </p>
3259            *
3260            * @param pk the primary key of the group
3261            * @param start the lower bound of the range of groups
3262            * @param end the upper bound of the range of groups (not inclusive)
3263            * @return the range of user groups associated with the group
3264            */
3265            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3266                    long pk, int start, int end) {
3267                    return getPersistence().getUserGroups(pk, start, end);
3268            }
3269    
3270            /**
3271            * Returns an ordered range of all the user groups associated with the group.
3272            *
3273            * <p>
3274            * 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.
3275            * </p>
3276            *
3277            * @param pk the primary key of the group
3278            * @param start the lower bound of the range of groups
3279            * @param end the upper bound of the range of groups (not inclusive)
3280            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3281            * @return the ordered range of user groups associated with the group
3282            */
3283            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3284                    long pk, int start, int end,
3285                    OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
3286                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
3287            }
3288    
3289            /**
3290            * Returns the number of user groups associated with the group.
3291            *
3292            * @param pk the primary key of the group
3293            * @return the number of user groups associated with the group
3294            */
3295            public static int getUserGroupsSize(long pk) {
3296                    return getPersistence().getUserGroupsSize(pk);
3297            }
3298    
3299            /**
3300            * Returns <code>true</code> if the user group is associated with the group.
3301            *
3302            * @param pk the primary key of the group
3303            * @param userGroupPK the primary key of the user group
3304            * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise
3305            */
3306            public static boolean containsUserGroup(long pk, long userGroupPK) {
3307                    return getPersistence().containsUserGroup(pk, userGroupPK);
3308            }
3309    
3310            /**
3311            * Returns <code>true</code> if the group has any user groups associated with it.
3312            *
3313            * @param pk the primary key of the group to check for associations with user groups
3314            * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise
3315            */
3316            public static boolean containsUserGroups(long pk) {
3317                    return getPersistence().containsUserGroups(pk);
3318            }
3319    
3320            /**
3321            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3322            *
3323            * @param pk the primary key of the group
3324            * @param userGroupPK the primary key of the user group
3325            */
3326            public static void addUserGroup(long pk, long userGroupPK) {
3327                    getPersistence().addUserGroup(pk, userGroupPK);
3328            }
3329    
3330            /**
3331            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3332            *
3333            * @param pk the primary key of the group
3334            * @param userGroup the user group
3335            */
3336            public static void addUserGroup(long pk,
3337                    com.liferay.portal.model.UserGroup userGroup) {
3338                    getPersistence().addUserGroup(pk, userGroup);
3339            }
3340    
3341            /**
3342            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3343            *
3344            * @param pk the primary key of the group
3345            * @param userGroupPKs the primary keys of the user groups
3346            */
3347            public static void addUserGroups(long pk, long[] userGroupPKs) {
3348                    getPersistence().addUserGroups(pk, userGroupPKs);
3349            }
3350    
3351            /**
3352            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3353            *
3354            * @param pk the primary key of the group
3355            * @param userGroups the user groups
3356            */
3357            public static void addUserGroups(long pk,
3358                    List<com.liferay.portal.model.UserGroup> userGroups) {
3359                    getPersistence().addUserGroups(pk, userGroups);
3360            }
3361    
3362            /**
3363            * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3364            *
3365            * @param pk the primary key of the group to clear the associated user groups from
3366            */
3367            public static void clearUserGroups(long pk) {
3368                    getPersistence().clearUserGroups(pk);
3369            }
3370    
3371            /**
3372            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3373            *
3374            * @param pk the primary key of the group
3375            * @param userGroupPK the primary key of the user group
3376            */
3377            public static void removeUserGroup(long pk, long userGroupPK) {
3378                    getPersistence().removeUserGroup(pk, userGroupPK);
3379            }
3380    
3381            /**
3382            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3383            *
3384            * @param pk the primary key of the group
3385            * @param userGroup the user group
3386            */
3387            public static void removeUserGroup(long pk,
3388                    com.liferay.portal.model.UserGroup userGroup) {
3389                    getPersistence().removeUserGroup(pk, userGroup);
3390            }
3391    
3392            /**
3393            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3394            *
3395            * @param pk the primary key of the group
3396            * @param userGroupPKs the primary keys of the user groups
3397            */
3398            public static void removeUserGroups(long pk, long[] userGroupPKs) {
3399                    getPersistence().removeUserGroups(pk, userGroupPKs);
3400            }
3401    
3402            /**
3403            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3404            *
3405            * @param pk the primary key of the group
3406            * @param userGroups the user groups
3407            */
3408            public static void removeUserGroups(long pk,
3409                    List<com.liferay.portal.model.UserGroup> userGroups) {
3410                    getPersistence().removeUserGroups(pk, userGroups);
3411            }
3412    
3413            /**
3414            * 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.
3415            *
3416            * @param pk the primary key of the group
3417            * @param userGroupPKs the primary keys of the user groups to be associated with the group
3418            */
3419            public static void setUserGroups(long pk, long[] userGroupPKs) {
3420                    getPersistence().setUserGroups(pk, userGroupPKs);
3421            }
3422    
3423            /**
3424            * 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.
3425            *
3426            * @param pk the primary key of the group
3427            * @param userGroups the user groups to be associated with the group
3428            */
3429            public static void setUserGroups(long pk,
3430                    List<com.liferay.portal.model.UserGroup> userGroups) {
3431                    getPersistence().setUserGroups(pk, userGroups);
3432            }
3433    
3434            /**
3435            * Returns the primaryKeys of users associated with the group.
3436            *
3437            * @param pk the primary key of the group
3438            * @return long[] of the primaryKeys of users associated with the group
3439            */
3440            public static long[] getUserPrimaryKeys(long pk) {
3441                    return getPersistence().getUserPrimaryKeys(pk);
3442            }
3443    
3444            /**
3445            * Returns all the users associated with the group.
3446            *
3447            * @param pk the primary key of the group
3448            * @return the users associated with the group
3449            */
3450            public static List<com.liferay.portal.model.User> getUsers(long pk) {
3451                    return getPersistence().getUsers(pk);
3452            }
3453    
3454            /**
3455            * Returns a range of all the users associated with the group.
3456            *
3457            * <p>
3458            * 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.
3459            * </p>
3460            *
3461            * @param pk the primary key of the group
3462            * @param start the lower bound of the range of groups
3463            * @param end the upper bound of the range of groups (not inclusive)
3464            * @return the range of users associated with the group
3465            */
3466            public static List<com.liferay.portal.model.User> getUsers(long pk,
3467                    int start, int end) {
3468                    return getPersistence().getUsers(pk, start, end);
3469            }
3470    
3471            /**
3472            * Returns an ordered range of all the users associated with the group.
3473            *
3474            * <p>
3475            * 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.
3476            * </p>
3477            *
3478            * @param pk the primary key of the group
3479            * @param start the lower bound of the range of groups
3480            * @param end the upper bound of the range of groups (not inclusive)
3481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3482            * @return the ordered range of users associated with the group
3483            */
3484            public static List<com.liferay.portal.model.User> getUsers(long pk,
3485                    int start, int end,
3486                    OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
3487                    return getPersistence().getUsers(pk, start, end, orderByComparator);
3488            }
3489    
3490            /**
3491            * Returns the number of users associated with the group.
3492            *
3493            * @param pk the primary key of the group
3494            * @return the number of users associated with the group
3495            */
3496            public static int getUsersSize(long pk) {
3497                    return getPersistence().getUsersSize(pk);
3498            }
3499    
3500            /**
3501            * Returns <code>true</code> if the user is associated with the group.
3502            *
3503            * @param pk the primary key of the group
3504            * @param userPK the primary key of the user
3505            * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise
3506            */
3507            public static boolean containsUser(long pk, long userPK) {
3508                    return getPersistence().containsUser(pk, userPK);
3509            }
3510    
3511            /**
3512            * Returns <code>true</code> if the group has any users associated with it.
3513            *
3514            * @param pk the primary key of the group to check for associations with users
3515            * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise
3516            */
3517            public static boolean containsUsers(long pk) {
3518                    return getPersistence().containsUsers(pk);
3519            }
3520    
3521            /**
3522            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3523            *
3524            * @param pk the primary key of the group
3525            * @param userPK the primary key of the user
3526            */
3527            public static void addUser(long pk, long userPK) {
3528                    getPersistence().addUser(pk, userPK);
3529            }
3530    
3531            /**
3532            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3533            *
3534            * @param pk the primary key of the group
3535            * @param user the user
3536            */
3537            public static void addUser(long pk, com.liferay.portal.model.User user) {
3538                    getPersistence().addUser(pk, user);
3539            }
3540    
3541            /**
3542            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3543            *
3544            * @param pk the primary key of the group
3545            * @param userPKs the primary keys of the users
3546            */
3547            public static void addUsers(long pk, long[] userPKs) {
3548                    getPersistence().addUsers(pk, userPKs);
3549            }
3550    
3551            /**
3552            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3553            *
3554            * @param pk the primary key of the group
3555            * @param users the users
3556            */
3557            public static void addUsers(long pk,
3558                    List<com.liferay.portal.model.User> users) {
3559                    getPersistence().addUsers(pk, users);
3560            }
3561    
3562            /**
3563            * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3564            *
3565            * @param pk the primary key of the group to clear the associated users from
3566            */
3567            public static void clearUsers(long pk) {
3568                    getPersistence().clearUsers(pk);
3569            }
3570    
3571            /**
3572            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3573            *
3574            * @param pk the primary key of the group
3575            * @param userPK the primary key of the user
3576            */
3577            public static void removeUser(long pk, long userPK) {
3578                    getPersistence().removeUser(pk, userPK);
3579            }
3580    
3581            /**
3582            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3583            *
3584            * @param pk the primary key of the group
3585            * @param user the user
3586            */
3587            public static void removeUser(long pk, com.liferay.portal.model.User user) {
3588                    getPersistence().removeUser(pk, user);
3589            }
3590    
3591            /**
3592            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3593            *
3594            * @param pk the primary key of the group
3595            * @param userPKs the primary keys of the users
3596            */
3597            public static void removeUsers(long pk, long[] userPKs) {
3598                    getPersistence().removeUsers(pk, userPKs);
3599            }
3600    
3601            /**
3602            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3603            *
3604            * @param pk the primary key of the group
3605            * @param users the users
3606            */
3607            public static void removeUsers(long pk,
3608                    List<com.liferay.portal.model.User> users) {
3609                    getPersistence().removeUsers(pk, users);
3610            }
3611    
3612            /**
3613            * 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.
3614            *
3615            * @param pk the primary key of the group
3616            * @param userPKs the primary keys of the users to be associated with the group
3617            */
3618            public static void setUsers(long pk, long[] userPKs) {
3619                    getPersistence().setUsers(pk, userPKs);
3620            }
3621    
3622            /**
3623            * 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.
3624            *
3625            * @param pk the primary key of the group
3626            * @param users the users to be associated with the group
3627            */
3628            public static void setUsers(long pk,
3629                    List<com.liferay.portal.model.User> users) {
3630                    getPersistence().setUsers(pk, users);
3631            }
3632    
3633            public static java.util.Set<java.lang.String> getBadColumnNames() {
3634                    return getPersistence().getBadColumnNames();
3635            }
3636    
3637            public static GroupPersistence getPersistence() {
3638                    if (_persistence == null) {
3639                            _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName());
3640    
3641                            ReferenceRegistry.registerReference(GroupUtil.class, "_persistence");
3642                    }
3643    
3644                    return _persistence;
3645            }
3646    
3647            private static GroupPersistence _persistence;
3648    }