001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.model.Group;
020    
021    /**
022     * The persistence interface for the group service.
023     *
024     * <p>
025     * Caching information and settings can be found in <code>portal.properties</code>
026     * </p>
027     *
028     * @author Brian Wing Shun Chan
029     * @see com.liferay.portal.service.persistence.impl.GroupPersistenceImpl
030     * @see GroupUtil
031     * @generated
032     */
033    @ProviderType
034    public interface GroupPersistence extends BasePersistence<Group> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link GroupUtil} to access the group persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the groups where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching groups
046            */
047            public java.util.List<Group> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the groups where uuid = &#63;.
051            *
052            * <p>
053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
054            * </p>
055            *
056            * @param uuid the uuid
057            * @param start the lower bound of the range of groups
058            * @param end the upper bound of the range of groups (not inclusive)
059            * @return the range of matching groups
060            */
061            public java.util.List<Group> findByUuid(java.lang.String uuid, int start,
062                    int end);
063    
064            /**
065            * Returns an ordered range of all the groups where uuid = &#63;.
066            *
067            * <p>
068            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
069            * </p>
070            *
071            * @param uuid the uuid
072            * @param start the lower bound of the range of groups
073            * @param end the upper bound of the range of groups (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching groups
076            */
077            public java.util.List<Group> findByUuid(java.lang.String uuid, int start,
078                    int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
080    
081            /**
082            * Returns the first group in the ordered set where uuid = &#63;.
083            *
084            * @param uuid the uuid
085            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
086            * @return the first matching group
087            * @throws NoSuchGroupException if a matching group could not be found
088            */
089            public Group findByUuid_First(java.lang.String uuid,
090                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
091                    throws com.liferay.portal.NoSuchGroupException;
092    
093            /**
094            * Returns the first group in the ordered set where uuid = &#63;.
095            *
096            * @param uuid the uuid
097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
098            * @return the first matching group, or <code>null</code> if a matching group could not be found
099            */
100            public Group fetchByUuid_First(java.lang.String uuid,
101                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
102    
103            /**
104            * Returns the last group in the ordered set where uuid = &#63;.
105            *
106            * @param uuid the uuid
107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
108            * @return the last matching group
109            * @throws NoSuchGroupException if a matching group could not be found
110            */
111            public Group findByUuid_Last(java.lang.String uuid,
112                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
113                    throws com.liferay.portal.NoSuchGroupException;
114    
115            /**
116            * Returns the last group in the ordered set where uuid = &#63;.
117            *
118            * @param uuid the uuid
119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
120            * @return the last matching group, or <code>null</code> if a matching group could not be found
121            */
122            public Group fetchByUuid_Last(java.lang.String uuid,
123                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
124    
125            /**
126            * Returns the groups before and after the current group in the ordered set where uuid = &#63;.
127            *
128            * @param groupId the primary key of the current group
129            * @param uuid the uuid
130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
131            * @return the previous, current, and next group
132            * @throws NoSuchGroupException if a group with the primary key could not be found
133            */
134            public Group[] findByUuid_PrevAndNext(long groupId, java.lang.String uuid,
135                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
136                    throws com.liferay.portal.NoSuchGroupException;
137    
138            /**
139            * Removes all the groups where uuid = &#63; from the database.
140            *
141            * @param uuid the uuid
142            */
143            public void removeByUuid(java.lang.String uuid);
144    
145            /**
146            * Returns the number of groups where uuid = &#63;.
147            *
148            * @param uuid the uuid
149            * @return the number of matching groups
150            */
151            public int countByUuid(java.lang.String uuid);
152    
153            /**
154            * Returns the group where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
155            *
156            * @param uuid the uuid
157            * @param groupId the group ID
158            * @return the matching group
159            * @throws NoSuchGroupException if a matching group could not be found
160            */
161            public Group findByUUID_G(java.lang.String uuid, long groupId)
162                    throws com.liferay.portal.NoSuchGroupException;
163    
164            /**
165            * Returns the group where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
166            *
167            * @param uuid the uuid
168            * @param groupId the group ID
169            * @return the matching group, or <code>null</code> if a matching group could not be found
170            */
171            public Group fetchByUUID_G(java.lang.String uuid, long groupId);
172    
173            /**
174            * 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.
175            *
176            * @param uuid the uuid
177            * @param groupId the group ID
178            * @param retrieveFromCache whether to use the finder cache
179            * @return the matching group, or <code>null</code> if a matching group could not be found
180            */
181            public Group fetchByUUID_G(java.lang.String uuid, long groupId,
182                    boolean retrieveFromCache);
183    
184            /**
185            * Removes the group where uuid = &#63; and groupId = &#63; from the database.
186            *
187            * @param uuid the uuid
188            * @param groupId the group ID
189            * @return the group that was removed
190            */
191            public Group removeByUUID_G(java.lang.String uuid, long groupId)
192                    throws com.liferay.portal.NoSuchGroupException;
193    
194            /**
195            * Returns the number of groups where uuid = &#63; and groupId = &#63;.
196            *
197            * @param uuid the uuid
198            * @param groupId the group ID
199            * @return the number of matching groups
200            */
201            public int countByUUID_G(java.lang.String uuid, long groupId);
202    
203            /**
204            * Returns all the groups where uuid = &#63; and companyId = &#63;.
205            *
206            * @param uuid the uuid
207            * @param companyId the company ID
208            * @return the matching groups
209            */
210            public java.util.List<Group> findByUuid_C(java.lang.String uuid,
211                    long companyId);
212    
213            /**
214            * Returns a range of all the groups where uuid = &#63; and companyId = &#63;.
215            *
216            * <p>
217            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
218            * </p>
219            *
220            * @param uuid the uuid
221            * @param companyId the company ID
222            * @param start the lower bound of the range of groups
223            * @param end the upper bound of the range of groups (not inclusive)
224            * @return the range of matching groups
225            */
226            public java.util.List<Group> findByUuid_C(java.lang.String uuid,
227                    long companyId, int start, int end);
228    
229            /**
230            * Returns an ordered range of all the groups where uuid = &#63; and companyId = &#63;.
231            *
232            * <p>
233            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
234            * </p>
235            *
236            * @param uuid the uuid
237            * @param companyId the company ID
238            * @param start the lower bound of the range of groups
239            * @param end the upper bound of the range of groups (not inclusive)
240            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
241            * @return the ordered range of matching groups
242            */
243            public java.util.List<Group> findByUuid_C(java.lang.String uuid,
244                    long companyId, int start, int end,
245                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
246    
247            /**
248            * Returns the first group in the ordered set where uuid = &#63; and companyId = &#63;.
249            *
250            * @param uuid the uuid
251            * @param companyId the company ID
252            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
253            * @return the first matching group
254            * @throws NoSuchGroupException if a matching group could not be found
255            */
256            public Group findByUuid_C_First(java.lang.String uuid, long companyId,
257                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
258                    throws com.liferay.portal.NoSuchGroupException;
259    
260            /**
261            * Returns the first group in the ordered set where uuid = &#63; and companyId = &#63;.
262            *
263            * @param uuid the uuid
264            * @param companyId the company ID
265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
266            * @return the first matching group, or <code>null</code> if a matching group could not be found
267            */
268            public Group fetchByUuid_C_First(java.lang.String uuid, long companyId,
269                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
270    
271            /**
272            * Returns the last group in the ordered set where uuid = &#63; and companyId = &#63;.
273            *
274            * @param uuid the uuid
275            * @param companyId the company ID
276            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
277            * @return the last matching group
278            * @throws NoSuchGroupException if a matching group could not be found
279            */
280            public Group findByUuid_C_Last(java.lang.String uuid, long companyId,
281                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
282                    throws com.liferay.portal.NoSuchGroupException;
283    
284            /**
285            * Returns the last group in the ordered set where uuid = &#63; and companyId = &#63;.
286            *
287            * @param uuid the uuid
288            * @param companyId the company ID
289            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
290            * @return the last matching group, or <code>null</code> if a matching group could not be found
291            */
292            public Group fetchByUuid_C_Last(java.lang.String uuid, long companyId,
293                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
294    
295            /**
296            * Returns the groups before and after the current group in the ordered set where uuid = &#63; and companyId = &#63;.
297            *
298            * @param groupId the primary key of the current group
299            * @param uuid the uuid
300            * @param companyId the company ID
301            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
302            * @return the previous, current, and next group
303            * @throws NoSuchGroupException if a group with the primary key could not be found
304            */
305            public Group[] findByUuid_C_PrevAndNext(long groupId,
306                    java.lang.String uuid, long companyId,
307                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
308                    throws com.liferay.portal.NoSuchGroupException;
309    
310            /**
311            * Removes all the groups where uuid = &#63; and companyId = &#63; from the database.
312            *
313            * @param uuid the uuid
314            * @param companyId the company ID
315            */
316            public void removeByUuid_C(java.lang.String uuid, long companyId);
317    
318            /**
319            * Returns the number of groups where uuid = &#63; and companyId = &#63;.
320            *
321            * @param uuid the uuid
322            * @param companyId the company ID
323            * @return the number of matching groups
324            */
325            public int countByUuid_C(java.lang.String uuid, long companyId);
326    
327            /**
328            * Returns all the groups where companyId = &#63;.
329            *
330            * @param companyId the company ID
331            * @return the matching groups
332            */
333            public java.util.List<Group> findByCompanyId(long companyId);
334    
335            /**
336            * Returns a range of all the groups where companyId = &#63;.
337            *
338            * <p>
339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
340            * </p>
341            *
342            * @param companyId the company ID
343            * @param start the lower bound of the range of groups
344            * @param end the upper bound of the range of groups (not inclusive)
345            * @return the range of matching groups
346            */
347            public java.util.List<Group> findByCompanyId(long companyId, int start,
348                    int end);
349    
350            /**
351            * Returns an ordered range of all the groups where companyId = &#63;.
352            *
353            * <p>
354            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
355            * </p>
356            *
357            * @param companyId the company ID
358            * @param start the lower bound of the range of groups
359            * @param end the upper bound of the range of groups (not inclusive)
360            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
361            * @return the ordered range of matching groups
362            */
363            public java.util.List<Group> findByCompanyId(long companyId, int start,
364                    int end,
365                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
366    
367            /**
368            * Returns the first group in the ordered set where companyId = &#63;.
369            *
370            * @param companyId the company ID
371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
372            * @return the first matching group
373            * @throws NoSuchGroupException if a matching group could not be found
374            */
375            public Group findByCompanyId_First(long companyId,
376                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
377                    throws com.liferay.portal.NoSuchGroupException;
378    
379            /**
380            * Returns the first group in the ordered set where companyId = &#63;.
381            *
382            * @param companyId the company ID
383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
384            * @return the first matching group, or <code>null</code> if a matching group could not be found
385            */
386            public Group fetchByCompanyId_First(long companyId,
387                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
388    
389            /**
390            * Returns the last group in the ordered set where companyId = &#63;.
391            *
392            * @param companyId the company ID
393            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
394            * @return the last matching group
395            * @throws NoSuchGroupException if a matching group could not be found
396            */
397            public Group findByCompanyId_Last(long companyId,
398                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
399                    throws com.liferay.portal.NoSuchGroupException;
400    
401            /**
402            * Returns the last group in the ordered set where companyId = &#63;.
403            *
404            * @param companyId the company ID
405            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
406            * @return the last matching group, or <code>null</code> if a matching group could not be found
407            */
408            public Group fetchByCompanyId_Last(long companyId,
409                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
410    
411            /**
412            * Returns the groups before and after the current group in the ordered set where companyId = &#63;.
413            *
414            * @param groupId the primary key of the current group
415            * @param companyId the company ID
416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
417            * @return the previous, current, and next group
418            * @throws NoSuchGroupException if a group with the primary key could not be found
419            */
420            public Group[] findByCompanyId_PrevAndNext(long groupId, long companyId,
421                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
422                    throws com.liferay.portal.NoSuchGroupException;
423    
424            /**
425            * Removes all the groups where companyId = &#63; from the database.
426            *
427            * @param companyId the company ID
428            */
429            public void removeByCompanyId(long companyId);
430    
431            /**
432            * Returns the number of groups where companyId = &#63;.
433            *
434            * @param companyId the company ID
435            * @return the number of matching groups
436            */
437            public int countByCompanyId(long companyId);
438    
439            /**
440            * Returns the group where liveGroupId = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
441            *
442            * @param liveGroupId the live group ID
443            * @return the matching group
444            * @throws NoSuchGroupException if a matching group could not be found
445            */
446            public Group findByLiveGroupId(long liveGroupId)
447                    throws com.liferay.portal.NoSuchGroupException;
448    
449            /**
450            * Returns the group where liveGroupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
451            *
452            * @param liveGroupId the live group ID
453            * @return the matching group, or <code>null</code> if a matching group could not be found
454            */
455            public Group fetchByLiveGroupId(long liveGroupId);
456    
457            /**
458            * Returns the group where liveGroupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
459            *
460            * @param liveGroupId the live group ID
461            * @param retrieveFromCache whether to use the finder cache
462            * @return the matching group, or <code>null</code> if a matching group could not be found
463            */
464            public Group fetchByLiveGroupId(long liveGroupId, boolean retrieveFromCache);
465    
466            /**
467            * Removes the group where liveGroupId = &#63; from the database.
468            *
469            * @param liveGroupId the live group ID
470            * @return the group that was removed
471            */
472            public Group removeByLiveGroupId(long liveGroupId)
473                    throws com.liferay.portal.NoSuchGroupException;
474    
475            /**
476            * Returns the number of groups where liveGroupId = &#63;.
477            *
478            * @param liveGroupId the live group ID
479            * @return the number of matching groups
480            */
481            public int countByLiveGroupId(long liveGroupId);
482    
483            /**
484            * Returns all the groups where companyId = &#63; and classNameId = &#63;.
485            *
486            * @param companyId the company ID
487            * @param classNameId the class name ID
488            * @return the matching groups
489            */
490            public java.util.List<Group> findByC_C(long companyId, long classNameId);
491    
492            /**
493            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63;.
494            *
495            * <p>
496            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
497            * </p>
498            *
499            * @param companyId the company ID
500            * @param classNameId the class name ID
501            * @param start the lower bound of the range of groups
502            * @param end the upper bound of the range of groups (not inclusive)
503            * @return the range of matching groups
504            */
505            public java.util.List<Group> findByC_C(long companyId, long classNameId,
506                    int start, int end);
507    
508            /**
509            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63;.
510            *
511            * <p>
512            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
513            * </p>
514            *
515            * @param companyId the company ID
516            * @param classNameId the class name ID
517            * @param start the lower bound of the range of groups
518            * @param end the upper bound of the range of groups (not inclusive)
519            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
520            * @return the ordered range of matching groups
521            */
522            public java.util.List<Group> findByC_C(long companyId, long classNameId,
523                    int start, int end,
524                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
525    
526            /**
527            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
528            *
529            * @param companyId the company ID
530            * @param classNameId the class name ID
531            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
532            * @return the first matching group
533            * @throws NoSuchGroupException if a matching group could not be found
534            */
535            public Group findByC_C_First(long companyId, long classNameId,
536                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
537                    throws com.liferay.portal.NoSuchGroupException;
538    
539            /**
540            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63;.
541            *
542            * @param companyId the company ID
543            * @param classNameId the class name ID
544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
545            * @return the first matching group, or <code>null</code> if a matching group could not be found
546            */
547            public Group fetchByC_C_First(long companyId, long classNameId,
548                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
549    
550            /**
551            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
552            *
553            * @param companyId the company ID
554            * @param classNameId the class name ID
555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
556            * @return the last matching group
557            * @throws NoSuchGroupException if a matching group could not be found
558            */
559            public Group findByC_C_Last(long companyId, long classNameId,
560                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
561                    throws com.liferay.portal.NoSuchGroupException;
562    
563            /**
564            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63;.
565            *
566            * @param companyId the company ID
567            * @param classNameId the class name ID
568            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
569            * @return the last matching group, or <code>null</code> if a matching group could not be found
570            */
571            public Group fetchByC_C_Last(long companyId, long classNameId,
572                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
573    
574            /**
575            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63;.
576            *
577            * @param groupId the primary key of the current group
578            * @param companyId the company ID
579            * @param classNameId the class name ID
580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
581            * @return the previous, current, and next group
582            * @throws NoSuchGroupException if a group with the primary key could not be found
583            */
584            public Group[] findByC_C_PrevAndNext(long groupId, long companyId,
585                    long classNameId,
586                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
587                    throws com.liferay.portal.NoSuchGroupException;
588    
589            /**
590            * Removes all the groups where companyId = &#63; and classNameId = &#63; from the database.
591            *
592            * @param companyId the company ID
593            * @param classNameId the class name ID
594            */
595            public void removeByC_C(long companyId, long classNameId);
596    
597            /**
598            * Returns the number of groups where companyId = &#63; and classNameId = &#63;.
599            *
600            * @param companyId the company ID
601            * @param classNameId the class name ID
602            * @return the number of matching groups
603            */
604            public int countByC_C(long companyId, long classNameId);
605    
606            /**
607            * Returns all the groups where companyId = &#63; and parentGroupId = &#63;.
608            *
609            * @param companyId the company ID
610            * @param parentGroupId the parent group ID
611            * @return the matching groups
612            */
613            public java.util.List<Group> findByC_P(long companyId, long parentGroupId);
614    
615            /**
616            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63;.
617            *
618            * <p>
619            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
620            * </p>
621            *
622            * @param companyId the company ID
623            * @param parentGroupId the parent group ID
624            * @param start the lower bound of the range of groups
625            * @param end the upper bound of the range of groups (not inclusive)
626            * @return the range of matching groups
627            */
628            public java.util.List<Group> findByC_P(long companyId, long parentGroupId,
629                    int start, int end);
630    
631            /**
632            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63;.
633            *
634            * <p>
635            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
636            * </p>
637            *
638            * @param companyId the company ID
639            * @param parentGroupId the parent group ID
640            * @param start the lower bound of the range of groups
641            * @param end the upper bound of the range of groups (not inclusive)
642            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
643            * @return the ordered range of matching groups
644            */
645            public java.util.List<Group> findByC_P(long companyId, long parentGroupId,
646                    int start, int end,
647                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
648    
649            /**
650            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
651            *
652            * @param companyId the company ID
653            * @param parentGroupId the parent group ID
654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
655            * @return the first matching group
656            * @throws NoSuchGroupException if a matching group could not be found
657            */
658            public Group findByC_P_First(long companyId, long parentGroupId,
659                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
660                    throws com.liferay.portal.NoSuchGroupException;
661    
662            /**
663            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
664            *
665            * @param companyId the company ID
666            * @param parentGroupId the parent group ID
667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
668            * @return the first matching group, or <code>null</code> if a matching group could not be found
669            */
670            public Group fetchByC_P_First(long companyId, long parentGroupId,
671                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
672    
673            /**
674            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
675            *
676            * @param companyId the company ID
677            * @param parentGroupId the parent group ID
678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
679            * @return the last matching group
680            * @throws NoSuchGroupException if a matching group could not be found
681            */
682            public Group findByC_P_Last(long companyId, long parentGroupId,
683                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
684                    throws com.liferay.portal.NoSuchGroupException;
685    
686            /**
687            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
688            *
689            * @param companyId the company ID
690            * @param parentGroupId the parent group ID
691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
692            * @return the last matching group, or <code>null</code> if a matching group could not be found
693            */
694            public Group fetchByC_P_Last(long companyId, long parentGroupId,
695                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
696    
697            /**
698            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63;.
699            *
700            * @param groupId the primary key of the current group
701            * @param companyId the company ID
702            * @param parentGroupId the parent group ID
703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
704            * @return the previous, current, and next group
705            * @throws NoSuchGroupException if a group with the primary key could not be found
706            */
707            public Group[] findByC_P_PrevAndNext(long groupId, long companyId,
708                    long parentGroupId,
709                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
710                    throws com.liferay.portal.NoSuchGroupException;
711    
712            /**
713            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; from the database.
714            *
715            * @param companyId the company ID
716            * @param parentGroupId the parent group ID
717            */
718            public void removeByC_P(long companyId, long parentGroupId);
719    
720            /**
721            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63;.
722            *
723            * @param companyId the company ID
724            * @param parentGroupId the parent group ID
725            * @return the number of matching groups
726            */
727            public int countByC_P(long companyId, long parentGroupId);
728    
729            /**
730            * Returns the group where companyId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
731            *
732            * @param companyId the company ID
733            * @param groupKey the group key
734            * @return the matching group
735            * @throws NoSuchGroupException if a matching group could not be found
736            */
737            public Group findByC_GK(long companyId, java.lang.String groupKey)
738                    throws com.liferay.portal.NoSuchGroupException;
739    
740            /**
741            * Returns the group where companyId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
742            *
743            * @param companyId the company ID
744            * @param groupKey the group key
745            * @return the matching group, or <code>null</code> if a matching group could not be found
746            */
747            public Group fetchByC_GK(long companyId, java.lang.String groupKey);
748    
749            /**
750            * Returns the group where companyId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
751            *
752            * @param companyId the company ID
753            * @param groupKey the group key
754            * @param retrieveFromCache whether to use the finder cache
755            * @return the matching group, or <code>null</code> if a matching group could not be found
756            */
757            public Group fetchByC_GK(long companyId, java.lang.String groupKey,
758                    boolean retrieveFromCache);
759    
760            /**
761            * Removes the group where companyId = &#63; and groupKey = &#63; from the database.
762            *
763            * @param companyId the company ID
764            * @param groupKey the group key
765            * @return the group that was removed
766            */
767            public Group removeByC_GK(long companyId, java.lang.String groupKey)
768                    throws com.liferay.portal.NoSuchGroupException;
769    
770            /**
771            * Returns the number of groups where companyId = &#63; and groupKey = &#63;.
772            *
773            * @param companyId the company ID
774            * @param groupKey the group key
775            * @return the number of matching groups
776            */
777            public int countByC_GK(long companyId, java.lang.String groupKey);
778    
779            /**
780            * Returns the group where companyId = &#63; and friendlyURL = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
781            *
782            * @param companyId the company ID
783            * @param friendlyURL the friendly u r l
784            * @return the matching group
785            * @throws NoSuchGroupException if a matching group could not be found
786            */
787            public Group findByC_F(long companyId, java.lang.String friendlyURL)
788                    throws com.liferay.portal.NoSuchGroupException;
789    
790            /**
791            * Returns the group where companyId = &#63; and friendlyURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
792            *
793            * @param companyId the company ID
794            * @param friendlyURL the friendly u r l
795            * @return the matching group, or <code>null</code> if a matching group could not be found
796            */
797            public Group fetchByC_F(long companyId, java.lang.String friendlyURL);
798    
799            /**
800            * 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.
801            *
802            * @param companyId the company ID
803            * @param friendlyURL the friendly u r l
804            * @param retrieveFromCache whether to use the finder cache
805            * @return the matching group, or <code>null</code> if a matching group could not be found
806            */
807            public Group fetchByC_F(long companyId, java.lang.String friendlyURL,
808                    boolean retrieveFromCache);
809    
810            /**
811            * Removes the group where companyId = &#63; and friendlyURL = &#63; from the database.
812            *
813            * @param companyId the company ID
814            * @param friendlyURL the friendly u r l
815            * @return the group that was removed
816            */
817            public Group removeByC_F(long companyId, java.lang.String friendlyURL)
818                    throws com.liferay.portal.NoSuchGroupException;
819    
820            /**
821            * Returns the number of groups where companyId = &#63; and friendlyURL = &#63;.
822            *
823            * @param companyId the company ID
824            * @param friendlyURL the friendly u r l
825            * @return the number of matching groups
826            */
827            public int countByC_F(long companyId, java.lang.String friendlyURL);
828    
829            /**
830            * Returns all the groups where companyId = &#63; and site = &#63;.
831            *
832            * @param companyId the company ID
833            * @param site the site
834            * @return the matching groups
835            */
836            public java.util.List<Group> findByC_S(long companyId, boolean site);
837    
838            /**
839            * Returns a range of all the groups where companyId = &#63; and site = &#63;.
840            *
841            * <p>
842            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
843            * </p>
844            *
845            * @param companyId the company ID
846            * @param site the site
847            * @param start the lower bound of the range of groups
848            * @param end the upper bound of the range of groups (not inclusive)
849            * @return the range of matching groups
850            */
851            public java.util.List<Group> findByC_S(long companyId, boolean site,
852                    int start, int end);
853    
854            /**
855            * Returns an ordered range of all the groups where companyId = &#63; and site = &#63;.
856            *
857            * <p>
858            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
859            * </p>
860            *
861            * @param companyId the company ID
862            * @param site the site
863            * @param start the lower bound of the range of groups
864            * @param end the upper bound of the range of groups (not inclusive)
865            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
866            * @return the ordered range of matching groups
867            */
868            public java.util.List<Group> findByC_S(long companyId, boolean site,
869                    int start, int end,
870                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
871    
872            /**
873            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
874            *
875            * @param companyId the company ID
876            * @param site the site
877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
878            * @return the first matching group
879            * @throws NoSuchGroupException if a matching group could not be found
880            */
881            public Group findByC_S_First(long companyId, boolean site,
882                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
883                    throws com.liferay.portal.NoSuchGroupException;
884    
885            /**
886            * Returns the first group in the ordered set where companyId = &#63; and site = &#63;.
887            *
888            * @param companyId the company ID
889            * @param site the site
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the first matching group, or <code>null</code> if a matching group could not be found
892            */
893            public Group fetchByC_S_First(long companyId, boolean site,
894                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
895    
896            /**
897            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
898            *
899            * @param companyId the company ID
900            * @param site the site
901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
902            * @return the last matching group
903            * @throws NoSuchGroupException if a matching group could not be found
904            */
905            public Group findByC_S_Last(long companyId, boolean site,
906                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
907                    throws com.liferay.portal.NoSuchGroupException;
908    
909            /**
910            * Returns the last group in the ordered set where companyId = &#63; and site = &#63;.
911            *
912            * @param companyId the company ID
913            * @param site the site
914            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
915            * @return the last matching group, or <code>null</code> if a matching group could not be found
916            */
917            public Group fetchByC_S_Last(long companyId, boolean site,
918                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
919    
920            /**
921            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and site = &#63;.
922            *
923            * @param groupId the primary key of the current group
924            * @param companyId the company ID
925            * @param site the site
926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
927            * @return the previous, current, and next group
928            * @throws NoSuchGroupException if a group with the primary key could not be found
929            */
930            public Group[] findByC_S_PrevAndNext(long groupId, long companyId,
931                    boolean site,
932                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
933                    throws com.liferay.portal.NoSuchGroupException;
934    
935            /**
936            * Removes all the groups where companyId = &#63; and site = &#63; from the database.
937            *
938            * @param companyId the company ID
939            * @param site the site
940            */
941            public void removeByC_S(long companyId, boolean site);
942    
943            /**
944            * Returns the number of groups where companyId = &#63; and site = &#63;.
945            *
946            * @param companyId the company ID
947            * @param site the site
948            * @return the number of matching groups
949            */
950            public int countByC_S(long companyId, boolean site);
951    
952            /**
953            * Returns all the groups where type = &#63; and active = &#63;.
954            *
955            * @param type the type
956            * @param active the active
957            * @return the matching groups
958            */
959            public java.util.List<Group> findByT_A(int type, boolean active);
960    
961            /**
962            * Returns a range of all the groups where type = &#63; and active = &#63;.
963            *
964            * <p>
965            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
966            * </p>
967            *
968            * @param type the type
969            * @param active the active
970            * @param start the lower bound of the range of groups
971            * @param end the upper bound of the range of groups (not inclusive)
972            * @return the range of matching groups
973            */
974            public java.util.List<Group> findByT_A(int type, boolean active, int start,
975                    int end);
976    
977            /**
978            * Returns an ordered range of all the groups where type = &#63; and active = &#63;.
979            *
980            * <p>
981            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
982            * </p>
983            *
984            * @param type the type
985            * @param active the active
986            * @param start the lower bound of the range of groups
987            * @param end the upper bound of the range of groups (not inclusive)
988            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
989            * @return the ordered range of matching groups
990            */
991            public java.util.List<Group> findByT_A(int type, boolean active, int start,
992                    int end,
993                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
994    
995            /**
996            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
997            *
998            * @param type the type
999            * @param active the active
1000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1001            * @return the first matching group
1002            * @throws NoSuchGroupException if a matching group could not be found
1003            */
1004            public Group findByT_A_First(int type, boolean active,
1005                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1006                    throws com.liferay.portal.NoSuchGroupException;
1007    
1008            /**
1009            * Returns the first group in the ordered set where type = &#63; and active = &#63;.
1010            *
1011            * @param type the type
1012            * @param active the active
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the first matching group, or <code>null</code> if a matching group could not be found
1015            */
1016            public Group fetchByT_A_First(int type, boolean active,
1017                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1018    
1019            /**
1020            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1021            *
1022            * @param type the type
1023            * @param active the active
1024            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1025            * @return the last matching group
1026            * @throws NoSuchGroupException if a matching group could not be found
1027            */
1028            public Group findByT_A_Last(int type, boolean active,
1029                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1030                    throws com.liferay.portal.NoSuchGroupException;
1031    
1032            /**
1033            * Returns the last group in the ordered set where type = &#63; and active = &#63;.
1034            *
1035            * @param type the type
1036            * @param active the active
1037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1038            * @return the last matching group, or <code>null</code> if a matching group could not be found
1039            */
1040            public Group fetchByT_A_Last(int type, boolean active,
1041                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1042    
1043            /**
1044            * Returns the groups before and after the current group in the ordered set where type = &#63; and active = &#63;.
1045            *
1046            * @param groupId the primary key of the current group
1047            * @param type the type
1048            * @param active the active
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the previous, current, and next group
1051            * @throws NoSuchGroupException if a group with the primary key could not be found
1052            */
1053            public Group[] findByT_A_PrevAndNext(long groupId, int type,
1054                    boolean active,
1055                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1056                    throws com.liferay.portal.NoSuchGroupException;
1057    
1058            /**
1059            * Removes all the groups where type = &#63; and active = &#63; from the database.
1060            *
1061            * @param type the type
1062            * @param active the active
1063            */
1064            public void removeByT_A(int type, boolean active);
1065    
1066            /**
1067            * Returns the number of groups where type = &#63; and active = &#63;.
1068            *
1069            * @param type the type
1070            * @param active the active
1071            * @return the number of matching groups
1072            */
1073            public int countByT_A(int type, boolean active);
1074    
1075            /**
1076            * Returns all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1077            *
1078            * @param groupId the group ID
1079            * @param companyId the company ID
1080            * @param parentGroupId the parent group ID
1081            * @return the matching groups
1082            */
1083            public java.util.List<Group> findByG_C_P(long groupId, long companyId,
1084                    long parentGroupId);
1085    
1086            /**
1087            * Returns a range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1088            *
1089            * <p>
1090            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1091            * </p>
1092            *
1093            * @param groupId the group ID
1094            * @param companyId the company ID
1095            * @param parentGroupId the parent group ID
1096            * @param start the lower bound of the range of groups
1097            * @param end the upper bound of the range of groups (not inclusive)
1098            * @return the range of matching groups
1099            */
1100            public java.util.List<Group> findByG_C_P(long groupId, long companyId,
1101                    long parentGroupId, int start, int end);
1102    
1103            /**
1104            * Returns an ordered range of all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1105            *
1106            * <p>
1107            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1108            * </p>
1109            *
1110            * @param groupId the group ID
1111            * @param companyId the company ID
1112            * @param parentGroupId the parent group ID
1113            * @param start the lower bound of the range of groups
1114            * @param end the upper bound of the range of groups (not inclusive)
1115            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1116            * @return the ordered range of matching groups
1117            */
1118            public java.util.List<Group> findByG_C_P(long groupId, long companyId,
1119                    long parentGroupId, int start, int end,
1120                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1121    
1122            /**
1123            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1124            *
1125            * @param groupId the group ID
1126            * @param companyId the company ID
1127            * @param parentGroupId the parent group ID
1128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1129            * @return the first matching group
1130            * @throws NoSuchGroupException if a matching group could not be found
1131            */
1132            public Group findByG_C_P_First(long groupId, long companyId,
1133                    long parentGroupId,
1134                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1135                    throws com.liferay.portal.NoSuchGroupException;
1136    
1137            /**
1138            * Returns the first group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1139            *
1140            * @param groupId the group ID
1141            * @param companyId the company ID
1142            * @param parentGroupId the parent group ID
1143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1144            * @return the first matching group, or <code>null</code> if a matching group could not be found
1145            */
1146            public Group fetchByG_C_P_First(long groupId, long companyId,
1147                    long parentGroupId,
1148                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1149    
1150            /**
1151            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1152            *
1153            * @param groupId the group ID
1154            * @param companyId the company ID
1155            * @param parentGroupId the parent group ID
1156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1157            * @return the last matching group
1158            * @throws NoSuchGroupException if a matching group could not be found
1159            */
1160            public Group findByG_C_P_Last(long groupId, long companyId,
1161                    long parentGroupId,
1162                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1163                    throws com.liferay.portal.NoSuchGroupException;
1164    
1165            /**
1166            * Returns the last group in the ordered set where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1167            *
1168            * @param groupId the group ID
1169            * @param companyId the company ID
1170            * @param parentGroupId the parent group ID
1171            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1172            * @return the last matching group, or <code>null</code> if a matching group could not be found
1173            */
1174            public Group fetchByG_C_P_Last(long groupId, long companyId,
1175                    long parentGroupId,
1176                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1177    
1178            /**
1179            * Removes all the groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63; from the database.
1180            *
1181            * @param groupId the group ID
1182            * @param companyId the company ID
1183            * @param parentGroupId the parent group ID
1184            */
1185            public void removeByG_C_P(long groupId, long companyId, long parentGroupId);
1186    
1187            /**
1188            * Returns the number of groups where groupId &gt; &#63; and companyId = &#63; and parentGroupId = &#63;.
1189            *
1190            * @param groupId the group ID
1191            * @param companyId the company ID
1192            * @param parentGroupId the parent group ID
1193            * @return the number of matching groups
1194            */
1195            public int countByG_C_P(long groupId, long companyId, long parentGroupId);
1196    
1197            /**
1198            * Returns the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1199            *
1200            * @param companyId the company ID
1201            * @param classNameId the class name ID
1202            * @param classPK the class p k
1203            * @return the matching group
1204            * @throws NoSuchGroupException if a matching group could not be found
1205            */
1206            public Group findByC_C_C(long companyId, long classNameId, long classPK)
1207                    throws com.liferay.portal.NoSuchGroupException;
1208    
1209            /**
1210            * 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.
1211            *
1212            * @param companyId the company ID
1213            * @param classNameId the class name ID
1214            * @param classPK the class p k
1215            * @return the matching group, or <code>null</code> if a matching group could not be found
1216            */
1217            public Group fetchByC_C_C(long companyId, long classNameId, long classPK);
1218    
1219            /**
1220            * 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.
1221            *
1222            * @param companyId the company ID
1223            * @param classNameId the class name ID
1224            * @param classPK the class p k
1225            * @param retrieveFromCache whether to use the finder cache
1226            * @return the matching group, or <code>null</code> if a matching group could not be found
1227            */
1228            public Group fetchByC_C_C(long companyId, long classNameId, long classPK,
1229                    boolean retrieveFromCache);
1230    
1231            /**
1232            * Removes the group where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1233            *
1234            * @param companyId the company ID
1235            * @param classNameId the class name ID
1236            * @param classPK the class p k
1237            * @return the group that was removed
1238            */
1239            public Group removeByC_C_C(long companyId, long classNameId, long classPK)
1240                    throws com.liferay.portal.NoSuchGroupException;
1241    
1242            /**
1243            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1244            *
1245            * @param companyId the company ID
1246            * @param classNameId the class name ID
1247            * @param classPK the class p k
1248            * @return the number of matching groups
1249            */
1250            public int countByC_C_C(long companyId, long classNameId, long classPK);
1251    
1252            /**
1253            * Returns all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1254            *
1255            * @param companyId the company ID
1256            * @param classNameId the class name ID
1257            * @param parentGroupId the parent group ID
1258            * @return the matching groups
1259            */
1260            public java.util.List<Group> findByC_C_P(long companyId, long classNameId,
1261                    long parentGroupId);
1262    
1263            /**
1264            * Returns a range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1265            *
1266            * <p>
1267            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1268            * </p>
1269            *
1270            * @param companyId the company ID
1271            * @param classNameId the class name ID
1272            * @param parentGroupId the parent group ID
1273            * @param start the lower bound of the range of groups
1274            * @param end the upper bound of the range of groups (not inclusive)
1275            * @return the range of matching groups
1276            */
1277            public java.util.List<Group> findByC_C_P(long companyId, long classNameId,
1278                    long parentGroupId, int start, int end);
1279    
1280            /**
1281            * Returns an ordered range of all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1282            *
1283            * <p>
1284            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1285            * </p>
1286            *
1287            * @param companyId the company ID
1288            * @param classNameId the class name ID
1289            * @param parentGroupId the parent group ID
1290            * @param start the lower bound of the range of groups
1291            * @param end the upper bound of the range of groups (not inclusive)
1292            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1293            * @return the ordered range of matching groups
1294            */
1295            public java.util.List<Group> findByC_C_P(long companyId, long classNameId,
1296                    long parentGroupId, int start, int end,
1297                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1298    
1299            /**
1300            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1301            *
1302            * @param companyId the company ID
1303            * @param classNameId the class name ID
1304            * @param parentGroupId the parent group ID
1305            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1306            * @return the first matching group
1307            * @throws NoSuchGroupException if a matching group could not be found
1308            */
1309            public Group findByC_C_P_First(long companyId, long classNameId,
1310                    long parentGroupId,
1311                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1312                    throws com.liferay.portal.NoSuchGroupException;
1313    
1314            /**
1315            * Returns the first group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1316            *
1317            * @param companyId the company ID
1318            * @param classNameId the class name ID
1319            * @param parentGroupId the parent group ID
1320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1321            * @return the first matching group, or <code>null</code> if a matching group could not be found
1322            */
1323            public Group fetchByC_C_P_First(long companyId, long classNameId,
1324                    long parentGroupId,
1325                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1326    
1327            /**
1328            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1329            *
1330            * @param companyId the company ID
1331            * @param classNameId the class name ID
1332            * @param parentGroupId the parent group ID
1333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1334            * @return the last matching group
1335            * @throws NoSuchGroupException if a matching group could not be found
1336            */
1337            public Group findByC_C_P_Last(long companyId, long classNameId,
1338                    long parentGroupId,
1339                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1340                    throws com.liferay.portal.NoSuchGroupException;
1341    
1342            /**
1343            * Returns the last group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1344            *
1345            * @param companyId the company ID
1346            * @param classNameId the class name ID
1347            * @param parentGroupId the parent group ID
1348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1349            * @return the last matching group, or <code>null</code> if a matching group could not be found
1350            */
1351            public Group fetchByC_C_P_Last(long companyId, long classNameId,
1352                    long parentGroupId,
1353                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1354    
1355            /**
1356            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1357            *
1358            * @param groupId the primary key of the current group
1359            * @param companyId the company ID
1360            * @param classNameId the class name ID
1361            * @param parentGroupId the parent group ID
1362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1363            * @return the previous, current, and next group
1364            * @throws NoSuchGroupException if a group with the primary key could not be found
1365            */
1366            public Group[] findByC_C_P_PrevAndNext(long groupId, long companyId,
1367                    long classNameId, long parentGroupId,
1368                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1369                    throws com.liferay.portal.NoSuchGroupException;
1370    
1371            /**
1372            * Removes all the groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63; from the database.
1373            *
1374            * @param companyId the company ID
1375            * @param classNameId the class name ID
1376            * @param parentGroupId the parent group ID
1377            */
1378            public void removeByC_C_P(long companyId, long classNameId,
1379                    long parentGroupId);
1380    
1381            /**
1382            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and parentGroupId = &#63;.
1383            *
1384            * @param companyId the company ID
1385            * @param classNameId the class name ID
1386            * @param parentGroupId the parent group ID
1387            * @return the number of matching groups
1388            */
1389            public int countByC_C_P(long companyId, long classNameId, long parentGroupId);
1390    
1391            /**
1392            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1393            *
1394            * @param companyId the company ID
1395            * @param parentGroupId the parent group ID
1396            * @param site the site
1397            * @return the matching groups
1398            */
1399            public java.util.List<Group> findByC_P_S(long companyId,
1400                    long parentGroupId, boolean site);
1401    
1402            /**
1403            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1404            *
1405            * <p>
1406            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1407            * </p>
1408            *
1409            * @param companyId the company ID
1410            * @param parentGroupId the parent group ID
1411            * @param site the site
1412            * @param start the lower bound of the range of groups
1413            * @param end the upper bound of the range of groups (not inclusive)
1414            * @return the range of matching groups
1415            */
1416            public java.util.List<Group> findByC_P_S(long companyId,
1417                    long parentGroupId, boolean site, int start, int end);
1418    
1419            /**
1420            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1421            *
1422            * <p>
1423            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1424            * </p>
1425            *
1426            * @param companyId the company ID
1427            * @param parentGroupId the parent group ID
1428            * @param site the site
1429            * @param start the lower bound of the range of groups
1430            * @param end the upper bound of the range of groups (not inclusive)
1431            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1432            * @return the ordered range of matching groups
1433            */
1434            public java.util.List<Group> findByC_P_S(long companyId,
1435                    long parentGroupId, boolean site, int start, int end,
1436                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1437    
1438            /**
1439            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1440            *
1441            * @param companyId the company ID
1442            * @param parentGroupId the parent group ID
1443            * @param site the site
1444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1445            * @return the first matching group
1446            * @throws NoSuchGroupException if a matching group could not be found
1447            */
1448            public Group findByC_P_S_First(long companyId, long parentGroupId,
1449                    boolean site,
1450                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1451                    throws com.liferay.portal.NoSuchGroupException;
1452    
1453            /**
1454            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1455            *
1456            * @param companyId the company ID
1457            * @param parentGroupId the parent group ID
1458            * @param site the site
1459            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1460            * @return the first matching group, or <code>null</code> if a matching group could not be found
1461            */
1462            public Group fetchByC_P_S_First(long companyId, long parentGroupId,
1463                    boolean site,
1464                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1465    
1466            /**
1467            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1468            *
1469            * @param companyId the company ID
1470            * @param parentGroupId the parent group ID
1471            * @param site the site
1472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1473            * @return the last matching group
1474            * @throws NoSuchGroupException if a matching group could not be found
1475            */
1476            public Group findByC_P_S_Last(long companyId, long parentGroupId,
1477                    boolean site,
1478                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1479                    throws com.liferay.portal.NoSuchGroupException;
1480    
1481            /**
1482            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1483            *
1484            * @param companyId the company ID
1485            * @param parentGroupId the parent group ID
1486            * @param site the site
1487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1488            * @return the last matching group, or <code>null</code> if a matching group could not be found
1489            */
1490            public Group fetchByC_P_S_Last(long companyId, long parentGroupId,
1491                    boolean site,
1492                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1493    
1494            /**
1495            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1496            *
1497            * @param groupId the primary key of the current group
1498            * @param companyId the company ID
1499            * @param parentGroupId the parent group ID
1500            * @param site the site
1501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1502            * @return the previous, current, and next group
1503            * @throws NoSuchGroupException if a group with the primary key could not be found
1504            */
1505            public Group[] findByC_P_S_PrevAndNext(long groupId, long companyId,
1506                    long parentGroupId, boolean site,
1507                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1508                    throws com.liferay.portal.NoSuchGroupException;
1509    
1510            /**
1511            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; from the database.
1512            *
1513            * @param companyId the company ID
1514            * @param parentGroupId the parent group ID
1515            * @param site the site
1516            */
1517            public void removeByC_P_S(long companyId, long parentGroupId, boolean site);
1518    
1519            /**
1520            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63;.
1521            *
1522            * @param companyId the company ID
1523            * @param parentGroupId the parent group ID
1524            * @param site the site
1525            * @return the number of matching groups
1526            */
1527            public int countByC_P_S(long companyId, long parentGroupId, boolean site);
1528    
1529            /**
1530            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1531            *
1532            * @param companyId the company ID
1533            * @param liveGroupId the live group ID
1534            * @param groupKey the group key
1535            * @return the matching group
1536            * @throws NoSuchGroupException if a matching group could not be found
1537            */
1538            public Group findByC_L_GK(long companyId, long liveGroupId,
1539                    java.lang.String groupKey)
1540                    throws com.liferay.portal.NoSuchGroupException;
1541    
1542            /**
1543            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1544            *
1545            * @param companyId the company ID
1546            * @param liveGroupId the live group ID
1547            * @param groupKey the group key
1548            * @return the matching group, or <code>null</code> if a matching group could not be found
1549            */
1550            public Group fetchByC_L_GK(long companyId, long liveGroupId,
1551                    java.lang.String groupKey);
1552    
1553            /**
1554            * Returns the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1555            *
1556            * @param companyId the company ID
1557            * @param liveGroupId the live group ID
1558            * @param groupKey the group key
1559            * @param retrieveFromCache whether to use the finder cache
1560            * @return the matching group, or <code>null</code> if a matching group could not be found
1561            */
1562            public Group fetchByC_L_GK(long companyId, long liveGroupId,
1563                    java.lang.String groupKey, boolean retrieveFromCache);
1564    
1565            /**
1566            * Removes the group where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
1567            *
1568            * @param companyId the company ID
1569            * @param liveGroupId the live group ID
1570            * @param groupKey the group key
1571            * @return the group that was removed
1572            */
1573            public Group removeByC_L_GK(long companyId, long liveGroupId,
1574                    java.lang.String groupKey)
1575                    throws com.liferay.portal.NoSuchGroupException;
1576    
1577            /**
1578            * Returns the number of groups where companyId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
1579            *
1580            * @param companyId the company ID
1581            * @param liveGroupId the live group ID
1582            * @param groupKey the group key
1583            * @return the number of matching groups
1584            */
1585            public int countByC_L_GK(long companyId, long liveGroupId,
1586                    java.lang.String groupKey);
1587    
1588            /**
1589            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or throws a {@link NoSuchGroupException} if it could not be found.
1590            *
1591            * @param companyId the company ID
1592            * @param classNameId the class name ID
1593            * @param liveGroupId the live group ID
1594            * @param groupKey the group key
1595            * @return the matching group
1596            * @throws NoSuchGroupException if a matching group could not be found
1597            */
1598            public Group findByC_C_L_GK(long companyId, long classNameId,
1599                    long liveGroupId, java.lang.String groupKey)
1600                    throws com.liferay.portal.NoSuchGroupException;
1601    
1602            /**
1603            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1604            *
1605            * @param companyId the company ID
1606            * @param classNameId the class name ID
1607            * @param liveGroupId the live group ID
1608            * @param groupKey the group key
1609            * @return the matching group, or <code>null</code> if a matching group could not be found
1610            */
1611            public Group fetchByC_C_L_GK(long companyId, long classNameId,
1612                    long liveGroupId, java.lang.String groupKey);
1613    
1614            /**
1615            * Returns the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1616            *
1617            * @param companyId the company ID
1618            * @param classNameId the class name ID
1619            * @param liveGroupId the live group ID
1620            * @param groupKey the group key
1621            * @param retrieveFromCache whether to use the finder cache
1622            * @return the matching group, or <code>null</code> if a matching group could not be found
1623            */
1624            public Group fetchByC_C_L_GK(long companyId, long classNameId,
1625                    long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache);
1626    
1627            /**
1628            * Removes the group where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63; from the database.
1629            *
1630            * @param companyId the company ID
1631            * @param classNameId the class name ID
1632            * @param liveGroupId the live group ID
1633            * @param groupKey the group key
1634            * @return the group that was removed
1635            */
1636            public Group removeByC_C_L_GK(long companyId, long classNameId,
1637                    long liveGroupId, java.lang.String groupKey)
1638                    throws com.liferay.portal.NoSuchGroupException;
1639    
1640            /**
1641            * Returns the number of groups where companyId = &#63; and classNameId = &#63; and liveGroupId = &#63; and groupKey = &#63;.
1642            *
1643            * @param companyId the company ID
1644            * @param classNameId the class name ID
1645            * @param liveGroupId the live group ID
1646            * @param groupKey the group key
1647            * @return the number of matching groups
1648            */
1649            public int countByC_C_L_GK(long companyId, long classNameId,
1650                    long liveGroupId, java.lang.String groupKey);
1651    
1652            /**
1653            * Returns all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1654            *
1655            * @param companyId the company ID
1656            * @param parentGroupId the parent group ID
1657            * @param site the site
1658            * @param inheritContent the inherit content
1659            * @return the matching groups
1660            */
1661            public java.util.List<Group> findByC_P_S_I(long companyId,
1662                    long parentGroupId, boolean site, boolean inheritContent);
1663    
1664            /**
1665            * Returns a range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1666            *
1667            * <p>
1668            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1669            * </p>
1670            *
1671            * @param companyId the company ID
1672            * @param parentGroupId the parent group ID
1673            * @param site the site
1674            * @param inheritContent the inherit content
1675            * @param start the lower bound of the range of groups
1676            * @param end the upper bound of the range of groups (not inclusive)
1677            * @return the range of matching groups
1678            */
1679            public java.util.List<Group> findByC_P_S_I(long companyId,
1680                    long parentGroupId, boolean site, boolean inheritContent, int start,
1681                    int end);
1682    
1683            /**
1684            * Returns an ordered range of all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1685            *
1686            * <p>
1687            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1688            * </p>
1689            *
1690            * @param companyId the company ID
1691            * @param parentGroupId the parent group ID
1692            * @param site the site
1693            * @param inheritContent the inherit content
1694            * @param start the lower bound of the range of groups
1695            * @param end the upper bound of the range of groups (not inclusive)
1696            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1697            * @return the ordered range of matching groups
1698            */
1699            public java.util.List<Group> findByC_P_S_I(long companyId,
1700                    long parentGroupId, boolean site, boolean inheritContent, int start,
1701                    int end,
1702                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1703    
1704            /**
1705            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1706            *
1707            * @param companyId the company ID
1708            * @param parentGroupId the parent group ID
1709            * @param site the site
1710            * @param inheritContent the inherit content
1711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1712            * @return the first matching group
1713            * @throws NoSuchGroupException if a matching group could not be found
1714            */
1715            public Group findByC_P_S_I_First(long companyId, long parentGroupId,
1716                    boolean site, boolean inheritContent,
1717                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1718                    throws com.liferay.portal.NoSuchGroupException;
1719    
1720            /**
1721            * Returns the first group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1722            *
1723            * @param companyId the company ID
1724            * @param parentGroupId the parent group ID
1725            * @param site the site
1726            * @param inheritContent the inherit content
1727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1728            * @return the first matching group, or <code>null</code> if a matching group could not be found
1729            */
1730            public Group fetchByC_P_S_I_First(long companyId, long parentGroupId,
1731                    boolean site, boolean inheritContent,
1732                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1733    
1734            /**
1735            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1736            *
1737            * @param companyId the company ID
1738            * @param parentGroupId the parent group ID
1739            * @param site the site
1740            * @param inheritContent the inherit content
1741            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1742            * @return the last matching group
1743            * @throws NoSuchGroupException if a matching group could not be found
1744            */
1745            public Group findByC_P_S_I_Last(long companyId, long parentGroupId,
1746                    boolean site, boolean inheritContent,
1747                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1748                    throws com.liferay.portal.NoSuchGroupException;
1749    
1750            /**
1751            * Returns the last group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1752            *
1753            * @param companyId the company ID
1754            * @param parentGroupId the parent group ID
1755            * @param site the site
1756            * @param inheritContent the inherit content
1757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1758            * @return the last matching group, or <code>null</code> if a matching group could not be found
1759            */
1760            public Group fetchByC_P_S_I_Last(long companyId, long parentGroupId,
1761                    boolean site, boolean inheritContent,
1762                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1763    
1764            /**
1765            * Returns the groups before and after the current group in the ordered set where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1766            *
1767            * @param groupId the primary key of the current group
1768            * @param companyId the company ID
1769            * @param parentGroupId the parent group ID
1770            * @param site the site
1771            * @param inheritContent the inherit content
1772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1773            * @return the previous, current, and next group
1774            * @throws NoSuchGroupException if a group with the primary key could not be found
1775            */
1776            public Group[] findByC_P_S_I_PrevAndNext(long groupId, long companyId,
1777                    long parentGroupId, boolean site, boolean inheritContent,
1778                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator)
1779                    throws com.liferay.portal.NoSuchGroupException;
1780    
1781            /**
1782            * Removes all the groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63; from the database.
1783            *
1784            * @param companyId the company ID
1785            * @param parentGroupId the parent group ID
1786            * @param site the site
1787            * @param inheritContent the inherit content
1788            */
1789            public void removeByC_P_S_I(long companyId, long parentGroupId,
1790                    boolean site, boolean inheritContent);
1791    
1792            /**
1793            * Returns the number of groups where companyId = &#63; and parentGroupId = &#63; and site = &#63; and inheritContent = &#63;.
1794            *
1795            * @param companyId the company ID
1796            * @param parentGroupId the parent group ID
1797            * @param site the site
1798            * @param inheritContent the inherit content
1799            * @return the number of matching groups
1800            */
1801            public int countByC_P_S_I(long companyId, long parentGroupId, boolean site,
1802                    boolean inheritContent);
1803    
1804            /**
1805            * Caches the group in the entity cache if it is enabled.
1806            *
1807            * @param group the group
1808            */
1809            public void cacheResult(Group group);
1810    
1811            /**
1812            * Caches the groups in the entity cache if it is enabled.
1813            *
1814            * @param groups the groups
1815            */
1816            public void cacheResult(java.util.List<Group> groups);
1817    
1818            /**
1819            * Creates a new group with the primary key. Does not add the group to the database.
1820            *
1821            * @param groupId the primary key for the new group
1822            * @return the new group
1823            */
1824            public Group create(long groupId);
1825    
1826            /**
1827            * Removes the group with the primary key from the database. Also notifies the appropriate model listeners.
1828            *
1829            * @param groupId the primary key of the group
1830            * @return the group that was removed
1831            * @throws NoSuchGroupException if a group with the primary key could not be found
1832            */
1833            public Group remove(long groupId)
1834                    throws com.liferay.portal.NoSuchGroupException;
1835    
1836            public Group updateImpl(Group group);
1837    
1838            /**
1839            * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found.
1840            *
1841            * @param groupId the primary key of the group
1842            * @return the group
1843            * @throws NoSuchGroupException if a group with the primary key could not be found
1844            */
1845            public Group findByPrimaryKey(long groupId)
1846                    throws com.liferay.portal.NoSuchGroupException;
1847    
1848            /**
1849            * Returns the group with the primary key or returns <code>null</code> if it could not be found.
1850            *
1851            * @param groupId the primary key of the group
1852            * @return the group, or <code>null</code> if a group with the primary key could not be found
1853            */
1854            public Group fetchByPrimaryKey(long groupId);
1855    
1856            @Override
1857            public java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys(
1858                    java.util.Set<java.io.Serializable> primaryKeys);
1859    
1860            /**
1861            * Returns all the groups.
1862            *
1863            * @return the groups
1864            */
1865            public java.util.List<Group> findAll();
1866    
1867            /**
1868            * Returns a range of all the groups.
1869            *
1870            * <p>
1871            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1872            * </p>
1873            *
1874            * @param start the lower bound of the range of groups
1875            * @param end the upper bound of the range of groups (not inclusive)
1876            * @return the range of groups
1877            */
1878            public java.util.List<Group> findAll(int start, int end);
1879    
1880            /**
1881            * Returns an ordered range of all the groups.
1882            *
1883            * <p>
1884            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1885            * </p>
1886            *
1887            * @param start the lower bound of the range of groups
1888            * @param end the upper bound of the range of groups (not inclusive)
1889            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1890            * @return the ordered range of groups
1891            */
1892            public java.util.List<Group> findAll(int start, int end,
1893                    com.liferay.portal.kernel.util.OrderByComparator<Group> orderByComparator);
1894    
1895            /**
1896            * Removes all the groups from the database.
1897            */
1898            public void removeAll();
1899    
1900            /**
1901            * Returns the number of groups.
1902            *
1903            * @return the number of groups
1904            */
1905            public int countAll();
1906    
1907            /**
1908            * Returns the primaryKeys of organizations associated with the group.
1909            *
1910            * @param pk the primary key of the group
1911            * @return long[] of the primaryKeys of organizations associated with the group
1912            */
1913            public long[] getOrganizationPrimaryKeys(long pk);
1914    
1915            /**
1916            * Returns all the organizations associated with the group.
1917            *
1918            * @param pk the primary key of the group
1919            * @return the organizations associated with the group
1920            */
1921            public java.util.List<com.liferay.portal.model.Organization> getOrganizations(
1922                    long pk);
1923    
1924            /**
1925            * Returns a range of all the organizations associated with the group.
1926            *
1927            * <p>
1928            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1929            * </p>
1930            *
1931            * @param pk the primary key of the group
1932            * @param start the lower bound of the range of groups
1933            * @param end the upper bound of the range of groups (not inclusive)
1934            * @return the range of organizations associated with the group
1935            */
1936            public java.util.List<com.liferay.portal.model.Organization> getOrganizations(
1937                    long pk, int start, int end);
1938    
1939            /**
1940            * Returns an ordered range of all the organizations associated with the group.
1941            *
1942            * <p>
1943            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1944            * </p>
1945            *
1946            * @param pk the primary key of the group
1947            * @param start the lower bound of the range of groups
1948            * @param end the upper bound of the range of groups (not inclusive)
1949            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1950            * @return the ordered range of organizations associated with the group
1951            */
1952            public java.util.List<com.liferay.portal.model.Organization> getOrganizations(
1953                    long pk, int start, int end,
1954                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Organization> orderByComparator);
1955    
1956            /**
1957            * Returns the number of organizations associated with the group.
1958            *
1959            * @param pk the primary key of the group
1960            * @return the number of organizations associated with the group
1961            */
1962            public int getOrganizationsSize(long pk);
1963    
1964            /**
1965            * Returns <code>true</code> if the organization is associated with the group.
1966            *
1967            * @param pk the primary key of the group
1968            * @param organizationPK the primary key of the organization
1969            * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise
1970            */
1971            public boolean containsOrganization(long pk, long organizationPK);
1972    
1973            /**
1974            * Returns <code>true</code> if the group has any organizations associated with it.
1975            *
1976            * @param pk the primary key of the group to check for associations with organizations
1977            * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise
1978            */
1979            public boolean containsOrganizations(long pk);
1980    
1981            /**
1982            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1983            *
1984            * @param pk the primary key of the group
1985            * @param organizationPK the primary key of the organization
1986            */
1987            public void addOrganization(long pk, long organizationPK);
1988    
1989            /**
1990            * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1991            *
1992            * @param pk the primary key of the group
1993            * @param organization the organization
1994            */
1995            public void addOrganization(long pk,
1996                    com.liferay.portal.model.Organization organization);
1997    
1998            /**
1999            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2000            *
2001            * @param pk the primary key of the group
2002            * @param organizationPKs the primary keys of the organizations
2003            */
2004            public void addOrganizations(long pk, long[] organizationPKs);
2005    
2006            /**
2007            * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2008            *
2009            * @param pk the primary key of the group
2010            * @param organizations the organizations
2011            */
2012            public void addOrganizations(long pk,
2013                    java.util.List<com.liferay.portal.model.Organization> organizations);
2014    
2015            /**
2016            * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2017            *
2018            * @param pk the primary key of the group to clear the associated organizations from
2019            */
2020            public void clearOrganizations(long pk);
2021    
2022            /**
2023            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2024            *
2025            * @param pk the primary key of the group
2026            * @param organizationPK the primary key of the organization
2027            */
2028            public void removeOrganization(long pk, long organizationPK);
2029    
2030            /**
2031            * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2032            *
2033            * @param pk the primary key of the group
2034            * @param organization the organization
2035            */
2036            public void removeOrganization(long pk,
2037                    com.liferay.portal.model.Organization organization);
2038    
2039            /**
2040            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2041            *
2042            * @param pk the primary key of the group
2043            * @param organizationPKs the primary keys of the organizations
2044            */
2045            public void removeOrganizations(long pk, long[] organizationPKs);
2046    
2047            /**
2048            * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2049            *
2050            * @param pk the primary key of the group
2051            * @param organizations the organizations
2052            */
2053            public void removeOrganizations(long pk,
2054                    java.util.List<com.liferay.portal.model.Organization> organizations);
2055    
2056            /**
2057            * 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.
2058            *
2059            * @param pk the primary key of the group
2060            * @param organizationPKs the primary keys of the organizations to be associated with the group
2061            */
2062            public void setOrganizations(long pk, long[] organizationPKs);
2063    
2064            /**
2065            * 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.
2066            *
2067            * @param pk the primary key of the group
2068            * @param organizations the organizations to be associated with the group
2069            */
2070            public void setOrganizations(long pk,
2071                    java.util.List<com.liferay.portal.model.Organization> organizations);
2072    
2073            /**
2074            * Returns the primaryKeys of roles associated with the group.
2075            *
2076            * @param pk the primary key of the group
2077            * @return long[] of the primaryKeys of roles associated with the group
2078            */
2079            public long[] getRolePrimaryKeys(long pk);
2080    
2081            /**
2082            * Returns all the roles associated with the group.
2083            *
2084            * @param pk the primary key of the group
2085            * @return the roles associated with the group
2086            */
2087            public java.util.List<com.liferay.portal.model.Role> getRoles(long pk);
2088    
2089            /**
2090            * Returns a range of all the roles associated with the group.
2091            *
2092            * <p>
2093            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2094            * </p>
2095            *
2096            * @param pk the primary key of the group
2097            * @param start the lower bound of the range of groups
2098            * @param end the upper bound of the range of groups (not inclusive)
2099            * @return the range of roles associated with the group
2100            */
2101            public java.util.List<com.liferay.portal.model.Role> getRoles(long pk,
2102                    int start, int end);
2103    
2104            /**
2105            * Returns an ordered range of all the roles associated with the group.
2106            *
2107            * <p>
2108            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2109            * </p>
2110            *
2111            * @param pk the primary key of the group
2112            * @param start the lower bound of the range of groups
2113            * @param end the upper bound of the range of groups (not inclusive)
2114            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2115            * @return the ordered range of roles associated with the group
2116            */
2117            public java.util.List<com.liferay.portal.model.Role> getRoles(long pk,
2118                    int start, int end,
2119                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator);
2120    
2121            /**
2122            * Returns the number of roles associated with the group.
2123            *
2124            * @param pk the primary key of the group
2125            * @return the number of roles associated with the group
2126            */
2127            public int getRolesSize(long pk);
2128    
2129            /**
2130            * Returns <code>true</code> if the role is associated with the group.
2131            *
2132            * @param pk the primary key of the group
2133            * @param rolePK the primary key of the role
2134            * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise
2135            */
2136            public boolean containsRole(long pk, long rolePK);
2137    
2138            /**
2139            * Returns <code>true</code> if the group has any roles associated with it.
2140            *
2141            * @param pk the primary key of the group to check for associations with roles
2142            * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise
2143            */
2144            public boolean containsRoles(long pk);
2145    
2146            /**
2147            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2148            *
2149            * @param pk the primary key of the group
2150            * @param rolePK the primary key of the role
2151            */
2152            public void addRole(long pk, long rolePK);
2153    
2154            /**
2155            * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2156            *
2157            * @param pk the primary key of the group
2158            * @param role the role
2159            */
2160            public void addRole(long pk, com.liferay.portal.model.Role role);
2161    
2162            /**
2163            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2164            *
2165            * @param pk the primary key of the group
2166            * @param rolePKs the primary keys of the roles
2167            */
2168            public void addRoles(long pk, long[] rolePKs);
2169    
2170            /**
2171            * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2172            *
2173            * @param pk the primary key of the group
2174            * @param roles the roles
2175            */
2176            public void addRoles(long pk,
2177                    java.util.List<com.liferay.portal.model.Role> roles);
2178    
2179            /**
2180            * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2181            *
2182            * @param pk the primary key of the group to clear the associated roles from
2183            */
2184            public void clearRoles(long pk);
2185    
2186            /**
2187            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2188            *
2189            * @param pk the primary key of the group
2190            * @param rolePK the primary key of the role
2191            */
2192            public void removeRole(long pk, long rolePK);
2193    
2194            /**
2195            * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2196            *
2197            * @param pk the primary key of the group
2198            * @param role the role
2199            */
2200            public void removeRole(long pk, com.liferay.portal.model.Role role);
2201    
2202            /**
2203            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2204            *
2205            * @param pk the primary key of the group
2206            * @param rolePKs the primary keys of the roles
2207            */
2208            public void removeRoles(long pk, long[] rolePKs);
2209    
2210            /**
2211            * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2212            *
2213            * @param pk the primary key of the group
2214            * @param roles the roles
2215            */
2216            public void removeRoles(long pk,
2217                    java.util.List<com.liferay.portal.model.Role> roles);
2218    
2219            /**
2220            * 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.
2221            *
2222            * @param pk the primary key of the group
2223            * @param rolePKs the primary keys of the roles to be associated with the group
2224            */
2225            public void setRoles(long pk, long[] rolePKs);
2226    
2227            /**
2228            * 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.
2229            *
2230            * @param pk the primary key of the group
2231            * @param roles the roles to be associated with the group
2232            */
2233            public void setRoles(long pk,
2234                    java.util.List<com.liferay.portal.model.Role> roles);
2235    
2236            /**
2237            * Returns the primaryKeys of user groups associated with the group.
2238            *
2239            * @param pk the primary key of the group
2240            * @return long[] of the primaryKeys of user groups associated with the group
2241            */
2242            public long[] getUserGroupPrimaryKeys(long pk);
2243    
2244            /**
2245            * Returns all the user groups associated with the group.
2246            *
2247            * @param pk the primary key of the group
2248            * @return the user groups associated with the group
2249            */
2250            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2251                    long pk);
2252    
2253            /**
2254            * Returns a range of all the user groups associated with the group.
2255            *
2256            * <p>
2257            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2258            * </p>
2259            *
2260            * @param pk the primary key of the group
2261            * @param start the lower bound of the range of groups
2262            * @param end the upper bound of the range of groups (not inclusive)
2263            * @return the range of user groups associated with the group
2264            */
2265            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2266                    long pk, int start, int end);
2267    
2268            /**
2269            * Returns an ordered range of all the user groups associated with the group.
2270            *
2271            * <p>
2272            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2273            * </p>
2274            *
2275            * @param pk the primary key of the group
2276            * @param start the lower bound of the range of groups
2277            * @param end the upper bound of the range of groups (not inclusive)
2278            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2279            * @return the ordered range of user groups associated with the group
2280            */
2281            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
2282                    long pk, int start, int end,
2283                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator);
2284    
2285            /**
2286            * Returns the number of user groups associated with the group.
2287            *
2288            * @param pk the primary key of the group
2289            * @return the number of user groups associated with the group
2290            */
2291            public int getUserGroupsSize(long pk);
2292    
2293            /**
2294            * Returns <code>true</code> if the user group is associated with the group.
2295            *
2296            * @param pk the primary key of the group
2297            * @param userGroupPK the primary key of the user group
2298            * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise
2299            */
2300            public boolean containsUserGroup(long pk, long userGroupPK);
2301    
2302            /**
2303            * Returns <code>true</code> if the group has any user groups associated with it.
2304            *
2305            * @param pk the primary key of the group to check for associations with user groups
2306            * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise
2307            */
2308            public boolean containsUserGroups(long pk);
2309    
2310            /**
2311            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2312            *
2313            * @param pk the primary key of the group
2314            * @param userGroupPK the primary key of the user group
2315            */
2316            public void addUserGroup(long pk, long userGroupPK);
2317    
2318            /**
2319            * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2320            *
2321            * @param pk the primary key of the group
2322            * @param userGroup the user group
2323            */
2324            public void addUserGroup(long pk,
2325                    com.liferay.portal.model.UserGroup userGroup);
2326    
2327            /**
2328            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2329            *
2330            * @param pk the primary key of the group
2331            * @param userGroupPKs the primary keys of the user groups
2332            */
2333            public void addUserGroups(long pk, long[] userGroupPKs);
2334    
2335            /**
2336            * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2337            *
2338            * @param pk the primary key of the group
2339            * @param userGroups the user groups
2340            */
2341            public void addUserGroups(long pk,
2342                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
2343    
2344            /**
2345            * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2346            *
2347            * @param pk the primary key of the group to clear the associated user groups from
2348            */
2349            public void clearUserGroups(long pk);
2350    
2351            /**
2352            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2353            *
2354            * @param pk the primary key of the group
2355            * @param userGroupPK the primary key of the user group
2356            */
2357            public void removeUserGroup(long pk, long userGroupPK);
2358    
2359            /**
2360            * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2361            *
2362            * @param pk the primary key of the group
2363            * @param userGroup the user group
2364            */
2365            public void removeUserGroup(long pk,
2366                    com.liferay.portal.model.UserGroup userGroup);
2367    
2368            /**
2369            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2370            *
2371            * @param pk the primary key of the group
2372            * @param userGroupPKs the primary keys of the user groups
2373            */
2374            public void removeUserGroups(long pk, long[] userGroupPKs);
2375    
2376            /**
2377            * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2378            *
2379            * @param pk the primary key of the group
2380            * @param userGroups the user groups
2381            */
2382            public void removeUserGroups(long pk,
2383                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
2384    
2385            /**
2386            * 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.
2387            *
2388            * @param pk the primary key of the group
2389            * @param userGroupPKs the primary keys of the user groups to be associated with the group
2390            */
2391            public void setUserGroups(long pk, long[] userGroupPKs);
2392    
2393            /**
2394            * 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.
2395            *
2396            * @param pk the primary key of the group
2397            * @param userGroups the user groups to be associated with the group
2398            */
2399            public void setUserGroups(long pk,
2400                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
2401    
2402            /**
2403            * Returns the primaryKeys of users associated with the group.
2404            *
2405            * @param pk the primary key of the group
2406            * @return long[] of the primaryKeys of users associated with the group
2407            */
2408            public long[] getUserPrimaryKeys(long pk);
2409    
2410            /**
2411            * Returns all the users associated with the group.
2412            *
2413            * @param pk the primary key of the group
2414            * @return the users associated with the group
2415            */
2416            public java.util.List<com.liferay.portal.model.User> getUsers(long pk);
2417    
2418            /**
2419            * Returns a range of all the users associated with the group.
2420            *
2421            * <p>
2422            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2423            * </p>
2424            *
2425            * @param pk the primary key of the group
2426            * @param start the lower bound of the range of groups
2427            * @param end the upper bound of the range of groups (not inclusive)
2428            * @return the range of users associated with the group
2429            */
2430            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
2431                    int start, int end);
2432    
2433            /**
2434            * Returns an ordered range of all the users associated with the group.
2435            *
2436            * <p>
2437            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2438            * </p>
2439            *
2440            * @param pk the primary key of the group
2441            * @param start the lower bound of the range of groups
2442            * @param end the upper bound of the range of groups (not inclusive)
2443            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2444            * @return the ordered range of users associated with the group
2445            */
2446            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
2447                    int start, int end,
2448                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator);
2449    
2450            /**
2451            * Returns the number of users associated with the group.
2452            *
2453            * @param pk the primary key of the group
2454            * @return the number of users associated with the group
2455            */
2456            public int getUsersSize(long pk);
2457    
2458            /**
2459            * Returns <code>true</code> if the user is associated with the group.
2460            *
2461            * @param pk the primary key of the group
2462            * @param userPK the primary key of the user
2463            * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise
2464            */
2465            public boolean containsUser(long pk, long userPK);
2466    
2467            /**
2468            * Returns <code>true</code> if the group has any users associated with it.
2469            *
2470            * @param pk the primary key of the group to check for associations with users
2471            * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise
2472            */
2473            public boolean containsUsers(long pk);
2474    
2475            /**
2476            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2477            *
2478            * @param pk the primary key of the group
2479            * @param userPK the primary key of the user
2480            */
2481            public void addUser(long pk, long userPK);
2482    
2483            /**
2484            * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2485            *
2486            * @param pk the primary key of the group
2487            * @param user the user
2488            */
2489            public void addUser(long pk, com.liferay.portal.model.User user);
2490    
2491            /**
2492            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2493            *
2494            * @param pk the primary key of the group
2495            * @param userPKs the primary keys of the users
2496            */
2497            public void addUsers(long pk, long[] userPKs);
2498    
2499            /**
2500            * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2501            *
2502            * @param pk the primary key of the group
2503            * @param users the users
2504            */
2505            public void addUsers(long pk,
2506                    java.util.List<com.liferay.portal.model.User> users);
2507    
2508            /**
2509            * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2510            *
2511            * @param pk the primary key of the group to clear the associated users from
2512            */
2513            public void clearUsers(long pk);
2514    
2515            /**
2516            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2517            *
2518            * @param pk the primary key of the group
2519            * @param userPK the primary key of the user
2520            */
2521            public void removeUser(long pk, long userPK);
2522    
2523            /**
2524            * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2525            *
2526            * @param pk the primary key of the group
2527            * @param user the user
2528            */
2529            public void removeUser(long pk, com.liferay.portal.model.User user);
2530    
2531            /**
2532            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2533            *
2534            * @param pk the primary key of the group
2535            * @param userPKs the primary keys of the users
2536            */
2537            public void removeUsers(long pk, long[] userPKs);
2538    
2539            /**
2540            * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2541            *
2542            * @param pk the primary key of the group
2543            * @param users the users
2544            */
2545            public void removeUsers(long pk,
2546                    java.util.List<com.liferay.portal.model.User> users);
2547    
2548            /**
2549            * 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.
2550            *
2551            * @param pk the primary key of the group
2552            * @param userPKs the primary keys of the users to be associated with the group
2553            */
2554            public void setUsers(long pk, long[] userPKs);
2555    
2556            /**
2557            * 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.
2558            *
2559            * @param pk the primary key of the group
2560            * @param users the users to be associated with the group
2561            */
2562            public void setUsers(long pk,
2563                    java.util.List<com.liferay.portal.model.User> users);
2564    }