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