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