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.UserGroup;
020    
021    /**
022     * The persistence interface for the user 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.UserGroupPersistenceImpl
030     * @see UserGroupUtil
031     * @generated
032     */
033    @ProviderType
034    public interface UserGroupPersistence extends BasePersistence<UserGroup> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link UserGroupUtil} to access the user group persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the user groups where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching user groups
046            */
047            public java.util.List<UserGroup> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the user 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 UserGroupModelImpl}. 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 user groups
058            * @param end the upper bound of the range of user groups (not inclusive)
059            * @return the range of matching user groups
060            */
061            public java.util.List<UserGroup> findByUuid(java.lang.String uuid,
062                    int start, int end);
063    
064            /**
065            * Returns an ordered range of all the user 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 UserGroupModelImpl}. 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 user groups
073            * @param end the upper bound of the range of user groups (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching user groups
076            */
077            public java.util.List<UserGroup> findByUuid(java.lang.String uuid,
078                    int start, int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
080    
081            /**
082            * Returns the first user group in the ordered set where uuid = &#63;.
083            *
084            * @param uuid the uuid
085            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
086            * @return the first matching user group
087            * @throws NoSuchUserGroupException if a matching user group could not be found
088            */
089            public UserGroup findByUuid_First(java.lang.String uuid,
090                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
091                    throws com.liferay.portal.NoSuchUserGroupException;
092    
093            /**
094            * Returns the first user group in the ordered set where uuid = &#63;.
095            *
096            * @param uuid the uuid
097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
098            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
099            */
100            public UserGroup fetchByUuid_First(java.lang.String uuid,
101                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
102    
103            /**
104            * Returns the last user group in the ordered set where uuid = &#63;.
105            *
106            * @param uuid the uuid
107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
108            * @return the last matching user group
109            * @throws NoSuchUserGroupException if a matching user group could not be found
110            */
111            public UserGroup findByUuid_Last(java.lang.String uuid,
112                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
113                    throws com.liferay.portal.NoSuchUserGroupException;
114    
115            /**
116            * Returns the last user group in the ordered set where uuid = &#63;.
117            *
118            * @param uuid the uuid
119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
120            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
121            */
122            public UserGroup fetchByUuid_Last(java.lang.String uuid,
123                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
124    
125            /**
126            * Returns the user groups before and after the current user group in the ordered set where uuid = &#63;.
127            *
128            * @param userGroupId the primary key of the current user group
129            * @param uuid the uuid
130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
131            * @return the previous, current, and next user group
132            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
133            */
134            public UserGroup[] findByUuid_PrevAndNext(long userGroupId,
135                    java.lang.String uuid,
136                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
137                    throws com.liferay.portal.NoSuchUserGroupException;
138    
139            /**
140            * Returns all the user groups that the user has permission to view where uuid = &#63;.
141            *
142            * @param uuid the uuid
143            * @return the matching user groups that the user has permission to view
144            */
145            public java.util.List<UserGroup> filterFindByUuid(java.lang.String uuid);
146    
147            /**
148            * Returns a range of all the user groups that the user has permission to view where uuid = &#63;.
149            *
150            * <p>
151            * 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 UserGroupModelImpl}. 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.
152            * </p>
153            *
154            * @param uuid the uuid
155            * @param start the lower bound of the range of user groups
156            * @param end the upper bound of the range of user groups (not inclusive)
157            * @return the range of matching user groups that the user has permission to view
158            */
159            public java.util.List<UserGroup> filterFindByUuid(java.lang.String uuid,
160                    int start, int end);
161    
162            /**
163            * Returns an ordered range of all the user groups that the user has permissions to view where uuid = &#63;.
164            *
165            * <p>
166            * 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 UserGroupModelImpl}. 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.
167            * </p>
168            *
169            * @param uuid the uuid
170            * @param start the lower bound of the range of user groups
171            * @param end the upper bound of the range of user groups (not inclusive)
172            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
173            * @return the ordered range of matching user groups that the user has permission to view
174            */
175            public java.util.List<UserGroup> filterFindByUuid(java.lang.String uuid,
176                    int start, int end,
177                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
178    
179            /**
180            * Returns the user groups before and after the current user group in the ordered set of user groups that the user has permission to view where uuid = &#63;.
181            *
182            * @param userGroupId the primary key of the current user group
183            * @param uuid the uuid
184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
185            * @return the previous, current, and next user group
186            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
187            */
188            public UserGroup[] filterFindByUuid_PrevAndNext(long userGroupId,
189                    java.lang.String uuid,
190                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
191                    throws com.liferay.portal.NoSuchUserGroupException;
192    
193            /**
194            * Removes all the user groups where uuid = &#63; from the database.
195            *
196            * @param uuid the uuid
197            */
198            public void removeByUuid(java.lang.String uuid);
199    
200            /**
201            * Returns the number of user groups where uuid = &#63;.
202            *
203            * @param uuid the uuid
204            * @return the number of matching user groups
205            */
206            public int countByUuid(java.lang.String uuid);
207    
208            /**
209            * Returns the number of user groups that the user has permission to view where uuid = &#63;.
210            *
211            * @param uuid the uuid
212            * @return the number of matching user groups that the user has permission to view
213            */
214            public int filterCountByUuid(java.lang.String uuid);
215    
216            /**
217            * Returns all the user groups where uuid = &#63; and companyId = &#63;.
218            *
219            * @param uuid the uuid
220            * @param companyId the company ID
221            * @return the matching user groups
222            */
223            public java.util.List<UserGroup> findByUuid_C(java.lang.String uuid,
224                    long companyId);
225    
226            /**
227            * Returns a range of all the user groups where uuid = &#63; and companyId = &#63;.
228            *
229            * <p>
230            * 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 UserGroupModelImpl}. 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.
231            * </p>
232            *
233            * @param uuid the uuid
234            * @param companyId the company ID
235            * @param start the lower bound of the range of user groups
236            * @param end the upper bound of the range of user groups (not inclusive)
237            * @return the range of matching user groups
238            */
239            public java.util.List<UserGroup> findByUuid_C(java.lang.String uuid,
240                    long companyId, int start, int end);
241    
242            /**
243            * Returns an ordered range of all the user groups where uuid = &#63; and companyId = &#63;.
244            *
245            * <p>
246            * 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 UserGroupModelImpl}. 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.
247            * </p>
248            *
249            * @param uuid the uuid
250            * @param companyId the company ID
251            * @param start the lower bound of the range of user groups
252            * @param end the upper bound of the range of user groups (not inclusive)
253            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
254            * @return the ordered range of matching user groups
255            */
256            public java.util.List<UserGroup> findByUuid_C(java.lang.String uuid,
257                    long companyId, int start, int end,
258                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
259    
260            /**
261            * Returns the first user group in the ordered set where uuid = &#63; and companyId = &#63;.
262            *
263            * @param uuid the uuid
264            * @param companyId the company ID
265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
266            * @return the first matching user group
267            * @throws NoSuchUserGroupException if a matching user group could not be found
268            */
269            public UserGroup findByUuid_C_First(java.lang.String uuid, long companyId,
270                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
271                    throws com.liferay.portal.NoSuchUserGroupException;
272    
273            /**
274            * Returns the first user group in the ordered set where uuid = &#63; and companyId = &#63;.
275            *
276            * @param uuid the uuid
277            * @param companyId the company ID
278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
279            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
280            */
281            public UserGroup fetchByUuid_C_First(java.lang.String uuid, long companyId,
282                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
283    
284            /**
285            * Returns the last user group in the ordered set where uuid = &#63; and companyId = &#63;.
286            *
287            * @param uuid the uuid
288            * @param companyId the company ID
289            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
290            * @return the last matching user group
291            * @throws NoSuchUserGroupException if a matching user group could not be found
292            */
293            public UserGroup findByUuid_C_Last(java.lang.String uuid, long companyId,
294                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
295                    throws com.liferay.portal.NoSuchUserGroupException;
296    
297            /**
298            * Returns the last user group in the ordered set where uuid = &#63; and companyId = &#63;.
299            *
300            * @param uuid the uuid
301            * @param companyId the company ID
302            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
303            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
304            */
305            public UserGroup fetchByUuid_C_Last(java.lang.String uuid, long companyId,
306                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
307    
308            /**
309            * Returns the user groups before and after the current user group in the ordered set where uuid = &#63; and companyId = &#63;.
310            *
311            * @param userGroupId the primary key of the current user group
312            * @param uuid the uuid
313            * @param companyId the company ID
314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
315            * @return the previous, current, and next user group
316            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
317            */
318            public UserGroup[] findByUuid_C_PrevAndNext(long userGroupId,
319                    java.lang.String uuid, long companyId,
320                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
321                    throws com.liferay.portal.NoSuchUserGroupException;
322    
323            /**
324            * Returns all the user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
325            *
326            * @param uuid the uuid
327            * @param companyId the company ID
328            * @return the matching user groups that the user has permission to view
329            */
330            public java.util.List<UserGroup> filterFindByUuid_C(java.lang.String uuid,
331                    long companyId);
332    
333            /**
334            * Returns a range of all the user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
335            *
336            * <p>
337            * 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 UserGroupModelImpl}. 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.
338            * </p>
339            *
340            * @param uuid the uuid
341            * @param companyId the company ID
342            * @param start the lower bound of the range of user groups
343            * @param end the upper bound of the range of user groups (not inclusive)
344            * @return the range of matching user groups that the user has permission to view
345            */
346            public java.util.List<UserGroup> filterFindByUuid_C(java.lang.String uuid,
347                    long companyId, int start, int end);
348    
349            /**
350            * Returns an ordered range of all the user groups that the user has permissions to view where uuid = &#63; and companyId = &#63;.
351            *
352            * <p>
353            * 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 UserGroupModelImpl}. 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.
354            * </p>
355            *
356            * @param uuid the uuid
357            * @param companyId the company ID
358            * @param start the lower bound of the range of user groups
359            * @param end the upper bound of the range of user groups (not inclusive)
360            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
361            * @return the ordered range of matching user groups that the user has permission to view
362            */
363            public java.util.List<UserGroup> filterFindByUuid_C(java.lang.String uuid,
364                    long companyId, int start, int end,
365                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
366    
367            /**
368            * Returns the user groups before and after the current user group in the ordered set of user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
369            *
370            * @param userGroupId the primary key of the current user group
371            * @param uuid the uuid
372            * @param companyId the company ID
373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
374            * @return the previous, current, and next user group
375            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
376            */
377            public UserGroup[] filterFindByUuid_C_PrevAndNext(long userGroupId,
378                    java.lang.String uuid, long companyId,
379                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
380                    throws com.liferay.portal.NoSuchUserGroupException;
381    
382            /**
383            * Removes all the user groups where uuid = &#63; and companyId = &#63; from the database.
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            */
388            public void removeByUuid_C(java.lang.String uuid, long companyId);
389    
390            /**
391            * Returns the number of user groups where uuid = &#63; and companyId = &#63;.
392            *
393            * @param uuid the uuid
394            * @param companyId the company ID
395            * @return the number of matching user groups
396            */
397            public int countByUuid_C(java.lang.String uuid, long companyId);
398    
399            /**
400            * Returns the number of user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
401            *
402            * @param uuid the uuid
403            * @param companyId the company ID
404            * @return the number of matching user groups that the user has permission to view
405            */
406            public int filterCountByUuid_C(java.lang.String uuid, long companyId);
407    
408            /**
409            * Returns all the user groups where companyId = &#63;.
410            *
411            * @param companyId the company ID
412            * @return the matching user groups
413            */
414            public java.util.List<UserGroup> findByCompanyId(long companyId);
415    
416            /**
417            * Returns a range of all the user groups where companyId = &#63;.
418            *
419            * <p>
420            * 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 UserGroupModelImpl}. 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.
421            * </p>
422            *
423            * @param companyId the company ID
424            * @param start the lower bound of the range of user groups
425            * @param end the upper bound of the range of user groups (not inclusive)
426            * @return the range of matching user groups
427            */
428            public java.util.List<UserGroup> findByCompanyId(long companyId, int start,
429                    int end);
430    
431            /**
432            * Returns an ordered range of all the user groups where companyId = &#63;.
433            *
434            * <p>
435            * 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 UserGroupModelImpl}. 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.
436            * </p>
437            *
438            * @param companyId the company ID
439            * @param start the lower bound of the range of user groups
440            * @param end the upper bound of the range of user groups (not inclusive)
441            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
442            * @return the ordered range of matching user groups
443            */
444            public java.util.List<UserGroup> findByCompanyId(long companyId, int start,
445                    int end,
446                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
447    
448            /**
449            * Returns the first user group in the ordered set where companyId = &#63;.
450            *
451            * @param companyId the company ID
452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
453            * @return the first matching user group
454            * @throws NoSuchUserGroupException if a matching user group could not be found
455            */
456            public UserGroup findByCompanyId_First(long companyId,
457                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
458                    throws com.liferay.portal.NoSuchUserGroupException;
459    
460            /**
461            * Returns the first user group in the ordered set where companyId = &#63;.
462            *
463            * @param companyId the company ID
464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
465            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
466            */
467            public UserGroup fetchByCompanyId_First(long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
469    
470            /**
471            * Returns the last user group in the ordered set where companyId = &#63;.
472            *
473            * @param companyId the company ID
474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
475            * @return the last matching user group
476            * @throws NoSuchUserGroupException if a matching user group could not be found
477            */
478            public UserGroup findByCompanyId_Last(long companyId,
479                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
480                    throws com.liferay.portal.NoSuchUserGroupException;
481    
482            /**
483            * Returns the last user group in the ordered set where companyId = &#63;.
484            *
485            * @param companyId the company ID
486            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
487            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
488            */
489            public UserGroup fetchByCompanyId_Last(long companyId,
490                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
491    
492            /**
493            * Returns the user groups before and after the current user group in the ordered set where companyId = &#63;.
494            *
495            * @param userGroupId the primary key of the current user group
496            * @param companyId the company ID
497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
498            * @return the previous, current, and next user group
499            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
500            */
501            public UserGroup[] findByCompanyId_PrevAndNext(long userGroupId,
502                    long companyId,
503                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
504                    throws com.liferay.portal.NoSuchUserGroupException;
505    
506            /**
507            * Returns all the user groups that the user has permission to view where companyId = &#63;.
508            *
509            * @param companyId the company ID
510            * @return the matching user groups that the user has permission to view
511            */
512            public java.util.List<UserGroup> filterFindByCompanyId(long companyId);
513    
514            /**
515            * Returns a range of all the user groups that the user has permission to view where companyId = &#63;.
516            *
517            * <p>
518            * 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 UserGroupModelImpl}. 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.
519            * </p>
520            *
521            * @param companyId the company ID
522            * @param start the lower bound of the range of user groups
523            * @param end the upper bound of the range of user groups (not inclusive)
524            * @return the range of matching user groups that the user has permission to view
525            */
526            public java.util.List<UserGroup> filterFindByCompanyId(long companyId,
527                    int start, int end);
528    
529            /**
530            * Returns an ordered range of all the user groups that the user has permissions to view where companyId = &#63;.
531            *
532            * <p>
533            * 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 UserGroupModelImpl}. 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.
534            * </p>
535            *
536            * @param companyId the company ID
537            * @param start the lower bound of the range of user groups
538            * @param end the upper bound of the range of user groups (not inclusive)
539            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
540            * @return the ordered range of matching user groups that the user has permission to view
541            */
542            public java.util.List<UserGroup> filterFindByCompanyId(long companyId,
543                    int start, int end,
544                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
545    
546            /**
547            * Returns the user groups before and after the current user group in the ordered set of user groups that the user has permission to view where companyId = &#63;.
548            *
549            * @param userGroupId the primary key of the current user group
550            * @param companyId the company ID
551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
552            * @return the previous, current, and next user group
553            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
554            */
555            public UserGroup[] filterFindByCompanyId_PrevAndNext(long userGroupId,
556                    long companyId,
557                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
558                    throws com.liferay.portal.NoSuchUserGroupException;
559    
560            /**
561            * Removes all the user groups where companyId = &#63; from the database.
562            *
563            * @param companyId the company ID
564            */
565            public void removeByCompanyId(long companyId);
566    
567            /**
568            * Returns the number of user groups where companyId = &#63;.
569            *
570            * @param companyId the company ID
571            * @return the number of matching user groups
572            */
573            public int countByCompanyId(long companyId);
574    
575            /**
576            * Returns the number of user groups that the user has permission to view where companyId = &#63;.
577            *
578            * @param companyId the company ID
579            * @return the number of matching user groups that the user has permission to view
580            */
581            public int filterCountByCompanyId(long companyId);
582    
583            /**
584            * Returns all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
585            *
586            * @param companyId the company ID
587            * @param parentUserGroupId the parent user group ID
588            * @return the matching user groups
589            */
590            public java.util.List<UserGroup> findByC_P(long companyId,
591                    long parentUserGroupId);
592    
593            /**
594            * Returns a range of all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
595            *
596            * <p>
597            * 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 UserGroupModelImpl}. 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.
598            * </p>
599            *
600            * @param companyId the company ID
601            * @param parentUserGroupId the parent user group ID
602            * @param start the lower bound of the range of user groups
603            * @param end the upper bound of the range of user groups (not inclusive)
604            * @return the range of matching user groups
605            */
606            public java.util.List<UserGroup> findByC_P(long companyId,
607                    long parentUserGroupId, int start, int end);
608    
609            /**
610            * Returns an ordered range of all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
611            *
612            * <p>
613            * 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 UserGroupModelImpl}. 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.
614            * </p>
615            *
616            * @param companyId the company ID
617            * @param parentUserGroupId the parent user group ID
618            * @param start the lower bound of the range of user groups
619            * @param end the upper bound of the range of user groups (not inclusive)
620            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
621            * @return the ordered range of matching user groups
622            */
623            public java.util.List<UserGroup> findByC_P(long companyId,
624                    long parentUserGroupId, int start, int end,
625                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
626    
627            /**
628            * Returns the first user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
629            *
630            * @param companyId the company ID
631            * @param parentUserGroupId the parent user group ID
632            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
633            * @return the first matching user group
634            * @throws NoSuchUserGroupException if a matching user group could not be found
635            */
636            public UserGroup findByC_P_First(long companyId, long parentUserGroupId,
637                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
638                    throws com.liferay.portal.NoSuchUserGroupException;
639    
640            /**
641            * Returns the first user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
642            *
643            * @param companyId the company ID
644            * @param parentUserGroupId the parent user group ID
645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
646            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
647            */
648            public UserGroup fetchByC_P_First(long companyId, long parentUserGroupId,
649                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
650    
651            /**
652            * Returns the last user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
653            *
654            * @param companyId the company ID
655            * @param parentUserGroupId the parent user group ID
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the last matching user group
658            * @throws NoSuchUserGroupException if a matching user group could not be found
659            */
660            public UserGroup findByC_P_Last(long companyId, long parentUserGroupId,
661                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
662                    throws com.liferay.portal.NoSuchUserGroupException;
663    
664            /**
665            * Returns the last user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
666            *
667            * @param companyId the company ID
668            * @param parentUserGroupId the parent user group ID
669            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
670            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
671            */
672            public UserGroup fetchByC_P_Last(long companyId, long parentUserGroupId,
673                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
674    
675            /**
676            * Returns the user groups before and after the current user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
677            *
678            * @param userGroupId the primary key of the current user group
679            * @param companyId the company ID
680            * @param parentUserGroupId the parent user group ID
681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
682            * @return the previous, current, and next user group
683            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
684            */
685            public UserGroup[] findByC_P_PrevAndNext(long userGroupId, long companyId,
686                    long parentUserGroupId,
687                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
688                    throws com.liferay.portal.NoSuchUserGroupException;
689    
690            /**
691            * Returns all the user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
692            *
693            * @param companyId the company ID
694            * @param parentUserGroupId the parent user group ID
695            * @return the matching user groups that the user has permission to view
696            */
697            public java.util.List<UserGroup> filterFindByC_P(long companyId,
698                    long parentUserGroupId);
699    
700            /**
701            * Returns a range of all the user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
702            *
703            * <p>
704            * 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 UserGroupModelImpl}. 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.
705            * </p>
706            *
707            * @param companyId the company ID
708            * @param parentUserGroupId the parent user group ID
709            * @param start the lower bound of the range of user groups
710            * @param end the upper bound of the range of user groups (not inclusive)
711            * @return the range of matching user groups that the user has permission to view
712            */
713            public java.util.List<UserGroup> filterFindByC_P(long companyId,
714                    long parentUserGroupId, int start, int end);
715    
716            /**
717            * Returns an ordered range of all the user groups that the user has permissions to view where companyId = &#63; and parentUserGroupId = &#63;.
718            *
719            * <p>
720            * 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 UserGroupModelImpl}. 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.
721            * </p>
722            *
723            * @param companyId the company ID
724            * @param parentUserGroupId the parent user group ID
725            * @param start the lower bound of the range of user groups
726            * @param end the upper bound of the range of user groups (not inclusive)
727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
728            * @return the ordered range of matching user groups that the user has permission to view
729            */
730            public java.util.List<UserGroup> filterFindByC_P(long companyId,
731                    long parentUserGroupId, int start, int end,
732                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
733    
734            /**
735            * Returns the user groups before and after the current user group in the ordered set of user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
736            *
737            * @param userGroupId the primary key of the current user group
738            * @param companyId the company ID
739            * @param parentUserGroupId the parent user group ID
740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
741            * @return the previous, current, and next user group
742            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
743            */
744            public UserGroup[] filterFindByC_P_PrevAndNext(long userGroupId,
745                    long companyId, long parentUserGroupId,
746                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator)
747                    throws com.liferay.portal.NoSuchUserGroupException;
748    
749            /**
750            * Removes all the user groups where companyId = &#63; and parentUserGroupId = &#63; from the database.
751            *
752            * @param companyId the company ID
753            * @param parentUserGroupId the parent user group ID
754            */
755            public void removeByC_P(long companyId, long parentUserGroupId);
756    
757            /**
758            * Returns the number of user groups where companyId = &#63; and parentUserGroupId = &#63;.
759            *
760            * @param companyId the company ID
761            * @param parentUserGroupId the parent user group ID
762            * @return the number of matching user groups
763            */
764            public int countByC_P(long companyId, long parentUserGroupId);
765    
766            /**
767            * Returns the number of user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
768            *
769            * @param companyId the company ID
770            * @param parentUserGroupId the parent user group ID
771            * @return the number of matching user groups that the user has permission to view
772            */
773            public int filterCountByC_P(long companyId, long parentUserGroupId);
774    
775            /**
776            * Returns the user group where companyId = &#63; and name = &#63; or throws a {@link NoSuchUserGroupException} if it could not be found.
777            *
778            * @param companyId the company ID
779            * @param name the name
780            * @return the matching user group
781            * @throws NoSuchUserGroupException if a matching user group could not be found
782            */
783            public UserGroup findByC_N(long companyId, java.lang.String name)
784                    throws com.liferay.portal.NoSuchUserGroupException;
785    
786            /**
787            * Returns the user group where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
788            *
789            * @param companyId the company ID
790            * @param name the name
791            * @return the matching user group, or <code>null</code> if a matching user group could not be found
792            */
793            public UserGroup fetchByC_N(long companyId, java.lang.String name);
794    
795            /**
796            * Returns the user group where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
797            *
798            * @param companyId the company ID
799            * @param name the name
800            * @param retrieveFromCache whether to use the finder cache
801            * @return the matching user group, or <code>null</code> if a matching user group could not be found
802            */
803            public UserGroup fetchByC_N(long companyId, java.lang.String name,
804                    boolean retrieveFromCache);
805    
806            /**
807            * Removes the user group where companyId = &#63; and name = &#63; from the database.
808            *
809            * @param companyId the company ID
810            * @param name the name
811            * @return the user group that was removed
812            */
813            public UserGroup removeByC_N(long companyId, java.lang.String name)
814                    throws com.liferay.portal.NoSuchUserGroupException;
815    
816            /**
817            * Returns the number of user groups where companyId = &#63; and name = &#63;.
818            *
819            * @param companyId the company ID
820            * @param name the name
821            * @return the number of matching user groups
822            */
823            public int countByC_N(long companyId, java.lang.String name);
824    
825            /**
826            * Caches the user group in the entity cache if it is enabled.
827            *
828            * @param userGroup the user group
829            */
830            public void cacheResult(UserGroup userGroup);
831    
832            /**
833            * Caches the user groups in the entity cache if it is enabled.
834            *
835            * @param userGroups the user groups
836            */
837            public void cacheResult(java.util.List<UserGroup> userGroups);
838    
839            /**
840            * Creates a new user group with the primary key. Does not add the user group to the database.
841            *
842            * @param userGroupId the primary key for the new user group
843            * @return the new user group
844            */
845            public UserGroup create(long userGroupId);
846    
847            /**
848            * Removes the user group with the primary key from the database. Also notifies the appropriate model listeners.
849            *
850            * @param userGroupId the primary key of the user group
851            * @return the user group that was removed
852            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
853            */
854            public UserGroup remove(long userGroupId)
855                    throws com.liferay.portal.NoSuchUserGroupException;
856    
857            public UserGroup updateImpl(UserGroup userGroup);
858    
859            /**
860            * Returns the user group with the primary key or throws a {@link NoSuchUserGroupException} if it could not be found.
861            *
862            * @param userGroupId the primary key of the user group
863            * @return the user group
864            * @throws NoSuchUserGroupException if a user group with the primary key could not be found
865            */
866            public UserGroup findByPrimaryKey(long userGroupId)
867                    throws com.liferay.portal.NoSuchUserGroupException;
868    
869            /**
870            * Returns the user group with the primary key or returns <code>null</code> if it could not be found.
871            *
872            * @param userGroupId the primary key of the user group
873            * @return the user group, or <code>null</code> if a user group with the primary key could not be found
874            */
875            public UserGroup fetchByPrimaryKey(long userGroupId);
876    
877            @Override
878            public java.util.Map<java.io.Serializable, UserGroup> fetchByPrimaryKeys(
879                    java.util.Set<java.io.Serializable> primaryKeys);
880    
881            /**
882            * Returns all the user groups.
883            *
884            * @return the user groups
885            */
886            public java.util.List<UserGroup> findAll();
887    
888            /**
889            * Returns a range of all the user groups.
890            *
891            * <p>
892            * 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 UserGroupModelImpl}. 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.
893            * </p>
894            *
895            * @param start the lower bound of the range of user groups
896            * @param end the upper bound of the range of user groups (not inclusive)
897            * @return the range of user groups
898            */
899            public java.util.List<UserGroup> findAll(int start, int end);
900    
901            /**
902            * Returns an ordered range of all the user groups.
903            *
904            * <p>
905            * 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 UserGroupModelImpl}. 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.
906            * </p>
907            *
908            * @param start the lower bound of the range of user groups
909            * @param end the upper bound of the range of user groups (not inclusive)
910            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
911            * @return the ordered range of user groups
912            */
913            public java.util.List<UserGroup> findAll(int start, int end,
914                    com.liferay.portal.kernel.util.OrderByComparator<UserGroup> orderByComparator);
915    
916            /**
917            * Removes all the user groups from the database.
918            */
919            public void removeAll();
920    
921            /**
922            * Returns the number of user groups.
923            *
924            * @return the number of user groups
925            */
926            public int countAll();
927    
928            /**
929            * Returns the primaryKeys of groups associated with the user group.
930            *
931            * @param pk the primary key of the user group
932            * @return long[] of the primaryKeys of groups associated with the user group
933            */
934            public long[] getGroupPrimaryKeys(long pk);
935    
936            /**
937            * Returns all the groups associated with the user group.
938            *
939            * @param pk the primary key of the user group
940            * @return the groups associated with the user group
941            */
942            public java.util.List<com.liferay.portal.model.Group> getGroups(long pk);
943    
944            /**
945            * Returns a range of all the groups associated with the user group.
946            *
947            * <p>
948            * 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 UserGroupModelImpl}. 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.
949            * </p>
950            *
951            * @param pk the primary key of the user group
952            * @param start the lower bound of the range of user groups
953            * @param end the upper bound of the range of user groups (not inclusive)
954            * @return the range of groups associated with the user group
955            */
956            public java.util.List<com.liferay.portal.model.Group> getGroups(long pk,
957                    int start, int end);
958    
959            /**
960            * Returns an ordered range of all the groups associated with the user group.
961            *
962            * <p>
963            * 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 UserGroupModelImpl}. 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.
964            * </p>
965            *
966            * @param pk the primary key of the user group
967            * @param start the lower bound of the range of user groups
968            * @param end the upper bound of the range of user groups (not inclusive)
969            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
970            * @return the ordered range of groups associated with the user group
971            */
972            public java.util.List<com.liferay.portal.model.Group> getGroups(long pk,
973                    int start, int end,
974                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator);
975    
976            /**
977            * Returns the number of groups associated with the user group.
978            *
979            * @param pk the primary key of the user group
980            * @return the number of groups associated with the user group
981            */
982            public int getGroupsSize(long pk);
983    
984            /**
985            * Returns <code>true</code> if the group is associated with the user group.
986            *
987            * @param pk the primary key of the user group
988            * @param groupPK the primary key of the group
989            * @return <code>true</code> if the group is associated with the user group; <code>false</code> otherwise
990            */
991            public boolean containsGroup(long pk, long groupPK);
992    
993            /**
994            * Returns <code>true</code> if the user group has any groups associated with it.
995            *
996            * @param pk the primary key of the user group to check for associations with groups
997            * @return <code>true</code> if the user group has any groups associated with it; <code>false</code> otherwise
998            */
999            public boolean containsGroups(long pk);
1000    
1001            /**
1002            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1003            *
1004            * @param pk the primary key of the user group
1005            * @param groupPK the primary key of the group
1006            */
1007            public void addGroup(long pk, long groupPK);
1008    
1009            /**
1010            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1011            *
1012            * @param pk the primary key of the user group
1013            * @param group the group
1014            */
1015            public void addGroup(long pk, com.liferay.portal.model.Group group);
1016    
1017            /**
1018            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1019            *
1020            * @param pk the primary key of the user group
1021            * @param groupPKs the primary keys of the groups
1022            */
1023            public void addGroups(long pk, long[] groupPKs);
1024    
1025            /**
1026            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1027            *
1028            * @param pk the primary key of the user group
1029            * @param groups the groups
1030            */
1031            public void addGroups(long pk,
1032                    java.util.List<com.liferay.portal.model.Group> groups);
1033    
1034            /**
1035            * Clears all associations between the user group and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1036            *
1037            * @param pk the primary key of the user group to clear the associated groups from
1038            */
1039            public void clearGroups(long pk);
1040    
1041            /**
1042            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1043            *
1044            * @param pk the primary key of the user group
1045            * @param groupPK the primary key of the group
1046            */
1047            public void removeGroup(long pk, long groupPK);
1048    
1049            /**
1050            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1051            *
1052            * @param pk the primary key of the user group
1053            * @param group the group
1054            */
1055            public void removeGroup(long pk, com.liferay.portal.model.Group group);
1056    
1057            /**
1058            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1059            *
1060            * @param pk the primary key of the user group
1061            * @param groupPKs the primary keys of the groups
1062            */
1063            public void removeGroups(long pk, long[] groupPKs);
1064    
1065            /**
1066            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1067            *
1068            * @param pk the primary key of the user group
1069            * @param groups the groups
1070            */
1071            public void removeGroups(long pk,
1072                    java.util.List<com.liferay.portal.model.Group> groups);
1073    
1074            /**
1075            * Sets the groups associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1076            *
1077            * @param pk the primary key of the user group
1078            * @param groupPKs the primary keys of the groups to be associated with the user group
1079            */
1080            public void setGroups(long pk, long[] groupPKs);
1081    
1082            /**
1083            * Sets the groups associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1084            *
1085            * @param pk the primary key of the user group
1086            * @param groups the groups to be associated with the user group
1087            */
1088            public void setGroups(long pk,
1089                    java.util.List<com.liferay.portal.model.Group> groups);
1090    
1091            /**
1092            * Returns the primaryKeys of teams associated with the user group.
1093            *
1094            * @param pk the primary key of the user group
1095            * @return long[] of the primaryKeys of teams associated with the user group
1096            */
1097            public long[] getTeamPrimaryKeys(long pk);
1098    
1099            /**
1100            * Returns all the teams associated with the user group.
1101            *
1102            * @param pk the primary key of the user group
1103            * @return the teams associated with the user group
1104            */
1105            public java.util.List<com.liferay.portal.model.Team> getTeams(long pk);
1106    
1107            /**
1108            * Returns a range of all the teams associated with the user group.
1109            *
1110            * <p>
1111            * 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 UserGroupModelImpl}. 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.
1112            * </p>
1113            *
1114            * @param pk the primary key of the user group
1115            * @param start the lower bound of the range of user groups
1116            * @param end the upper bound of the range of user groups (not inclusive)
1117            * @return the range of teams associated with the user group
1118            */
1119            public java.util.List<com.liferay.portal.model.Team> getTeams(long pk,
1120                    int start, int end);
1121    
1122            /**
1123            * Returns an ordered range of all the teams associated with the user group.
1124            *
1125            * <p>
1126            * 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 UserGroupModelImpl}. 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.
1127            * </p>
1128            *
1129            * @param pk the primary key of the user group
1130            * @param start the lower bound of the range of user groups
1131            * @param end the upper bound of the range of user groups (not inclusive)
1132            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1133            * @return the ordered range of teams associated with the user group
1134            */
1135            public java.util.List<com.liferay.portal.model.Team> getTeams(long pk,
1136                    int start, int end,
1137                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Team> orderByComparator);
1138    
1139            /**
1140            * Returns the number of teams associated with the user group.
1141            *
1142            * @param pk the primary key of the user group
1143            * @return the number of teams associated with the user group
1144            */
1145            public int getTeamsSize(long pk);
1146    
1147            /**
1148            * Returns <code>true</code> if the team is associated with the user group.
1149            *
1150            * @param pk the primary key of the user group
1151            * @param teamPK the primary key of the team
1152            * @return <code>true</code> if the team is associated with the user group; <code>false</code> otherwise
1153            */
1154            public boolean containsTeam(long pk, long teamPK);
1155    
1156            /**
1157            * Returns <code>true</code> if the user group has any teams associated with it.
1158            *
1159            * @param pk the primary key of the user group to check for associations with teams
1160            * @return <code>true</code> if the user group has any teams associated with it; <code>false</code> otherwise
1161            */
1162            public boolean containsTeams(long pk);
1163    
1164            /**
1165            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1166            *
1167            * @param pk the primary key of the user group
1168            * @param teamPK the primary key of the team
1169            */
1170            public void addTeam(long pk, long teamPK);
1171    
1172            /**
1173            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1174            *
1175            * @param pk the primary key of the user group
1176            * @param team the team
1177            */
1178            public void addTeam(long pk, com.liferay.portal.model.Team team);
1179    
1180            /**
1181            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1182            *
1183            * @param pk the primary key of the user group
1184            * @param teamPKs the primary keys of the teams
1185            */
1186            public void addTeams(long pk, long[] teamPKs);
1187    
1188            /**
1189            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1190            *
1191            * @param pk the primary key of the user group
1192            * @param teams the teams
1193            */
1194            public void addTeams(long pk,
1195                    java.util.List<com.liferay.portal.model.Team> teams);
1196    
1197            /**
1198            * Clears all associations between the user group and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1199            *
1200            * @param pk the primary key of the user group to clear the associated teams from
1201            */
1202            public void clearTeams(long pk);
1203    
1204            /**
1205            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1206            *
1207            * @param pk the primary key of the user group
1208            * @param teamPK the primary key of the team
1209            */
1210            public void removeTeam(long pk, long teamPK);
1211    
1212            /**
1213            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1214            *
1215            * @param pk the primary key of the user group
1216            * @param team the team
1217            */
1218            public void removeTeam(long pk, com.liferay.portal.model.Team team);
1219    
1220            /**
1221            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1222            *
1223            * @param pk the primary key of the user group
1224            * @param teamPKs the primary keys of the teams
1225            */
1226            public void removeTeams(long pk, long[] teamPKs);
1227    
1228            /**
1229            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1230            *
1231            * @param pk the primary key of the user group
1232            * @param teams the teams
1233            */
1234            public void removeTeams(long pk,
1235                    java.util.List<com.liferay.portal.model.Team> teams);
1236    
1237            /**
1238            * Sets the teams associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1239            *
1240            * @param pk the primary key of the user group
1241            * @param teamPKs the primary keys of the teams to be associated with the user group
1242            */
1243            public void setTeams(long pk, long[] teamPKs);
1244    
1245            /**
1246            * Sets the teams associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1247            *
1248            * @param pk the primary key of the user group
1249            * @param teams the teams to be associated with the user group
1250            */
1251            public void setTeams(long pk,
1252                    java.util.List<com.liferay.portal.model.Team> teams);
1253    
1254            /**
1255            * Returns the primaryKeys of users associated with the user group.
1256            *
1257            * @param pk the primary key of the user group
1258            * @return long[] of the primaryKeys of users associated with the user group
1259            */
1260            public long[] getUserPrimaryKeys(long pk);
1261    
1262            /**
1263            * Returns all the users associated with the user group.
1264            *
1265            * @param pk the primary key of the user group
1266            * @return the users associated with the user group
1267            */
1268            public java.util.List<com.liferay.portal.model.User> getUsers(long pk);
1269    
1270            /**
1271            * Returns a range of all the users associated with the user group.
1272            *
1273            * <p>
1274            * 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 UserGroupModelImpl}. 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.
1275            * </p>
1276            *
1277            * @param pk the primary key of the user group
1278            * @param start the lower bound of the range of user groups
1279            * @param end the upper bound of the range of user groups (not inclusive)
1280            * @return the range of users associated with the user group
1281            */
1282            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
1283                    int start, int end);
1284    
1285            /**
1286            * Returns an ordered range of all the users associated with the user group.
1287            *
1288            * <p>
1289            * 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 UserGroupModelImpl}. 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.
1290            * </p>
1291            *
1292            * @param pk the primary key of the user group
1293            * @param start the lower bound of the range of user groups
1294            * @param end the upper bound of the range of user groups (not inclusive)
1295            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1296            * @return the ordered range of users associated with the user group
1297            */
1298            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
1299                    int start, int end,
1300                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator);
1301    
1302            /**
1303            * Returns the number of users associated with the user group.
1304            *
1305            * @param pk the primary key of the user group
1306            * @return the number of users associated with the user group
1307            */
1308            public int getUsersSize(long pk);
1309    
1310            /**
1311            * Returns <code>true</code> if the user is associated with the user group.
1312            *
1313            * @param pk the primary key of the user group
1314            * @param userPK the primary key of the user
1315            * @return <code>true</code> if the user is associated with the user group; <code>false</code> otherwise
1316            */
1317            public boolean containsUser(long pk, long userPK);
1318    
1319            /**
1320            * Returns <code>true</code> if the user group has any users associated with it.
1321            *
1322            * @param pk the primary key of the user group to check for associations with users
1323            * @return <code>true</code> if the user group has any users associated with it; <code>false</code> otherwise
1324            */
1325            public boolean containsUsers(long pk);
1326    
1327            /**
1328            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1329            *
1330            * @param pk the primary key of the user group
1331            * @param userPK the primary key of the user
1332            */
1333            public void addUser(long pk, long userPK);
1334    
1335            /**
1336            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1337            *
1338            * @param pk the primary key of the user group
1339            * @param user the user
1340            */
1341            public void addUser(long pk, com.liferay.portal.model.User user);
1342    
1343            /**
1344            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1345            *
1346            * @param pk the primary key of the user group
1347            * @param userPKs the primary keys of the users
1348            */
1349            public void addUsers(long pk, long[] userPKs);
1350    
1351            /**
1352            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1353            *
1354            * @param pk the primary key of the user group
1355            * @param users the users
1356            */
1357            public void addUsers(long pk,
1358                    java.util.List<com.liferay.portal.model.User> users);
1359    
1360            /**
1361            * Clears all associations between the user group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1362            *
1363            * @param pk the primary key of the user group to clear the associated users from
1364            */
1365            public void clearUsers(long pk);
1366    
1367            /**
1368            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1369            *
1370            * @param pk the primary key of the user group
1371            * @param userPK the primary key of the user
1372            */
1373            public void removeUser(long pk, long userPK);
1374    
1375            /**
1376            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1377            *
1378            * @param pk the primary key of the user group
1379            * @param user the user
1380            */
1381            public void removeUser(long pk, com.liferay.portal.model.User user);
1382    
1383            /**
1384            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1385            *
1386            * @param pk the primary key of the user group
1387            * @param userPKs the primary keys of the users
1388            */
1389            public void removeUsers(long pk, long[] userPKs);
1390    
1391            /**
1392            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1393            *
1394            * @param pk the primary key of the user group
1395            * @param users the users
1396            */
1397            public void removeUsers(long pk,
1398                    java.util.List<com.liferay.portal.model.User> users);
1399    
1400            /**
1401            * Sets the users associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1402            *
1403            * @param pk the primary key of the user group
1404            * @param userPKs the primary keys of the users to be associated with the user group
1405            */
1406            public void setUsers(long pk, long[] userPKs);
1407    
1408            /**
1409            * Sets the users associated with the user group, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1410            *
1411            * @param pk the primary key of the user group
1412            * @param users the users to be associated with the user group
1413            */
1414            public void setUsers(long pk,
1415                    java.util.List<com.liferay.portal.model.User> users);
1416    }