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