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 static 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 classNameId = &#63;.
753            *
754            * @param companyId the company ID
755            * @param classNameId the class name 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_C(
760                    long companyId, long classNameId)
761                    throws com.liferay.portal.kernel.exception.SystemException {
762                    return getPersistence().findByC_C(companyId, classNameId);
763            }
764    
765            /**
766            * Returns a range of all the groups where companyId = &#63; and classNameId = &#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 classNameId the class name 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_C(
780                    long companyId, long classNameId, int start, int end)
781                    throws com.liferay.portal.kernel.exception.SystemException {
782                    return getPersistence().findByC_C(companyId, classNameId, start, end);
783            }
784    
785            /**
786            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#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 classNameId the class name 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_C(
801                    long companyId, long classNameId, 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_C(companyId, classNameId, start, end,
806                            orderByComparator);
807            }
808    
809            /**
810            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
811            *
812            * @param companyId the company ID
813            * @param classNameId the class name 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_C_First(
820                    long companyId, long classNameId,
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_C_First(companyId, classNameId, orderByComparator);
826            }
827    
828            /**
829            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
830            *
831            * @param companyId the company ID
832            * @param classNameId the class name 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_C_First(
838                    long companyId, long classNameId,
839                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
840                    throws com.liferay.portal.kernel.exception.SystemException {
841                    return getPersistence()
842                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
843            }
844    
845            /**
846            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
847            *
848            * @param companyId the company ID
849            * @param classNameId the class name 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_C_Last(
856                    long companyId, long classNameId,
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_C_Last(companyId, classNameId, orderByComparator);
862            }
863    
864            /**
865            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
866            *
867            * @param companyId the company ID
868            * @param classNameId the class name 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_C_Last(
874                    long companyId, long classNameId,
875                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
876                    throws com.liferay.portal.kernel.exception.SystemException {
877                    return getPersistence()
878                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
879            }
880    
881            /**
882            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63;.
883            *
884            * @param groupId the primary key of the current group
885            * @param companyId the company ID
886            * @param classNameId the class name 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_C_PrevAndNext(
893                    long groupId, long companyId, long classNameId,
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_C_PrevAndNext(groupId, companyId, classNameId,
899                            orderByComparator);
900            }
901    
902            /**
903            * Removes all the groups where companyId = &#63; and classNameId = &#63; from the database.
904            *
905            * @param companyId the company ID
906            * @param classNameId the class name ID
907            * @throws SystemException if a system exception occurred
908            */
909            public static void removeByC_C(long companyId, long classNameId)
910                    throws com.liferay.portal.kernel.exception.SystemException {
911                    getPersistence().removeByC_C(companyId, classNameId);
912            }
913    
914            /**
915            * Returns the number of groups where companyId = &#63; and classNameId = &#63;.
916            *
917            * @param companyId the company ID
918            * @param classNameId the class name ID
919            * @return the number of matching groups
920            * @throws SystemException if a system exception occurred
921            */
922            public static int countByC_C(long companyId, long classNameId)
923                    throws com.liferay.portal.kernel.exception.SystemException {
924                    return getPersistence().countByC_C(companyId, classNameId);
925            }
926    
927            /**
928            * Returns all the groups where companyId = &#63; and parentGroupId = &#63;.
929            *
930            * @param companyId the company ID
931            * @param parentGroupId the parent group ID
932            * @return the matching groups
933            * @throws SystemException if a system exception occurred
934            */
935            public static java.util.List<com.liferay.portal.model.Group> findByC_P(
936                    long companyId, long parentGroupId)
937                    throws com.liferay.portal.kernel.exception.SystemException {
938                    return getPersistence().findByC_P(companyId, parentGroupId);
939            }
940    
941            /**
942            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63;.
943            *
944            * <p>
945            * 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.
946            * </p>
947            *
948            * @param companyId the company ID
949            * @param parentGroupId the parent group ID
950            * @param start the lower bound of the range of groups
951            * @param end the upper bound of the range of groups (not inclusive)
952            * @return the range of matching groups
953            * @throws SystemException if a system exception occurred
954            */
955            public static java.util.List<com.liferay.portal.model.Group> findByC_P(
956                    long companyId, long parentGroupId, int start, int end)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence().findByC_P(companyId, parentGroupId, start, end);
959            }
960    
961            /**
962            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63;.
963            *
964            * <p>
965            * 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.
966            * </p>
967            *
968            * @param companyId the company ID
969            * @param parentGroupId the parent group ID
970            * @param start the lower bound of the range of groups
971            * @param end the upper bound of the range of groups (not inclusive)
972            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
973            * @return the ordered range of matching groups
974            * @throws SystemException if a system exception occurred
975            */
976            public static java.util.List<com.liferay.portal.model.Group> findByC_P(
977                    long companyId, long parentGroupId, int start, int end,
978                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
979                    throws com.liferay.portal.kernel.exception.SystemException {
980                    return getPersistence()
981                                       .findByC_P(companyId, parentGroupId, start, end,
982                            orderByComparator);
983            }
984    
985            /**
986            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
987            *
988            * @param companyId the company ID
989            * @param parentGroupId the parent group ID
990            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
991            * @return the first matching group
992            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
993            * @throws SystemException if a system exception occurred
994            */
995            public static com.liferay.portal.model.Group findByC_P_First(
996                    long companyId, long parentGroupId,
997                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
998                    throws com.liferay.portal.NoSuchGroupException,
999                            com.liferay.portal.kernel.exception.SystemException {
1000                    return getPersistence()
1001                                       .findByC_P_First(companyId, parentGroupId, orderByComparator);
1002            }
1003    
1004            /**
1005            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
1006            *
1007            * @param companyId the company ID
1008            * @param parentGroupId the parent group ID
1009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1010            * @return the first matching group, or <code>null</code> if a matching group could not be found
1011            * @throws SystemException if a system exception occurred
1012            */
1013            public static com.liferay.portal.model.Group fetchByC_P_First(
1014                    long companyId, long parentGroupId,
1015                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1016                    throws com.liferay.portal.kernel.exception.SystemException {
1017                    return getPersistence()
1018                                       .fetchByC_P_First(companyId, parentGroupId, orderByComparator);
1019            }
1020    
1021            /**
1022            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
1023            *
1024            * @param companyId the company ID
1025            * @param parentGroupId the parent group ID
1026            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1027            * @return the last matching group
1028            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1029            * @throws SystemException if a system exception occurred
1030            */
1031            public static com.liferay.portal.model.Group findByC_P_Last(
1032                    long companyId, long parentGroupId,
1033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1034                    throws com.liferay.portal.NoSuchGroupException,
1035                            com.liferay.portal.kernel.exception.SystemException {
1036                    return getPersistence()
1037                                       .findByC_P_Last(companyId, parentGroupId, orderByComparator);
1038            }
1039    
1040            /**
1041            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
1042            *
1043            * @param companyId the company ID
1044            * @param parentGroupId the parent group ID
1045            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1046            * @return the last matching group, or <code>null</code> if a matching group could not be found
1047            * @throws SystemException if a system exception occurred
1048            */
1049            public static com.liferay.portal.model.Group fetchByC_P_Last(
1050                    long companyId, long parentGroupId,
1051                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1052                    throws com.liferay.portal.kernel.exception.SystemException {
1053                    return getPersistence()
1054                                       .fetchByC_P_Last(companyId, parentGroupId, orderByComparator);
1055            }
1056    
1057            /**
1058            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
1059            *
1060            * @param groupId the primary key of the current group
1061            * @param companyId the company ID
1062            * @param parentGroupId the parent group ID
1063            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1064            * @return the previous, current, and next group
1065            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
1066            * @throws SystemException if a system exception occurred
1067            */
1068            public static com.liferay.portal.model.Group[] findByC_P_PrevAndNext(
1069                    long groupId, long companyId, long parentGroupId,
1070                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1071                    throws com.liferay.portal.NoSuchGroupException,
1072                            com.liferay.portal.kernel.exception.SystemException {
1073                    return getPersistence()
1074                                       .findByC_P_PrevAndNext(groupId, companyId, parentGroupId,
1075                            orderByComparator);
1076            }
1077    
1078            /**
1079            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; from the database.
1080            *
1081            * @param companyId the company ID
1082            * @param parentGroupId the parent group ID
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static void removeByC_P(long companyId, long parentGroupId)
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    getPersistence().removeByC_P(companyId, parentGroupId);
1088            }
1089    
1090            /**
1091            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63;.
1092            *
1093            * @param companyId the company ID
1094            * @param parentGroupId the parent group ID
1095            * @return the number of matching groups
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static int countByC_P(long companyId, long parentGroupId)
1099                    throws com.liferay.portal.kernel.exception.SystemException {
1100                    return getPersistence().countByC_P(companyId, parentGroupId);
1101            }
1102    
1103            /**
1104            * Returns the group where companyId = &#63; and name = &#63; or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found.
1105            *
1106            * @param companyId the company ID
1107            * @param name the name
1108            * @return the matching group
1109            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1110            * @throws SystemException if a system exception occurred
1111            */
1112            public static com.liferay.portal.model.Group findByC_N(long companyId,
1113                    java.lang.String name)
1114                    throws com.liferay.portal.NoSuchGroupException,
1115                            com.liferay.portal.kernel.exception.SystemException {
1116                    return getPersistence().findByC_N(companyId, name);
1117            }
1118    
1119            /**
1120            * Returns the group where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1121            *
1122            * @param companyId the company ID
1123            * @param name the name
1124            * @return the matching group, or <code>null</code> if a matching group could not be found
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static com.liferay.portal.model.Group fetchByC_N(long companyId,
1128                    java.lang.String name)
1129                    throws com.liferay.portal.kernel.exception.SystemException {
1130                    return getPersistence().fetchByC_N(companyId, name);
1131            }
1132    
1133            /**
1134            * 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.
1135            *
1136            * @param companyId the company ID
1137            * @param name the name
1138            * @param retrieveFromCache whether to use the finder cache
1139            * @return the matching group, or <code>null</code> if a matching group could not be found
1140            * @throws SystemException if a system exception occurred
1141            */
1142            public static com.liferay.portal.model.Group fetchByC_N(long companyId,
1143                    java.lang.String name, boolean retrieveFromCache)
1144                    throws com.liferay.portal.kernel.exception.SystemException {
1145                    return getPersistence().fetchByC_N(companyId, name, retrieveFromCache);
1146            }
1147    
1148            /**
1149            * Removes the group where companyId = &#63; and name = &#63; from the database.
1150            *
1151            * @param companyId the company ID
1152            * @param name the name
1153            * @return the group that was removed
1154            * @throws SystemException if a system exception occurred
1155            */
1156            public static com.liferay.portal.model.Group removeByC_N(long companyId,
1157                    java.lang.String name)
1158                    throws com.liferay.portal.NoSuchGroupException,
1159                            com.liferay.portal.kernel.exception.SystemException {
1160                    return getPersistence().removeByC_N(companyId, name);
1161            }
1162    
1163            /**
1164            * Returns the number of groups where companyId = &#63; and name = &#63;.
1165            *
1166            * @param companyId the company ID
1167            * @param name the name
1168            * @return the number of matching groups
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static int countByC_N(long companyId, java.lang.String name)
1172                    throws com.liferay.portal.kernel.exception.SystemException {
1173                    return getPersistence().countByC_N(companyId, name);
1174            }
1175    
1176            /**
1177            * Returns the group where companyId = &#63; and friendlyURL = &#63; or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found.
1178            *
1179            * @param companyId the company ID
1180            * @param friendlyURL the friendly u r l
1181            * @return the matching group
1182            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1183            * @throws SystemException if a system exception occurred
1184            */
1185            public static com.liferay.portal.model.Group findByC_F(long companyId,
1186                    java.lang.String friendlyURL)
1187                    throws com.liferay.portal.NoSuchGroupException,
1188                            com.liferay.portal.kernel.exception.SystemException {
1189                    return getPersistence().findByC_F(companyId, friendlyURL);
1190            }
1191    
1192            /**
1193            * Returns the group where companyId = &#63; and friendlyURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1194            *
1195            * @param companyId the company ID
1196            * @param friendlyURL the friendly u r l
1197            * @return the matching group, or <code>null</code> if a matching group could not be found
1198            * @throws SystemException if a system exception occurred
1199            */
1200            public static com.liferay.portal.model.Group fetchByC_F(long companyId,
1201                    java.lang.String friendlyURL)
1202                    throws com.liferay.portal.kernel.exception.SystemException {
1203                    return getPersistence().fetchByC_F(companyId, friendlyURL);
1204            }
1205    
1206            /**
1207            * 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.
1208            *
1209            * @param companyId the company ID
1210            * @param friendlyURL the friendly u r l
1211            * @param retrieveFromCache whether to use the finder cache
1212            * @return the matching group, or <code>null</code> if a matching group could not be found
1213            * @throws SystemException if a system exception occurred
1214            */
1215            public static com.liferay.portal.model.Group fetchByC_F(long companyId,
1216                    java.lang.String friendlyURL, boolean retrieveFromCache)
1217                    throws com.liferay.portal.kernel.exception.SystemException {
1218                    return getPersistence()
1219                                       .fetchByC_F(companyId, friendlyURL, retrieveFromCache);
1220            }
1221    
1222            /**
1223            * Removes the group where companyId = &#63; and friendlyURL = &#63; from the database.
1224            *
1225            * @param companyId the company ID
1226            * @param friendlyURL the friendly u r l
1227            * @return the group that was removed
1228            * @throws SystemException if a system exception occurred
1229            */
1230            public static com.liferay.portal.model.Group removeByC_F(long companyId,
1231                    java.lang.String friendlyURL)
1232                    throws com.liferay.portal.NoSuchGroupException,
1233                            com.liferay.portal.kernel.exception.SystemException {
1234                    return getPersistence().removeByC_F(companyId, friendlyURL);
1235            }
1236    
1237            /**
1238            * Returns the number of groups where companyId = &#63; and friendlyURL = &#63;.
1239            *
1240            * @param companyId the company ID
1241            * @param friendlyURL the friendly u r l
1242            * @return the number of matching groups
1243            * @throws SystemException if a system exception occurred
1244            */
1245            public static int countByC_F(long companyId, java.lang.String friendlyURL)
1246                    throws com.liferay.portal.kernel.exception.SystemException {
1247                    return getPersistence().countByC_F(companyId, friendlyURL);
1248            }
1249    
1250            /**
1251            * Returns all the groups where companyId = &#63; and site = &#63;.
1252            *
1253            * @param companyId the company ID
1254            * @param site the site
1255            * @return the matching groups
1256            * @throws SystemException if a system exception occurred
1257            */
1258            public static java.util.List<com.liferay.portal.model.Group> findByC_S(
1259                    long companyId, boolean site)
1260                    throws com.liferay.portal.kernel.exception.SystemException {
1261                    return getPersistence().findByC_S(companyId, site);
1262            }
1263    
1264            /**
1265            * Returns a range of all the groups where companyId = &#63; and site = &#63;.
1266            *
1267            * <p>
1268            * 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.
1269            * </p>
1270            *
1271            * @param companyId the company ID
1272            * @param site the site
1273            * @param start the lower bound of the range of groups
1274            * @param end the upper bound of the range of groups (not inclusive)
1275            * @return the range of matching groups
1276            * @throws SystemException if a system exception occurred
1277            */
1278            public static java.util.List<com.liferay.portal.model.Group> findByC_S(
1279                    long companyId, boolean site, int start, int end)
1280                    throws com.liferay.portal.kernel.exception.SystemException {
1281                    return getPersistence().findByC_S(companyId, site, start, end);
1282            }
1283    
1284            /**
1285            * Returns an ordered range of all the groups where companyId = &#63; and site = &#63;.
1286            *
1287            * <p>
1288            * 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.
1289            * </p>
1290            *
1291            * @param companyId the company ID
1292            * @param site the site
1293            * @param start the lower bound of the range of groups
1294            * @param end the upper bound of the range of groups (not inclusive)
1295            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1296            * @return the ordered range of matching groups
1297            * @throws SystemException if a system exception occurred
1298            */
1299            public static java.util.List<com.liferay.portal.model.Group> findByC_S(
1300                    long companyId, boolean site, int start, int end,
1301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1302                    throws com.liferay.portal.kernel.exception.SystemException {
1303                    return getPersistence()
1304                                       .findByC_S(companyId, site, start, end, orderByComparator);
1305            }
1306    
1307            /**
1308            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
1309            *
1310            * @param companyId the company ID
1311            * @param site the site
1312            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1313            * @return the first matching group
1314            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1315            * @throws SystemException if a system exception occurred
1316            */
1317            public static com.liferay.portal.model.Group findByC_S_First(
1318                    long companyId, boolean site,
1319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1320                    throws com.liferay.portal.NoSuchGroupException,
1321                            com.liferay.portal.kernel.exception.SystemException {
1322                    return getPersistence()
1323                                       .findByC_S_First(companyId, site, orderByComparator);
1324            }
1325    
1326            /**
1327            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
1328            *
1329            * @param companyId the company ID
1330            * @param site the site
1331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1332            * @return the first matching group, or <code>null</code> if a matching group could not be found
1333            * @throws SystemException if a system exception occurred
1334            */
1335            public static com.liferay.portal.model.Group fetchByC_S_First(
1336                    long companyId, boolean site,
1337                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1338                    throws com.liferay.portal.kernel.exception.SystemException {
1339                    return getPersistence()
1340                                       .fetchByC_S_First(companyId, site, orderByComparator);
1341            }
1342    
1343            /**
1344            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
1345            *
1346            * @param companyId the company ID
1347            * @param site the site
1348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1349            * @return the last matching group
1350            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1351            * @throws SystemException if a system exception occurred
1352            */
1353            public static com.liferay.portal.model.Group findByC_S_Last(
1354                    long companyId, boolean site,
1355                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1356                    throws com.liferay.portal.NoSuchGroupException,
1357                            com.liferay.portal.kernel.exception.SystemException {
1358                    return getPersistence()
1359                                       .findByC_S_Last(companyId, site, orderByComparator);
1360            }
1361    
1362            /**
1363            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
1364            *
1365            * @param companyId the company ID
1366            * @param site the site
1367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1368            * @return the last matching group, or <code>null</code> if a matching group could not be found
1369            * @throws SystemException if a system exception occurred
1370            */
1371            public static com.liferay.portal.model.Group fetchByC_S_Last(
1372                    long companyId, boolean site,
1373                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1374                    throws com.liferay.portal.kernel.exception.SystemException {
1375                    return getPersistence()
1376                                       .fetchByC_S_Last(companyId, site, orderByComparator);
1377            }
1378    
1379            /**
1380            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and site = &#63;.
1381            *
1382            * @param groupId the primary key of the current group
1383            * @param companyId the company ID
1384            * @param site the site
1385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1386            * @return the previous, current, and next group
1387            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
1388            * @throws SystemException if a system exception occurred
1389            */
1390            public static com.liferay.portal.model.Group[] findByC_S_PrevAndNext(
1391                    long groupId, long companyId, boolean site,
1392                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1393                    throws com.liferay.portal.NoSuchGroupException,
1394                            com.liferay.portal.kernel.exception.SystemException {
1395                    return getPersistence()
1396                                       .findByC_S_PrevAndNext(groupId, companyId, site,
1397                            orderByComparator);
1398            }
1399    
1400            /**
1401            * Removes all the groups where companyId = &#63; and site = &#63; from the database.
1402            *
1403            * @param companyId the company ID
1404            * @param site the site
1405            * @throws SystemException if a system exception occurred
1406            */
1407            public static void removeByC_S(long companyId, boolean site)
1408                    throws com.liferay.portal.kernel.exception.SystemException {
1409                    getPersistence().removeByC_S(companyId, site);
1410            }
1411    
1412            /**
1413            * Returns the number of groups where companyId = &#63; and site = &#63;.
1414            *
1415            * @param companyId the company ID
1416            * @param site the site
1417            * @return the number of matching groups
1418            * @throws SystemException if a system exception occurred
1419            */
1420            public static int countByC_S(long companyId, boolean site)
1421                    throws com.liferay.portal.kernel.exception.SystemException {
1422                    return getPersistence().countByC_S(companyId, site);
1423            }
1424    
1425            /**
1426            * Returns all the groups where type = &#63; and active = &#63;.
1427            *
1428            * @param type the type
1429            * @param active the active
1430            * @return the matching groups
1431            * @throws SystemException if a system exception occurred
1432            */
1433            public static java.util.List<com.liferay.portal.model.Group> findByT_A(
1434                    int type, boolean active)
1435                    throws com.liferay.portal.kernel.exception.SystemException {
1436                    return getPersistence().findByT_A(type, active);
1437            }
1438    
1439            /**
1440            * Returns a range of all the groups where type = &#63; and active = &#63;.
1441            *
1442            * <p>
1443            * 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.
1444            * </p>
1445            *
1446            * @param type the type
1447            * @param active the active
1448            * @param start the lower bound of the range of groups
1449            * @param end the upper bound of the range of groups (not inclusive)
1450            * @return the range of matching groups
1451            * @throws SystemException if a system exception occurred
1452            */
1453            public static java.util.List<com.liferay.portal.model.Group> findByT_A(
1454                    int type, boolean active, int start, int end)
1455                    throws com.liferay.portal.kernel.exception.SystemException {
1456                    return getPersistence().findByT_A(type, active, start, end);
1457            }
1458    
1459            /**
1460            * Returns an ordered range of all the groups where type = &#63; and active = &#63;.
1461            *
1462            * <p>
1463            * 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.
1464            * </p>
1465            *
1466            * @param type the type
1467            * @param active the active
1468            * @param start the lower bound of the range of groups
1469            * @param end the upper bound of the range of groups (not inclusive)
1470            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1471            * @return the ordered range of matching groups
1472            * @throws SystemException if a system exception occurred
1473            */
1474            public static java.util.List<com.liferay.portal.model.Group> findByT_A(
1475                    int type, boolean active, int start, int end,
1476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1477                    throws com.liferay.portal.kernel.exception.SystemException {
1478                    return getPersistence()
1479                                       .findByT_A(type, active, start, end, orderByComparator);
1480            }
1481    
1482            /**
1483            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1484            *
1485            * @param type the type
1486            * @param active the active
1487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1488            * @return the first matching group
1489            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1490            * @throws SystemException if a system exception occurred
1491            */
1492            public static com.liferay.portal.model.Group findByT_A_First(int type,
1493                    boolean active,
1494                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1495                    throws com.liferay.portal.NoSuchGroupException,
1496                            com.liferay.portal.kernel.exception.SystemException {
1497                    return getPersistence().findByT_A_First(type, active, orderByComparator);
1498            }
1499    
1500            /**
1501            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1502            *
1503            * @param type the type
1504            * @param active the active
1505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1506            * @return the first matching group, or <code>null</code> if a matching group could not be found
1507            * @throws SystemException if a system exception occurred
1508            */
1509            public static com.liferay.portal.model.Group fetchByT_A_First(int type,
1510                    boolean active,
1511                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1512                    throws com.liferay.portal.kernel.exception.SystemException {
1513                    return getPersistence().fetchByT_A_First(type, active, orderByComparator);
1514            }
1515    
1516            /**
1517            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1518            *
1519            * @param type the type
1520            * @param active the active
1521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1522            * @return the last matching group
1523            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1524            * @throws SystemException if a system exception occurred
1525            */
1526            public static com.liferay.portal.model.Group findByT_A_Last(int type,
1527                    boolean active,
1528                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1529                    throws com.liferay.portal.NoSuchGroupException,
1530                            com.liferay.portal.kernel.exception.SystemException {
1531                    return getPersistence().findByT_A_Last(type, active, orderByComparator);
1532            }
1533    
1534            /**
1535            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1536            *
1537            * @param type the type
1538            * @param active the active
1539            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1540            * @return the last matching group, or <code>null</code> if a matching group could not be found
1541            * @throws SystemException if a system exception occurred
1542            */
1543            public static com.liferay.portal.model.Group fetchByT_A_Last(int type,
1544                    boolean active,
1545                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1546                    throws com.liferay.portal.kernel.exception.SystemException {
1547                    return getPersistence().fetchByT_A_Last(type, active, orderByComparator);
1548            }
1549    
1550            /**
1551            * Returns the groups before and after the current group in the ordered set where type = &#63; and active = &#63;.
1552            *
1553            * @param groupId the primary key of the current group
1554            * @param type the type
1555            * @param active the active
1556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1557            * @return the previous, current, and next group
1558            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
1559            * @throws SystemException if a system exception occurred
1560            */
1561            public static com.liferay.portal.model.Group[] findByT_A_PrevAndNext(
1562                    long groupId, int type, boolean active,
1563                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1564                    throws com.liferay.portal.NoSuchGroupException,
1565                            com.liferay.portal.kernel.exception.SystemException {
1566                    return getPersistence()
1567                                       .findByT_A_PrevAndNext(groupId, type, active,
1568                            orderByComparator);
1569            }
1570    
1571            /**
1572            * Removes all the groups where type = &#63; and active = &#63; from the database.
1573            *
1574            * @param type the type
1575            * @param active the active
1576            * @throws SystemException if a system exception occurred
1577            */
1578            public static void removeByT_A(int type, boolean active)
1579                    throws com.liferay.portal.kernel.exception.SystemException {
1580                    getPersistence().removeByT_A(type, active);
1581            }
1582    
1583            /**
1584            * Returns the number of groups where type = &#63; and active = &#63;.
1585            *
1586            * @param type the type
1587            * @param active the active
1588            * @return the number of matching groups
1589            * @throws SystemException if a system exception occurred
1590            */
1591            public static int countByT_A(int type, boolean active)
1592                    throws com.liferay.portal.kernel.exception.SystemException {
1593                    return getPersistence().countByT_A(type, active);
1594            }
1595    
1596            /**
1597            * 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.
1598            *
1599            * @param companyId the company ID
1600            * @param classNameId the class name ID
1601            * @param classPK the class p k
1602            * @return the matching group
1603            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1604            * @throws SystemException if a system exception occurred
1605            */
1606            public static com.liferay.portal.model.Group findByC_C_C(long companyId,
1607                    long classNameId, long classPK)
1608                    throws com.liferay.portal.NoSuchGroupException,
1609                            com.liferay.portal.kernel.exception.SystemException {
1610                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
1611            }
1612    
1613            /**
1614            * 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.
1615            *
1616            * @param companyId the company ID
1617            * @param classNameId the class name ID
1618            * @param classPK the class p k
1619            * @return the matching group, or <code>null</code> if a matching group could not be found
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static com.liferay.portal.model.Group fetchByC_C_C(long companyId,
1623                    long classNameId, long classPK)
1624                    throws com.liferay.portal.kernel.exception.SystemException {
1625                    return getPersistence().fetchByC_C_C(companyId, classNameId, classPK);
1626            }
1627    
1628            /**
1629            * 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.
1630            *
1631            * @param companyId the company ID
1632            * @param classNameId the class name ID
1633            * @param classPK the class p k
1634            * @param retrieveFromCache whether to use the finder cache
1635            * @return the matching group, or <code>null</code> if a matching group could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portal.model.Group fetchByC_C_C(long companyId,
1639                    long classNameId, long classPK, boolean retrieveFromCache)
1640                    throws com.liferay.portal.kernel.exception.SystemException {
1641                    return getPersistence()
1642                                       .fetchByC_C_C(companyId, classNameId, classPK,
1643                            retrieveFromCache);
1644            }
1645    
1646            /**
1647            * Removes the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1648            *
1649            * @param companyId the company ID
1650            * @param classNameId the class name ID
1651            * @param classPK the class p k
1652            * @return the group that was removed
1653            * @throws SystemException if a system exception occurred
1654            */
1655            public static com.liferay.portal.model.Group removeByC_C_C(long companyId,
1656                    long classNameId, long classPK)
1657                    throws com.liferay.portal.NoSuchGroupException,
1658                            com.liferay.portal.kernel.exception.SystemException {
1659                    return getPersistence().removeByC_C_C(companyId, classNameId, classPK);
1660            }
1661    
1662            /**
1663            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1664            *
1665            * @param companyId the company ID
1666            * @param classNameId the class name ID
1667            * @param classPK the class p k
1668            * @return the number of matching groups
1669            * @throws SystemException if a system exception occurred
1670            */
1671            public static int countByC_C_C(long companyId, long classNameId,
1672                    long classPK)
1673                    throws com.liferay.portal.kernel.exception.SystemException {
1674                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
1675            }
1676    
1677            /**
1678            * Returns all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1679            *
1680            * @param companyId the company ID
1681            * @param classNameId the class name ID
1682            * @param parentGroupId the parent group ID
1683            * @return the matching groups
1684            * @throws SystemException if a system exception occurred
1685            */
1686            public static java.util.List<com.liferay.portal.model.Group> findByC_C_P(
1687                    long companyId, long classNameId, long parentGroupId)
1688                    throws com.liferay.portal.kernel.exception.SystemException {
1689                    return getPersistence()
1690                                       .findByC_C_P(companyId, classNameId, parentGroupId);
1691            }
1692    
1693            /**
1694            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1695            *
1696            * <p>
1697            * 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.
1698            * </p>
1699            *
1700            * @param companyId the company ID
1701            * @param classNameId the class name ID
1702            * @param parentGroupId the parent group ID
1703            * @param start the lower bound of the range of groups
1704            * @param end the upper bound of the range of groups (not inclusive)
1705            * @return the range of matching groups
1706            * @throws SystemException if a system exception occurred
1707            */
1708            public static java.util.List<com.liferay.portal.model.Group> findByC_C_P(
1709                    long companyId, long classNameId, long parentGroupId, int start, int end)
1710                    throws com.liferay.portal.kernel.exception.SystemException {
1711                    return getPersistence()
1712                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1713                            end);
1714            }
1715    
1716            /**
1717            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1718            *
1719            * <p>
1720            * 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.
1721            * </p>
1722            *
1723            * @param companyId the company ID
1724            * @param classNameId the class name ID
1725            * @param parentGroupId the parent group ID
1726            * @param start the lower bound of the range of groups
1727            * @param end the upper bound of the range of groups (not inclusive)
1728            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1729            * @return the ordered range of matching groups
1730            * @throws SystemException if a system exception occurred
1731            */
1732            public static java.util.List<com.liferay.portal.model.Group> findByC_C_P(
1733                    long companyId, long classNameId, long parentGroupId, int start,
1734                    int end,
1735                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1736                    throws com.liferay.portal.kernel.exception.SystemException {
1737                    return getPersistence()
1738                                       .findByC_C_P(companyId, classNameId, parentGroupId, start,
1739                            end, orderByComparator);
1740            }
1741    
1742            /**
1743            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1744            *
1745            * @param companyId the company ID
1746            * @param classNameId the class name ID
1747            * @param parentGroupId the parent group ID
1748            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1749            * @return the first matching group
1750            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1751            * @throws SystemException if a system exception occurred
1752            */
1753            public static com.liferay.portal.model.Group findByC_C_P_First(
1754                    long companyId, long classNameId, long parentGroupId,
1755                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1756                    throws com.liferay.portal.NoSuchGroupException,
1757                            com.liferay.portal.kernel.exception.SystemException {
1758                    return getPersistence()
1759                                       .findByC_C_P_First(companyId, classNameId, parentGroupId,
1760                            orderByComparator);
1761            }
1762    
1763            /**
1764            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1765            *
1766            * @param companyId the company ID
1767            * @param classNameId the class name ID
1768            * @param parentGroupId the parent group ID
1769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1770            * @return the first matching group, or <code>null</code> if a matching group could not be found
1771            * @throws SystemException if a system exception occurred
1772            */
1773            public static com.liferay.portal.model.Group fetchByC_C_P_First(
1774                    long companyId, long classNameId, long parentGroupId,
1775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1776                    throws com.liferay.portal.kernel.exception.SystemException {
1777                    return getPersistence()
1778                                       .fetchByC_C_P_First(companyId, classNameId, parentGroupId,
1779                            orderByComparator);
1780            }
1781    
1782            /**
1783            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1784            *
1785            * @param companyId the company ID
1786            * @param classNameId the class name ID
1787            * @param parentGroupId the parent group ID
1788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1789            * @return the last matching group
1790            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1791            * @throws SystemException if a system exception occurred
1792            */
1793            public static com.liferay.portal.model.Group findByC_C_P_Last(
1794                    long companyId, long classNameId, long parentGroupId,
1795                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1796                    throws com.liferay.portal.NoSuchGroupException,
1797                            com.liferay.portal.kernel.exception.SystemException {
1798                    return getPersistence()
1799                                       .findByC_C_P_Last(companyId, classNameId, parentGroupId,
1800                            orderByComparator);
1801            }
1802    
1803            /**
1804            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1805            *
1806            * @param companyId the company ID
1807            * @param classNameId the class name ID
1808            * @param parentGroupId the parent group ID
1809            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1810            * @return the last matching group, or <code>null</code> if a matching group could not be found
1811            * @throws SystemException if a system exception occurred
1812            */
1813            public static com.liferay.portal.model.Group fetchByC_C_P_Last(
1814                    long companyId, long classNameId, long parentGroupId,
1815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1816                    throws com.liferay.portal.kernel.exception.SystemException {
1817                    return getPersistence()
1818                                       .fetchByC_C_P_Last(companyId, classNameId, parentGroupId,
1819                            orderByComparator);
1820            }
1821    
1822            /**
1823            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1824            *
1825            * @param groupId the primary key of the current group
1826            * @param companyId the company ID
1827            * @param classNameId the class name ID
1828            * @param parentGroupId the parent group ID
1829            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1830            * @return the previous, current, and next group
1831            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
1832            * @throws SystemException if a system exception occurred
1833            */
1834            public static com.liferay.portal.model.Group[] findByC_C_P_PrevAndNext(
1835                    long groupId, long companyId, long classNameId, long parentGroupId,
1836                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1837                    throws com.liferay.portal.NoSuchGroupException,
1838                            com.liferay.portal.kernel.exception.SystemException {
1839                    return getPersistence()
1840                                       .findByC_C_P_PrevAndNext(groupId, companyId, classNameId,
1841                            parentGroupId, orderByComparator);
1842            }
1843    
1844            /**
1845            * Removes all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
1846            *
1847            * @param companyId the company ID
1848            * @param classNameId the class name ID
1849            * @param parentGroupId the parent group ID
1850            * @throws SystemException if a system exception occurred
1851            */
1852            public static void removeByC_C_P(long companyId, long classNameId,
1853                    long parentGroupId)
1854                    throws com.liferay.portal.kernel.exception.SystemException {
1855                    getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId);
1856            }
1857    
1858            /**
1859            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1860            *
1861            * @param companyId the company ID
1862            * @param classNameId the class name ID
1863            * @param parentGroupId the parent group ID
1864            * @return the number of matching groups
1865            * @throws SystemException if a system exception occurred
1866            */
1867            public static int countByC_C_P(long companyId, long classNameId,
1868                    long parentGroupId)
1869                    throws com.liferay.portal.kernel.exception.SystemException {
1870                    return getPersistence()
1871                                       .countByC_C_P(companyId, classNameId, parentGroupId);
1872            }
1873    
1874            /**
1875            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1876            *
1877            * @param companyId the company ID
1878            * @param parentGroupId the parent group ID
1879            * @param site the site
1880            * @return the matching groups
1881            * @throws SystemException if a system exception occurred
1882            */
1883            public static java.util.List<com.liferay.portal.model.Group> findByC_P_S(
1884                    long companyId, long parentGroupId, boolean site)
1885                    throws com.liferay.portal.kernel.exception.SystemException {
1886                    return getPersistence().findByC_P_S(companyId, parentGroupId, site);
1887            }
1888    
1889            /**
1890            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1891            *
1892            * <p>
1893            * 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.
1894            * </p>
1895            *
1896            * @param companyId the company ID
1897            * @param parentGroupId the parent group ID
1898            * @param site the site
1899            * @param start the lower bound of the range of groups
1900            * @param end the upper bound of the range of groups (not inclusive)
1901            * @return the range of matching groups
1902            * @throws SystemException if a system exception occurred
1903            */
1904            public static java.util.List<com.liferay.portal.model.Group> findByC_P_S(
1905                    long companyId, long parentGroupId, boolean site, int start, int end)
1906                    throws com.liferay.portal.kernel.exception.SystemException {
1907                    return getPersistence()
1908                                       .findByC_P_S(companyId, parentGroupId, site, start, end);
1909            }
1910    
1911            /**
1912            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1913            *
1914            * <p>
1915            * 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.
1916            * </p>
1917            *
1918            * @param companyId the company ID
1919            * @param parentGroupId the parent group ID
1920            * @param site the site
1921            * @param start the lower bound of the range of groups
1922            * @param end the upper bound of the range of groups (not inclusive)
1923            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1924            * @return the ordered range of matching groups
1925            * @throws SystemException if a system exception occurred
1926            */
1927            public static java.util.List<com.liferay.portal.model.Group> findByC_P_S(
1928                    long companyId, long parentGroupId, boolean site, int start, int end,
1929                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1930                    throws com.liferay.portal.kernel.exception.SystemException {
1931                    return getPersistence()
1932                                       .findByC_P_S(companyId, parentGroupId, site, start, end,
1933                            orderByComparator);
1934            }
1935    
1936            /**
1937            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1938            *
1939            * @param companyId the company ID
1940            * @param parentGroupId the parent group ID
1941            * @param site the site
1942            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1943            * @return the first matching group
1944            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1945            * @throws SystemException if a system exception occurred
1946            */
1947            public static com.liferay.portal.model.Group findByC_P_S_First(
1948                    long companyId, long parentGroupId, boolean site,
1949                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1950                    throws com.liferay.portal.NoSuchGroupException,
1951                            com.liferay.portal.kernel.exception.SystemException {
1952                    return getPersistence()
1953                                       .findByC_P_S_First(companyId, parentGroupId, site,
1954                            orderByComparator);
1955            }
1956    
1957            /**
1958            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1959            *
1960            * @param companyId the company ID
1961            * @param parentGroupId the parent group ID
1962            * @param site the site
1963            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1964            * @return the first matching group, or <code>null</code> if a matching group could not be found
1965            * @throws SystemException if a system exception occurred
1966            */
1967            public static com.liferay.portal.model.Group fetchByC_P_S_First(
1968                    long companyId, long parentGroupId, boolean site,
1969                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1970                    throws com.liferay.portal.kernel.exception.SystemException {
1971                    return getPersistence()
1972                                       .fetchByC_P_S_First(companyId, parentGroupId, site,
1973                            orderByComparator);
1974            }
1975    
1976            /**
1977            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1978            *
1979            * @param companyId the company ID
1980            * @param parentGroupId the parent group ID
1981            * @param site the site
1982            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1983            * @return the last matching group
1984            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
1985            * @throws SystemException if a system exception occurred
1986            */
1987            public static com.liferay.portal.model.Group findByC_P_S_Last(
1988                    long companyId, long parentGroupId, boolean site,
1989                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1990                    throws com.liferay.portal.NoSuchGroupException,
1991                            com.liferay.portal.kernel.exception.SystemException {
1992                    return getPersistence()
1993                                       .findByC_P_S_Last(companyId, parentGroupId, site,
1994                            orderByComparator);
1995            }
1996    
1997            /**
1998            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1999            *
2000            * @param companyId the company ID
2001            * @param parentGroupId the parent group ID
2002            * @param site the site
2003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2004            * @return the last matching group, or <code>null</code> if a matching group could not be found
2005            * @throws SystemException if a system exception occurred
2006            */
2007            public static com.liferay.portal.model.Group fetchByC_P_S_Last(
2008                    long companyId, long parentGroupId, boolean site,
2009                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    return getPersistence()
2012                                       .fetchByC_P_S_Last(companyId, parentGroupId, site,
2013                            orderByComparator);
2014            }
2015    
2016            /**
2017            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2018            *
2019            * @param groupId the primary key of the current group
2020            * @param companyId the company ID
2021            * @param parentGroupId the parent group ID
2022            * @param site the site
2023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2024            * @return the previous, current, and next group
2025            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
2026            * @throws SystemException if a system exception occurred
2027            */
2028            public static com.liferay.portal.model.Group[] findByC_P_S_PrevAndNext(
2029                    long groupId, long companyId, long parentGroupId, boolean site,
2030                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2031                    throws com.liferay.portal.NoSuchGroupException,
2032                            com.liferay.portal.kernel.exception.SystemException {
2033                    return getPersistence()
2034                                       .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId,
2035                            site, orderByComparator);
2036            }
2037    
2038            /**
2039            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; from the database.
2040            *
2041            * @param companyId the company ID
2042            * @param parentGroupId the parent group ID
2043            * @param site the site
2044            * @throws SystemException if a system exception occurred
2045            */
2046            public static void removeByC_P_S(long companyId, long parentGroupId,
2047                    boolean site)
2048                    throws com.liferay.portal.kernel.exception.SystemException {
2049                    getPersistence().removeByC_P_S(companyId, parentGroupId, site);
2050            }
2051    
2052            /**
2053            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
2054            *
2055            * @param companyId the company ID
2056            * @param parentGroupId the parent group ID
2057            * @param site the site
2058            * @return the number of matching groups
2059            * @throws SystemException if a system exception occurred
2060            */
2061            public static int countByC_P_S(long companyId, long parentGroupId,
2062                    boolean site)
2063                    throws com.liferay.portal.kernel.exception.SystemException {
2064                    return getPersistence().countByC_P_S(companyId, parentGroupId, site);
2065            }
2066    
2067            /**
2068            * 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.
2069            *
2070            * @param companyId the company ID
2071            * @param liveGroupId the live group ID
2072            * @param name the name
2073            * @return the matching group
2074            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
2075            * @throws SystemException if a system exception occurred
2076            */
2077            public static com.liferay.portal.model.Group findByC_L_N(long companyId,
2078                    long liveGroupId, java.lang.String name)
2079                    throws com.liferay.portal.NoSuchGroupException,
2080                            com.liferay.portal.kernel.exception.SystemException {
2081                    return getPersistence().findByC_L_N(companyId, liveGroupId, name);
2082            }
2083    
2084            /**
2085            * 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.
2086            *
2087            * @param companyId the company ID
2088            * @param liveGroupId the live group ID
2089            * @param name the name
2090            * @return the matching group, or <code>null</code> if a matching group could not be found
2091            * @throws SystemException if a system exception occurred
2092            */
2093            public static com.liferay.portal.model.Group fetchByC_L_N(long companyId,
2094                    long liveGroupId, java.lang.String name)
2095                    throws com.liferay.portal.kernel.exception.SystemException {
2096                    return getPersistence().fetchByC_L_N(companyId, liveGroupId, name);
2097            }
2098    
2099            /**
2100            * 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.
2101            *
2102            * @param companyId the company ID
2103            * @param liveGroupId the live group ID
2104            * @param name the name
2105            * @param retrieveFromCache whether to use the finder cache
2106            * @return the matching group, or <code>null</code> if a matching group could not be found
2107            * @throws SystemException if a system exception occurred
2108            */
2109            public static com.liferay.portal.model.Group fetchByC_L_N(long companyId,
2110                    long liveGroupId, java.lang.String name, boolean retrieveFromCache)
2111                    throws com.liferay.portal.kernel.exception.SystemException {
2112                    return getPersistence()
2113                                       .fetchByC_L_N(companyId, liveGroupId, name, retrieveFromCache);
2114            }
2115    
2116            /**
2117            * Removes the group where companyId = &#63; and liveGroupId = &#63; and name = &#63; from the database.
2118            *
2119            * @param companyId the company ID
2120            * @param liveGroupId the live group ID
2121            * @param name the name
2122            * @return the group that was removed
2123            * @throws SystemException if a system exception occurred
2124            */
2125            public static com.liferay.portal.model.Group removeByC_L_N(long companyId,
2126                    long liveGroupId, java.lang.String name)
2127                    throws com.liferay.portal.NoSuchGroupException,
2128                            com.liferay.portal.kernel.exception.SystemException {
2129                    return getPersistence().removeByC_L_N(companyId, liveGroupId, name);
2130            }
2131    
2132            /**
2133            * Returns the number of groups where companyId = &#63; and liveGroupId = &#63; and name = &#63;.
2134            *
2135            * @param companyId the company ID
2136            * @param liveGroupId the live group ID
2137            * @param name the name
2138            * @return the number of matching groups
2139            * @throws SystemException if a system exception occurred
2140            */
2141            public static int countByC_L_N(long companyId, long liveGroupId,
2142                    java.lang.String name)
2143                    throws com.liferay.portal.kernel.exception.SystemException {
2144                    return getPersistence().countByC_L_N(companyId, liveGroupId, name);
2145            }
2146    
2147            /**
2148            * 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.
2149            *
2150            * @param companyId the company ID
2151            * @param classNameId the class name ID
2152            * @param liveGroupId the live group ID
2153            * @param name the name
2154            * @return the matching group
2155            * @throws com.liferay.portal.NoSuchGroupException if a matching group could not be found
2156            * @throws SystemException if a system exception occurred
2157            */
2158            public static com.liferay.portal.model.Group findByC_C_L_N(long companyId,
2159                    long classNameId, long liveGroupId, java.lang.String name)
2160                    throws com.liferay.portal.NoSuchGroupException,
2161                            com.liferay.portal.kernel.exception.SystemException {
2162                    return getPersistence()
2163                                       .findByC_C_L_N(companyId, classNameId, liveGroupId, name);
2164            }
2165    
2166            /**
2167            * 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.
2168            *
2169            * @param companyId the company ID
2170            * @param classNameId the class name ID
2171            * @param liveGroupId the live group ID
2172            * @param name the name
2173            * @return the matching group, or <code>null</code> if a matching group could not be found
2174            * @throws SystemException if a system exception occurred
2175            */
2176            public static com.liferay.portal.model.Group fetchByC_C_L_N(
2177                    long companyId, long classNameId, long liveGroupId,
2178                    java.lang.String name)
2179                    throws com.liferay.portal.kernel.exception.SystemException {
2180                    return getPersistence()
2181                                       .fetchByC_C_L_N(companyId, classNameId, liveGroupId, name);
2182            }
2183    
2184            /**
2185            * 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.
2186            *
2187            * @param companyId the company ID
2188            * @param classNameId the class name ID
2189            * @param liveGroupId the live group ID
2190            * @param name the name
2191            * @param retrieveFromCache whether to use the finder cache
2192            * @return the matching group, or <code>null</code> if a matching group could not be found
2193            * @throws SystemException if a system exception occurred
2194            */
2195            public static com.liferay.portal.model.Group fetchByC_C_L_N(
2196                    long companyId, long classNameId, long liveGroupId,
2197                    java.lang.String name, boolean retrieveFromCache)
2198                    throws com.liferay.portal.kernel.exception.SystemException {
2199                    return getPersistence()
2200                                       .fetchByC_C_L_N(companyId, classNameId, liveGroupId, name,
2201                            retrieveFromCache);
2202            }
2203    
2204            /**
2205            * Removes the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and name = &#63; from the database.
2206            *
2207            * @param companyId the company ID
2208            * @param classNameId the class name ID
2209            * @param liveGroupId the live group ID
2210            * @param name the name
2211            * @return the group that was removed
2212            * @throws SystemException if a system exception occurred
2213            */
2214            public static com.liferay.portal.model.Group removeByC_C_L_N(
2215                    long companyId, long classNameId, long liveGroupId,
2216                    java.lang.String name)
2217                    throws com.liferay.portal.NoSuchGroupException,
2218                            com.liferay.portal.kernel.exception.SystemException {
2219                    return getPersistence()
2220                                       .removeByC_C_L_N(companyId, classNameId, liveGroupId, name);
2221            }
2222    
2223            /**
2224            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and name = &#63;.
2225            *
2226            * @param companyId the company ID
2227            * @param classNameId the class name ID
2228            * @param liveGroupId the live group ID
2229            * @param name the name
2230            * @return the number of matching groups
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static int countByC_C_L_N(long companyId, long classNameId,
2234                    long liveGroupId, java.lang.String name)
2235                    throws com.liferay.portal.kernel.exception.SystemException {
2236                    return getPersistence()
2237                                       .countByC_C_L_N(companyId, classNameId, liveGroupId, name);
2238            }
2239    
2240            /**
2241            * Caches the group in the entity cache if it is enabled.
2242            *
2243            * @param group the group
2244            */
2245            public static void cacheResult(com.liferay.portal.model.Group group) {
2246                    getPersistence().cacheResult(group);
2247            }
2248    
2249            /**
2250            * Caches the groups in the entity cache if it is enabled.
2251            *
2252            * @param groups the groups
2253            */
2254            public static void cacheResult(
2255                    java.util.List<com.liferay.portal.model.Group> groups) {
2256                    getPersistence().cacheResult(groups);
2257            }
2258    
2259            /**
2260            * Creates a new group with the primary key. Does not add the group to the database.
2261            *
2262            * @param groupId the primary key for the new group
2263            * @return the new group
2264            */
2265            public static com.liferay.portal.model.Group create(long groupId) {
2266                    return getPersistence().create(groupId);
2267            }
2268    
2269            /**
2270            * Removes the group with the primary key from the database. Also notifies the appropriate model listeners.
2271            *
2272            * @param groupId the primary key of the group
2273            * @return the group that was removed
2274            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
2275            * @throws SystemException if a system exception occurred
2276            */
2277            public static com.liferay.portal.model.Group remove(long groupId)
2278                    throws com.liferay.portal.NoSuchGroupException,
2279                            com.liferay.portal.kernel.exception.SystemException {
2280                    return getPersistence().remove(groupId);
2281            }
2282    
2283            public static com.liferay.portal.model.Group updateImpl(
2284                    com.liferay.portal.model.Group group)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence().updateImpl(group);
2287            }
2288    
2289            /**
2290            * Returns the group with the primary key or throws a {@link com.liferay.portal.NoSuchGroupException} if it could not be found.
2291            *
2292            * @param groupId the primary key of the group
2293            * @return the group
2294            * @throws com.liferay.portal.NoSuchGroupException if a group with the primary key could not be found
2295            * @throws SystemException if a system exception occurred
2296            */
2297            public static com.liferay.portal.model.Group findByPrimaryKey(long groupId)
2298                    throws com.liferay.portal.NoSuchGroupException,
2299                            com.liferay.portal.kernel.exception.SystemException {
2300                    return getPersistence().findByPrimaryKey(groupId);
2301            }
2302    
2303            /**
2304            * Returns the group with the primary key or returns <code>null</code> if it could not be found.
2305            *
2306            * @param groupId the primary key of the group
2307            * @return the group, or <code>null</code> if a group with the primary key could not be found
2308            * @throws SystemException if a system exception occurred
2309            */
2310            public static com.liferay.portal.model.Group fetchByPrimaryKey(long groupId)
2311                    throws com.liferay.portal.kernel.exception.SystemException {
2312                    return getPersistence().fetchByPrimaryKey(groupId);
2313            }
2314    
2315            /**
2316            * Returns all the groups.
2317            *
2318            * @return the groups
2319            * @throws SystemException if a system exception occurred
2320            */
2321            public static java.util.List<com.liferay.portal.model.Group> findAll()
2322                    throws com.liferay.portal.kernel.exception.SystemException {
2323                    return getPersistence().findAll();
2324            }
2325    
2326            /**
2327            * Returns a range of all the groups.
2328            *
2329            * <p>
2330            * 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.
2331            * </p>
2332            *
2333            * @param start the lower bound of the range of groups
2334            * @param end the upper bound of the range of groups (not inclusive)
2335            * @return the range of groups
2336            * @throws SystemException if a system exception occurred
2337            */
2338            public static java.util.List<com.liferay.portal.model.Group> findAll(
2339                    int start, int end)
2340                    throws com.liferay.portal.kernel.exception.SystemException {
2341                    return getPersistence().findAll(start, end);
2342            }
2343    
2344            /**
2345            * Returns an ordered range of all the groups.
2346            *
2347            * <p>
2348            * 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.
2349            * </p>
2350            *
2351            * @param start the lower bound of the range of groups
2352            * @param end the upper bound of the range of groups (not inclusive)
2353            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2354            * @return the ordered range of groups
2355            * @throws SystemException if a system exception occurred
2356            */
2357            public static java.util.List<com.liferay.portal.model.Group> findAll(
2358                    int start, int end,
2359                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2360                    throws com.liferay.portal.kernel.exception.SystemException {
2361                    return getPersistence().findAll(start, end, orderByComparator);
2362            }
2363    
2364            /**
2365            * Removes all the groups from the database.
2366            *
2367            * @throws SystemException if a system exception occurred
2368            */
2369            public static void removeAll()
2370                    throws com.liferay.portal.kernel.exception.SystemException {
2371                    getPersistence().removeAll();
2372            }
2373    
2374            /**
2375            * Returns the number of groups.
2376            *
2377            * @return the number of groups
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static int countAll()
2381                    throws com.liferay.portal.kernel.exception.SystemException {
2382                    return getPersistence().countAll();
2383            }
2384    
2385            /**
2386            * Returns all the organizations associated with the group.
2387            *
2388            * @param pk the primary key of the group
2389            * @return the organizations associated with the group
2390            * @throws SystemException if a system exception occurred
2391            */
2392            public static java.util.List<com.liferay.portal.model.Organization> getOrganizations(
2393                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2394                    return getPersistence().getOrganizations(pk);
2395            }
2396    
2397            /**
2398            * Returns a range of all the organizations associated with the group.
2399            *
2400            * <p>
2401            * 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.
2402            * </p>
2403            *
2404            * @param pk the primary key of the group
2405            * @param start the lower bound of the range of groups
2406            * @param end the upper bound of the range of groups (not inclusive)
2407            * @return the range of organizations associated with the group
2408            * @throws SystemException if a system exception occurred
2409            */
2410            public static java.util.List<com.liferay.portal.model.Organization> getOrganizations(
2411                    long pk, int start, int end)
2412                    throws com.liferay.portal.kernel.exception.SystemException {
2413                    return getPersistence().getOrganizations(pk, start, end);
2414            }
2415    
2416            /**
2417            * Returns an ordered range of all the organizations associated with the group.
2418            *
2419            * <p>
2420            * 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.
2421            * </p>
2422            *
2423            * @param pk the primary key of the group
2424            * @param start the lower bound of the range of groups
2425            * @param end the upper bound of the range of groups (not inclusive)
2426            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2427            * @return the ordered range of organizations associated with the group
2428            * @throws SystemException if a system exception occurred
2429            */
2430            public static java.util.List<com.liferay.portal.model.Organization> getOrganizations(
2431                    long pk, int start, int end,
2432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2433                    throws com.liferay.portal.kernel.exception.SystemException {
2434                    return getPersistence()
2435                                       .getOrganizations(pk, start, end, orderByComparator);
2436            }
2437    
2438            /**
2439            * Returns the number of organizations associated with the group.
2440            *
2441            * @param pk the primary key of the group
2442            * @return the number of organizations associated with the group
2443            * @throws SystemException if a system exception occurred
2444            */
2445            public static int getOrganizationsSize(long pk)
2446                    throws com.liferay.portal.kernel.exception.SystemException {
2447                    return getPersistence().getOrganizationsSize(pk);
2448            }
2449    
2450            /**
2451            * Returns <code>true</code> if the organization is associated with the group.
2452            *
2453            * @param pk the primary key of the group
2454            * @param organizationPK the primary key of the organization
2455            * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise
2456            * @throws SystemException if a system exception occurred
2457            */
2458            public static boolean containsOrganization(long pk, long organizationPK)
2459                    throws com.liferay.portal.kernel.exception.SystemException {
2460                    return getPersistence().containsOrganization(pk, organizationPK);
2461            }
2462    
2463            /**
2464            * Returns <code>true</code> if the group has any organizations associated with it.
2465            *
2466            * @param pk the primary key of the group to check for associations with organizations
2467            * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise
2468            * @throws SystemException if a system exception occurred
2469            */
2470            public static boolean containsOrganizations(long pk)
2471                    throws com.liferay.portal.kernel.exception.SystemException {
2472                    return getPersistence().containsOrganizations(pk);
2473            }
2474    
2475            /**
2476            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2477            *
2478            * @param pk the primary key of the group
2479            * @param organizationPK the primary key of the organization
2480            * @throws SystemException if a system exception occurred
2481            */
2482            public static void addOrganization(long pk, long organizationPK)
2483                    throws com.liferay.portal.kernel.exception.SystemException {
2484                    getPersistence().addOrganization(pk, organizationPK);
2485            }
2486    
2487            /**
2488            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2489            *
2490            * @param pk the primary key of the group
2491            * @param organization the organization
2492            * @throws SystemException if a system exception occurred
2493            */
2494            public static void addOrganization(long pk,
2495                    com.liferay.portal.model.Organization organization)
2496                    throws com.liferay.portal.kernel.exception.SystemException {
2497                    getPersistence().addOrganization(pk, organization);
2498            }
2499    
2500            /**
2501            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2502            *
2503            * @param pk the primary key of the group
2504            * @param organizationPKs the primary keys of the organizations
2505            * @throws SystemException if a system exception occurred
2506            */
2507            public static void addOrganizations(long pk, long[] organizationPKs)
2508                    throws com.liferay.portal.kernel.exception.SystemException {
2509                    getPersistence().addOrganizations(pk, organizationPKs);
2510            }
2511    
2512            /**
2513            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2514            *
2515            * @param pk the primary key of the group
2516            * @param organizations the organizations
2517            * @throws SystemException if a system exception occurred
2518            */
2519            public static void addOrganizations(long pk,
2520                    java.util.List<com.liferay.portal.model.Organization> organizations)
2521                    throws com.liferay.portal.kernel.exception.SystemException {
2522                    getPersistence().addOrganizations(pk, organizations);
2523            }
2524    
2525            /**
2526            * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2527            *
2528            * @param pk the primary key of the group to clear the associated organizations from
2529            * @throws SystemException if a system exception occurred
2530            */
2531            public static void clearOrganizations(long pk)
2532                    throws com.liferay.portal.kernel.exception.SystemException {
2533                    getPersistence().clearOrganizations(pk);
2534            }
2535    
2536            /**
2537            * Removes the association between the group and the organization. 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 organizationPK the primary key of the organization
2541            * @throws SystemException if a system exception occurred
2542            */
2543            public static void removeOrganization(long pk, long organizationPK)
2544                    throws com.liferay.portal.kernel.exception.SystemException {
2545                    getPersistence().removeOrganization(pk, organizationPK);
2546            }
2547    
2548            /**
2549            * Removes the association between the group and the organization. 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 organization the organization
2553            * @throws SystemException if a system exception occurred
2554            */
2555            public static void removeOrganization(long pk,
2556                    com.liferay.portal.model.Organization organization)
2557                    throws com.liferay.portal.kernel.exception.SystemException {
2558                    getPersistence().removeOrganization(pk, organization);
2559            }
2560    
2561            /**
2562            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2563            *
2564            * @param pk the primary key of the group
2565            * @param organizationPKs the primary keys of the organizations
2566            * @throws SystemException if a system exception occurred
2567            */
2568            public static void removeOrganizations(long pk, long[] organizationPKs)
2569                    throws com.liferay.portal.kernel.exception.SystemException {
2570                    getPersistence().removeOrganizations(pk, organizationPKs);
2571            }
2572    
2573            /**
2574            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2575            *
2576            * @param pk the primary key of the group
2577            * @param organizations the organizations
2578            * @throws SystemException if a system exception occurred
2579            */
2580            public static void removeOrganizations(long pk,
2581                    java.util.List<com.liferay.portal.model.Organization> organizations)
2582                    throws com.liferay.portal.kernel.exception.SystemException {
2583                    getPersistence().removeOrganizations(pk, organizations);
2584            }
2585    
2586            /**
2587            * 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.
2588            *
2589            * @param pk the primary key of the group
2590            * @param organizationPKs the primary keys of the organizations to be associated with the group
2591            * @throws SystemException if a system exception occurred
2592            */
2593            public static void setOrganizations(long pk, long[] organizationPKs)
2594                    throws com.liferay.portal.kernel.exception.SystemException {
2595                    getPersistence().setOrganizations(pk, organizationPKs);
2596            }
2597    
2598            /**
2599            * 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.
2600            *
2601            * @param pk the primary key of the group
2602            * @param organizations the organizations to be associated with the group
2603            * @throws SystemException if a system exception occurred
2604            */
2605            public static void setOrganizations(long pk,
2606                    java.util.List<com.liferay.portal.model.Organization> organizations)
2607                    throws com.liferay.portal.kernel.exception.SystemException {
2608                    getPersistence().setOrganizations(pk, organizations);
2609            }
2610    
2611            /**
2612            * Returns all the roles associated with the group.
2613            *
2614            * @param pk the primary key of the group
2615            * @return the roles associated with the group
2616            * @throws SystemException if a system exception occurred
2617            */
2618            public static java.util.List<com.liferay.portal.model.Role> getRoles(
2619                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2620                    return getPersistence().getRoles(pk);
2621            }
2622    
2623            /**
2624            * Returns a range of all the roles associated with the group.
2625            *
2626            * <p>
2627            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
2628            * </p>
2629            *
2630            * @param pk the primary key of the group
2631            * @param start the lower bound of the range of groups
2632            * @param end the upper bound of the range of groups (not inclusive)
2633            * @return the range of roles associated with the group
2634            * @throws SystemException if a system exception occurred
2635            */
2636            public static java.util.List<com.liferay.portal.model.Role> getRoles(
2637                    long pk, int start, int end)
2638                    throws com.liferay.portal.kernel.exception.SystemException {
2639                    return getPersistence().getRoles(pk, start, end);
2640            }
2641    
2642            /**
2643            * Returns an ordered range of all the roles associated with the group.
2644            *
2645            * <p>
2646            * 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.
2647            * </p>
2648            *
2649            * @param pk the primary key of the group
2650            * @param start the lower bound of the range of groups
2651            * @param end the upper bound of the range of groups (not inclusive)
2652            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2653            * @return the ordered range of roles associated with the group
2654            * @throws SystemException if a system exception occurred
2655            */
2656            public static java.util.List<com.liferay.portal.model.Role> getRoles(
2657                    long pk, int start, int end,
2658                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2659                    throws com.liferay.portal.kernel.exception.SystemException {
2660                    return getPersistence().getRoles(pk, start, end, orderByComparator);
2661            }
2662    
2663            /**
2664            * Returns the number of roles associated with the group.
2665            *
2666            * @param pk the primary key of the group
2667            * @return the number of roles associated with the group
2668            * @throws SystemException if a system exception occurred
2669            */
2670            public static int getRolesSize(long pk)
2671                    throws com.liferay.portal.kernel.exception.SystemException {
2672                    return getPersistence().getRolesSize(pk);
2673            }
2674    
2675            /**
2676            * Returns <code>true</code> if the role is associated with the group.
2677            *
2678            * @param pk the primary key of the group
2679            * @param rolePK the primary key of the role
2680            * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise
2681            * @throws SystemException if a system exception occurred
2682            */
2683            public static boolean containsRole(long pk, long rolePK)
2684                    throws com.liferay.portal.kernel.exception.SystemException {
2685                    return getPersistence().containsRole(pk, rolePK);
2686            }
2687    
2688            /**
2689            * Returns <code>true</code> if the group has any roles associated with it.
2690            *
2691            * @param pk the primary key of the group to check for associations with roles
2692            * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise
2693            * @throws SystemException if a system exception occurred
2694            */
2695            public static boolean containsRoles(long pk)
2696                    throws com.liferay.portal.kernel.exception.SystemException {
2697                    return getPersistence().containsRoles(pk);
2698            }
2699    
2700            /**
2701            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2702            *
2703            * @param pk the primary key of the group
2704            * @param rolePK the primary key of the role
2705            * @throws SystemException if a system exception occurred
2706            */
2707            public static void addRole(long pk, long rolePK)
2708                    throws com.liferay.portal.kernel.exception.SystemException {
2709                    getPersistence().addRole(pk, rolePK);
2710            }
2711    
2712            /**
2713            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2714            *
2715            * @param pk the primary key of the group
2716            * @param role the role
2717            * @throws SystemException if a system exception occurred
2718            */
2719            public static void addRole(long pk, com.liferay.portal.model.Role role)
2720                    throws com.liferay.portal.kernel.exception.SystemException {
2721                    getPersistence().addRole(pk, role);
2722            }
2723    
2724            /**
2725            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2726            *
2727            * @param pk the primary key of the group
2728            * @param rolePKs the primary keys of the roles
2729            * @throws SystemException if a system exception occurred
2730            */
2731            public static void addRoles(long pk, long[] rolePKs)
2732                    throws com.liferay.portal.kernel.exception.SystemException {
2733                    getPersistence().addRoles(pk, rolePKs);
2734            }
2735    
2736            /**
2737            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2738            *
2739            * @param pk the primary key of the group
2740            * @param roles the roles
2741            * @throws SystemException if a system exception occurred
2742            */
2743            public static void addRoles(long pk,
2744                    java.util.List<com.liferay.portal.model.Role> roles)
2745                    throws com.liferay.portal.kernel.exception.SystemException {
2746                    getPersistence().addRoles(pk, roles);
2747            }
2748    
2749            /**
2750            * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2751            *
2752            * @param pk the primary key of the group to clear the associated roles from
2753            * @throws SystemException if a system exception occurred
2754            */
2755            public static void clearRoles(long pk)
2756                    throws com.liferay.portal.kernel.exception.SystemException {
2757                    getPersistence().clearRoles(pk);
2758            }
2759    
2760            /**
2761            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2762            *
2763            * @param pk the primary key of the group
2764            * @param rolePK the primary key of the role
2765            * @throws SystemException if a system exception occurred
2766            */
2767            public static void removeRole(long pk, long rolePK)
2768                    throws com.liferay.portal.kernel.exception.SystemException {
2769                    getPersistence().removeRole(pk, rolePK);
2770            }
2771    
2772            /**
2773            * Removes the association between the group and the role. 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 role the role
2777            * @throws SystemException if a system exception occurred
2778            */
2779            public static void removeRole(long pk, com.liferay.portal.model.Role role)
2780                    throws com.liferay.portal.kernel.exception.SystemException {
2781                    getPersistence().removeRole(pk, role);
2782            }
2783    
2784            /**
2785            * Removes the association between the group and the roles. 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 rolePKs the primary keys of the roles
2789            * @throws SystemException if a system exception occurred
2790            */
2791            public static void removeRoles(long pk, long[] rolePKs)
2792                    throws com.liferay.portal.kernel.exception.SystemException {
2793                    getPersistence().removeRoles(pk, rolePKs);
2794            }
2795    
2796            /**
2797            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2798            *
2799            * @param pk the primary key of the group
2800            * @param roles the roles
2801            * @throws SystemException if a system exception occurred
2802            */
2803            public static void removeRoles(long pk,
2804                    java.util.List<com.liferay.portal.model.Role> roles)
2805                    throws com.liferay.portal.kernel.exception.SystemException {
2806                    getPersistence().removeRoles(pk, roles);
2807            }
2808    
2809            /**
2810            * 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.
2811            *
2812            * @param pk the primary key of the group
2813            * @param rolePKs the primary keys of the roles to be associated with the group
2814            * @throws SystemException if a system exception occurred
2815            */
2816            public static void setRoles(long pk, long[] rolePKs)
2817                    throws com.liferay.portal.kernel.exception.SystemException {
2818                    getPersistence().setRoles(pk, rolePKs);
2819            }
2820    
2821            /**
2822            * 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.
2823            *
2824            * @param pk the primary key of the group
2825            * @param roles the roles to be associated with the group
2826            * @throws SystemException if a system exception occurred
2827            */
2828            public static void setRoles(long pk,
2829                    java.util.List<com.liferay.portal.model.Role> roles)
2830                    throws com.liferay.portal.kernel.exception.SystemException {
2831                    getPersistence().setRoles(pk, roles);
2832            }
2833    
2834            /**
2835            * Returns all the user groups associated with the group.
2836            *
2837            * @param pk the primary key of the group
2838            * @return the user groups associated with the group
2839            * @throws SystemException if a system exception occurred
2840            */
2841            public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2842                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2843                    return getPersistence().getUserGroups(pk);
2844            }
2845    
2846            /**
2847            * Returns a range of all the user groups associated with the group.
2848            *
2849            * <p>
2850            * 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.
2851            * </p>
2852            *
2853            * @param pk the primary key of the group
2854            * @param start the lower bound of the range of groups
2855            * @param end the upper bound of the range of groups (not inclusive)
2856            * @return the range of user groups associated with the group
2857            * @throws SystemException if a system exception occurred
2858            */
2859            public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2860                    long pk, int start, int end)
2861                    throws com.liferay.portal.kernel.exception.SystemException {
2862                    return getPersistence().getUserGroups(pk, start, end);
2863            }
2864    
2865            /**
2866            * Returns an ordered range of all the user groups associated with the group.
2867            *
2868            * <p>
2869            * 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.
2870            * </p>
2871            *
2872            * @param pk the primary key of the group
2873            * @param start the lower bound of the range of groups
2874            * @param end the upper bound of the range of groups (not inclusive)
2875            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2876            * @return the ordered range of user groups associated with the group
2877            * @throws SystemException if a system exception occurred
2878            */
2879            public static java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2880                    long pk, int start, int end,
2881                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2882                    throws com.liferay.portal.kernel.exception.SystemException {
2883                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
2884            }
2885    
2886            /**
2887            * Returns the number of user groups associated with the group.
2888            *
2889            * @param pk the primary key of the group
2890            * @return the number of user groups associated with the group
2891            * @throws SystemException if a system exception occurred
2892            */
2893            public static int getUserGroupsSize(long pk)
2894                    throws com.liferay.portal.kernel.exception.SystemException {
2895                    return getPersistence().getUserGroupsSize(pk);
2896            }
2897    
2898            /**
2899            * Returns <code>true</code> if the user group is associated with the group.
2900            *
2901            * @param pk the primary key of the group
2902            * @param userGroupPK the primary key of the user group
2903            * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise
2904            * @throws SystemException if a system exception occurred
2905            */
2906            public static boolean containsUserGroup(long pk, long userGroupPK)
2907                    throws com.liferay.portal.kernel.exception.SystemException {
2908                    return getPersistence().containsUserGroup(pk, userGroupPK);
2909            }
2910    
2911            /**
2912            * Returns <code>true</code> if the group has any user groups associated with it.
2913            *
2914            * @param pk the primary key of the group to check for associations with user groups
2915            * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise
2916            * @throws SystemException if a system exception occurred
2917            */
2918            public static boolean containsUserGroups(long pk)
2919                    throws com.liferay.portal.kernel.exception.SystemException {
2920                    return getPersistence().containsUserGroups(pk);
2921            }
2922    
2923            /**
2924            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2925            *
2926            * @param pk the primary key of the group
2927            * @param userGroupPK the primary key of the user group
2928            * @throws SystemException if a system exception occurred
2929            */
2930            public static void addUserGroup(long pk, long userGroupPK)
2931                    throws com.liferay.portal.kernel.exception.SystemException {
2932                    getPersistence().addUserGroup(pk, userGroupPK);
2933            }
2934    
2935            /**
2936            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2937            *
2938            * @param pk the primary key of the group
2939            * @param userGroup the user group
2940            * @throws SystemException if a system exception occurred
2941            */
2942            public static void addUserGroup(long pk,
2943                    com.liferay.portal.model.UserGroup userGroup)
2944                    throws com.liferay.portal.kernel.exception.SystemException {
2945                    getPersistence().addUserGroup(pk, userGroup);
2946            }
2947    
2948            /**
2949            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2950            *
2951            * @param pk the primary key of the group
2952            * @param userGroupPKs the primary keys of the user groups
2953            * @throws SystemException if a system exception occurred
2954            */
2955            public static void addUserGroups(long pk, long[] userGroupPKs)
2956                    throws com.liferay.portal.kernel.exception.SystemException {
2957                    getPersistence().addUserGroups(pk, userGroupPKs);
2958            }
2959    
2960            /**
2961            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2962            *
2963            * @param pk the primary key of the group
2964            * @param userGroups the user groups
2965            * @throws SystemException if a system exception occurred
2966            */
2967            public static void addUserGroups(long pk,
2968                    java.util.List<com.liferay.portal.model.UserGroup> userGroups)
2969                    throws com.liferay.portal.kernel.exception.SystemException {
2970                    getPersistence().addUserGroups(pk, userGroups);
2971            }
2972    
2973            /**
2974            * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2975            *
2976            * @param pk the primary key of the group to clear the associated user groups from
2977            * @throws SystemException if a system exception occurred
2978            */
2979            public static void clearUserGroups(long pk)
2980                    throws com.liferay.portal.kernel.exception.SystemException {
2981                    getPersistence().clearUserGroups(pk);
2982            }
2983    
2984            /**
2985            * Removes the association between the group and the user group. 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 userGroupPK the primary key of the user group
2989            * @throws SystemException if a system exception occurred
2990            */
2991            public static void removeUserGroup(long pk, long userGroupPK)
2992                    throws com.liferay.portal.kernel.exception.SystemException {
2993                    getPersistence().removeUserGroup(pk, userGroupPK);
2994            }
2995    
2996            /**
2997            * Removes the association between the group and the user group. 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 userGroup the user group
3001            * @throws SystemException if a system exception occurred
3002            */
3003            public static void removeUserGroup(long pk,
3004                    com.liferay.portal.model.UserGroup userGroup)
3005                    throws com.liferay.portal.kernel.exception.SystemException {
3006                    getPersistence().removeUserGroup(pk, userGroup);
3007            }
3008    
3009            /**
3010            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3011            *
3012            * @param pk the primary key of the group
3013            * @param userGroupPKs the primary keys of the user groups
3014            * @throws SystemException if a system exception occurred
3015            */
3016            public static void removeUserGroups(long pk, long[] userGroupPKs)
3017                    throws com.liferay.portal.kernel.exception.SystemException {
3018                    getPersistence().removeUserGroups(pk, userGroupPKs);
3019            }
3020    
3021            /**
3022            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3023            *
3024            * @param pk the primary key of the group
3025            * @param userGroups the user groups
3026            * @throws SystemException if a system exception occurred
3027            */
3028            public static void removeUserGroups(long pk,
3029                    java.util.List<com.liferay.portal.model.UserGroup> userGroups)
3030                    throws com.liferay.portal.kernel.exception.SystemException {
3031                    getPersistence().removeUserGroups(pk, userGroups);
3032            }
3033    
3034            /**
3035            * 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.
3036            *
3037            * @param pk the primary key of the group
3038            * @param userGroupPKs the primary keys of the user groups to be associated with the group
3039            * @throws SystemException if a system exception occurred
3040            */
3041            public static void setUserGroups(long pk, long[] userGroupPKs)
3042                    throws com.liferay.portal.kernel.exception.SystemException {
3043                    getPersistence().setUserGroups(pk, userGroupPKs);
3044            }
3045    
3046            /**
3047            * 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.
3048            *
3049            * @param pk the primary key of the group
3050            * @param userGroups the user groups to be associated with the group
3051            * @throws SystemException if a system exception occurred
3052            */
3053            public static void setUserGroups(long pk,
3054                    java.util.List<com.liferay.portal.model.UserGroup> userGroups)
3055                    throws com.liferay.portal.kernel.exception.SystemException {
3056                    getPersistence().setUserGroups(pk, userGroups);
3057            }
3058    
3059            /**
3060            * Returns all the users associated with the group.
3061            *
3062            * @param pk the primary key of the group
3063            * @return the users associated with the group
3064            * @throws SystemException if a system exception occurred
3065            */
3066            public static java.util.List<com.liferay.portal.model.User> getUsers(
3067                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
3068                    return getPersistence().getUsers(pk);
3069            }
3070    
3071            /**
3072            * Returns a range of all the users associated with the group.
3073            *
3074            * <p>
3075            * 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.
3076            * </p>
3077            *
3078            * @param pk the primary key of the group
3079            * @param start the lower bound of the range of groups
3080            * @param end the upper bound of the range of groups (not inclusive)
3081            * @return the range of users associated with the group
3082            * @throws SystemException if a system exception occurred
3083            */
3084            public static java.util.List<com.liferay.portal.model.User> getUsers(
3085                    long pk, int start, int end)
3086                    throws com.liferay.portal.kernel.exception.SystemException {
3087                    return getPersistence().getUsers(pk, start, end);
3088            }
3089    
3090            /**
3091            * Returns an ordered range of all the users associated with the group.
3092            *
3093            * <p>
3094            * 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.
3095            * </p>
3096            *
3097            * @param pk the primary key of the group
3098            * @param start the lower bound of the range of groups
3099            * @param end the upper bound of the range of groups (not inclusive)
3100            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3101            * @return the ordered range of users associated with the group
3102            * @throws SystemException if a system exception occurred
3103            */
3104            public static java.util.List<com.liferay.portal.model.User> getUsers(
3105                    long pk, int start, int end,
3106                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3107                    throws com.liferay.portal.kernel.exception.SystemException {
3108                    return getPersistence().getUsers(pk, start, end, orderByComparator);
3109            }
3110    
3111            /**
3112            * Returns the number of users associated with the group.
3113            *
3114            * @param pk the primary key of the group
3115            * @return the number of users associated with the group
3116            * @throws SystemException if a system exception occurred
3117            */
3118            public static int getUsersSize(long pk)
3119                    throws com.liferay.portal.kernel.exception.SystemException {
3120                    return getPersistence().getUsersSize(pk);
3121            }
3122    
3123            /**
3124            * Returns <code>true</code> if the user is associated with the group.
3125            *
3126            * @param pk the primary key of the group
3127            * @param userPK the primary key of the user
3128            * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise
3129            * @throws SystemException if a system exception occurred
3130            */
3131            public static boolean containsUser(long pk, long userPK)
3132                    throws com.liferay.portal.kernel.exception.SystemException {
3133                    return getPersistence().containsUser(pk, userPK);
3134            }
3135    
3136            /**
3137            * Returns <code>true</code> if the group has any users associated with it.
3138            *
3139            * @param pk the primary key of the group to check for associations with users
3140            * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise
3141            * @throws SystemException if a system exception occurred
3142            */
3143            public static boolean containsUsers(long pk)
3144                    throws com.liferay.portal.kernel.exception.SystemException {
3145                    return getPersistence().containsUsers(pk);
3146            }
3147    
3148            /**
3149            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3150            *
3151            * @param pk the primary key of the group
3152            * @param userPK the primary key of the user
3153            * @throws SystemException if a system exception occurred
3154            */
3155            public static void addUser(long pk, long userPK)
3156                    throws com.liferay.portal.kernel.exception.SystemException {
3157                    getPersistence().addUser(pk, userPK);
3158            }
3159    
3160            /**
3161            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3162            *
3163            * @param pk the primary key of the group
3164            * @param user the user
3165            * @throws SystemException if a system exception occurred
3166            */
3167            public static void addUser(long pk, com.liferay.portal.model.User user)
3168                    throws com.liferay.portal.kernel.exception.SystemException {
3169                    getPersistence().addUser(pk, user);
3170            }
3171    
3172            /**
3173            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3174            *
3175            * @param pk the primary key of the group
3176            * @param userPKs the primary keys of the users
3177            * @throws SystemException if a system exception occurred
3178            */
3179            public static void addUsers(long pk, long[] userPKs)
3180                    throws com.liferay.portal.kernel.exception.SystemException {
3181                    getPersistence().addUsers(pk, userPKs);
3182            }
3183    
3184            /**
3185            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3186            *
3187            * @param pk the primary key of the group
3188            * @param users the users
3189            * @throws SystemException if a system exception occurred
3190            */
3191            public static void addUsers(long pk,
3192                    java.util.List<com.liferay.portal.model.User> users)
3193                    throws com.liferay.portal.kernel.exception.SystemException {
3194                    getPersistence().addUsers(pk, users);
3195            }
3196    
3197            /**
3198            * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3199            *
3200            * @param pk the primary key of the group to clear the associated users from
3201            * @throws SystemException if a system exception occurred
3202            */
3203            public static void clearUsers(long pk)
3204                    throws com.liferay.portal.kernel.exception.SystemException {
3205                    getPersistence().clearUsers(pk);
3206            }
3207    
3208            /**
3209            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3210            *
3211            * @param pk the primary key of the group
3212            * @param userPK the primary key of the user
3213            * @throws SystemException if a system exception occurred
3214            */
3215            public static void removeUser(long pk, long userPK)
3216                    throws com.liferay.portal.kernel.exception.SystemException {
3217                    getPersistence().removeUser(pk, userPK);
3218            }
3219    
3220            /**
3221            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3222            *
3223            * @param pk the primary key of the group
3224            * @param user the user
3225            * @throws SystemException if a system exception occurred
3226            */
3227            public static void removeUser(long pk, com.liferay.portal.model.User user)
3228                    throws com.liferay.portal.kernel.exception.SystemException {
3229                    getPersistence().removeUser(pk, user);
3230            }
3231    
3232            /**
3233            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3234            *
3235            * @param pk the primary key of the group
3236            * @param userPKs the primary keys of the users
3237            * @throws SystemException if a system exception occurred
3238            */
3239            public static void removeUsers(long pk, long[] userPKs)
3240                    throws com.liferay.portal.kernel.exception.SystemException {
3241                    getPersistence().removeUsers(pk, userPKs);
3242            }
3243    
3244            /**
3245            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3246            *
3247            * @param pk the primary key of the group
3248            * @param users the users
3249            * @throws SystemException if a system exception occurred
3250            */
3251            public static void removeUsers(long pk,
3252                    java.util.List<com.liferay.portal.model.User> users)
3253                    throws com.liferay.portal.kernel.exception.SystemException {
3254                    getPersistence().removeUsers(pk, users);
3255            }
3256    
3257            /**
3258            * 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.
3259            *
3260            * @param pk the primary key of the group
3261            * @param userPKs the primary keys of the users to be associated with the group
3262            * @throws SystemException if a system exception occurred
3263            */
3264            public static void setUsers(long pk, long[] userPKs)
3265                    throws com.liferay.portal.kernel.exception.SystemException {
3266                    getPersistence().setUsers(pk, userPKs);
3267            }
3268    
3269            /**
3270            * 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.
3271            *
3272            * @param pk the primary key of the group
3273            * @param users the users to be associated with the group
3274            * @throws SystemException if a system exception occurred
3275            */
3276            public static void setUsers(long pk,
3277                    java.util.List<com.liferay.portal.model.User> users)
3278                    throws com.liferay.portal.kernel.exception.SystemException {
3279                    getPersistence().setUsers(pk, users);
3280            }
3281    
3282            public static GroupPersistence getPersistence() {
3283                    if (_persistence == null) {
3284                            _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName());
3285    
3286                            ReferenceRegistry.registerReference(GroupUtil.class, "_persistence");
3287                    }
3288    
3289                    return _persistence;
3290            }
3291    
3292            /**
3293             * @deprecated As of 6.2.0
3294             */
3295            public void setPersistence(GroupPersistence persistence) {
3296            }
3297    
3298            private static GroupPersistence _persistence;
3299    }