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