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