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