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