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