001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.exception.NoSuchUserGroupException;
020    import com.liferay.portal.kernel.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.kernel.model.Group> getGroups(
1038                    long pk);
1039    
1040            /**
1041            * Returns a range of all the groups associated with the user group.
1042            *
1043            * <p>
1044            * 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.
1045            * </p>
1046            *
1047            * @param pk the primary key of the user group
1048            * @param start the lower bound of the range of user groups
1049            * @param end the upper bound of the range of user groups (not inclusive)
1050            * @return the range of groups associated with the user group
1051            */
1052            public java.util.List<com.liferay.portal.kernel.model.Group> getGroups(
1053                    long pk, int start, int end);
1054    
1055            /**
1056            * Returns an ordered range of all the groups associated with the user group.
1057            *
1058            * <p>
1059            * 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.
1060            * </p>
1061            *
1062            * @param pk the primary key of the user group
1063            * @param start the lower bound of the range of user groups
1064            * @param end the upper bound of the range of user groups (not inclusive)
1065            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1066            * @return the ordered range of groups associated with the user group
1067            */
1068            public java.util.List<com.liferay.portal.kernel.model.Group> getGroups(
1069                    long pk, int start, int end,
1070                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.Group> orderByComparator);
1071    
1072            /**
1073            * Returns the number of groups associated with the user group.
1074            *
1075            * @param pk the primary key of the user group
1076            * @return the number of groups associated with the user group
1077            */
1078            public int getGroupsSize(long pk);
1079    
1080            /**
1081            * Returns <code>true</code> if the group is associated with the user group.
1082            *
1083            * @param pk the primary key of the user group
1084            * @param groupPK the primary key of the group
1085            * @return <code>true</code> if the group is associated with the user group; <code>false</code> otherwise
1086            */
1087            public boolean containsGroup(long pk, long groupPK);
1088    
1089            /**
1090            * Returns <code>true</code> if the user group has any groups associated with it.
1091            *
1092            * @param pk the primary key of the user group to check for associations with groups
1093            * @return <code>true</code> if the user group has any groups associated with it; <code>false</code> otherwise
1094            */
1095            public boolean containsGroups(long pk);
1096    
1097            /**
1098            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1099            *
1100            * @param pk the primary key of the user group
1101            * @param groupPK the primary key of the group
1102            */
1103            public void addGroup(long pk, long groupPK);
1104    
1105            /**
1106            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1107            *
1108            * @param pk the primary key of the user group
1109            * @param group the group
1110            */
1111            public void addGroup(long pk, com.liferay.portal.kernel.model.Group group);
1112    
1113            /**
1114            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1115            *
1116            * @param pk the primary key of the user group
1117            * @param groupPKs the primary keys of the groups
1118            */
1119            public void addGroups(long pk, long[] groupPKs);
1120    
1121            /**
1122            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1123            *
1124            * @param pk the primary key of the user group
1125            * @param groups the groups
1126            */
1127            public void addGroups(long pk,
1128                    java.util.List<com.liferay.portal.kernel.model.Group> groups);
1129    
1130            /**
1131            * Clears all associations between the user group and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1132            *
1133            * @param pk the primary key of the user group to clear the associated groups from
1134            */
1135            public void clearGroups(long pk);
1136    
1137            /**
1138            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1139            *
1140            * @param pk the primary key of the user group
1141            * @param groupPK the primary key of the group
1142            */
1143            public void removeGroup(long pk, long groupPK);
1144    
1145            /**
1146            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1147            *
1148            * @param pk the primary key of the user group
1149            * @param group the group
1150            */
1151            public void removeGroup(long pk, com.liferay.portal.kernel.model.Group group);
1152    
1153            /**
1154            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1155            *
1156            * @param pk the primary key of the user group
1157            * @param groupPKs the primary keys of the groups
1158            */
1159            public void removeGroups(long pk, long[] groupPKs);
1160    
1161            /**
1162            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1163            *
1164            * @param pk the primary key of the user group
1165            * @param groups the groups
1166            */
1167            public void removeGroups(long pk,
1168                    java.util.List<com.liferay.portal.kernel.model.Group> groups);
1169    
1170            /**
1171            * 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.
1172            *
1173            * @param pk the primary key of the user group
1174            * @param groupPKs the primary keys of the groups to be associated with the user group
1175            */
1176            public void setGroups(long pk, long[] groupPKs);
1177    
1178            /**
1179            * 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.
1180            *
1181            * @param pk the primary key of the user group
1182            * @param groups the groups to be associated with the user group
1183            */
1184            public void setGroups(long pk,
1185                    java.util.List<com.liferay.portal.kernel.model.Group> groups);
1186    
1187            /**
1188            * Returns the primaryKeys of teams associated with the user group.
1189            *
1190            * @param pk the primary key of the user group
1191            * @return long[] of the primaryKeys of teams associated with the user group
1192            */
1193            public long[] getTeamPrimaryKeys(long pk);
1194    
1195            /**
1196            * Returns all the teams associated with the user group.
1197            *
1198            * @param pk the primary key of the user group
1199            * @return the teams associated with the user group
1200            */
1201            public java.util.List<com.liferay.portal.kernel.model.Team> getTeams(
1202                    long pk);
1203    
1204            /**
1205            * Returns a range of all the teams associated with the user group.
1206            *
1207            * <p>
1208            * 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.
1209            * </p>
1210            *
1211            * @param pk the primary key of the user group
1212            * @param start the lower bound of the range of user groups
1213            * @param end the upper bound of the range of user groups (not inclusive)
1214            * @return the range of teams associated with the user group
1215            */
1216            public java.util.List<com.liferay.portal.kernel.model.Team> getTeams(
1217                    long pk, int start, int end);
1218    
1219            /**
1220            * Returns an ordered range of all the teams associated with the user group.
1221            *
1222            * <p>
1223            * 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.
1224            * </p>
1225            *
1226            * @param pk the primary key of the user group
1227            * @param start the lower bound of the range of user groups
1228            * @param end the upper bound of the range of user groups (not inclusive)
1229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1230            * @return the ordered range of teams associated with the user group
1231            */
1232            public java.util.List<com.liferay.portal.kernel.model.Team> getTeams(
1233                    long pk, int start, int end,
1234                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.Team> orderByComparator);
1235    
1236            /**
1237            * Returns the number of teams associated with the user group.
1238            *
1239            * @param pk the primary key of the user group
1240            * @return the number of teams associated with the user group
1241            */
1242            public int getTeamsSize(long pk);
1243    
1244            /**
1245            * Returns <code>true</code> if the team is associated with the user group.
1246            *
1247            * @param pk the primary key of the user group
1248            * @param teamPK the primary key of the team
1249            * @return <code>true</code> if the team is associated with the user group; <code>false</code> otherwise
1250            */
1251            public boolean containsTeam(long pk, long teamPK);
1252    
1253            /**
1254            * Returns <code>true</code> if the user group has any teams associated with it.
1255            *
1256            * @param pk the primary key of the user group to check for associations with teams
1257            * @return <code>true</code> if the user group has any teams associated with it; <code>false</code> otherwise
1258            */
1259            public boolean containsTeams(long pk);
1260    
1261            /**
1262            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1263            *
1264            * @param pk the primary key of the user group
1265            * @param teamPK the primary key of the team
1266            */
1267            public void addTeam(long pk, long teamPK);
1268    
1269            /**
1270            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1271            *
1272            * @param pk the primary key of the user group
1273            * @param team the team
1274            */
1275            public void addTeam(long pk, com.liferay.portal.kernel.model.Team team);
1276    
1277            /**
1278            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1279            *
1280            * @param pk the primary key of the user group
1281            * @param teamPKs the primary keys of the teams
1282            */
1283            public void addTeams(long pk, long[] teamPKs);
1284    
1285            /**
1286            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1287            *
1288            * @param pk the primary key of the user group
1289            * @param teams the teams
1290            */
1291            public void addTeams(long pk,
1292                    java.util.List<com.liferay.portal.kernel.model.Team> teams);
1293    
1294            /**
1295            * Clears all associations between the user group and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1296            *
1297            * @param pk the primary key of the user group to clear the associated teams from
1298            */
1299            public void clearTeams(long pk);
1300    
1301            /**
1302            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1303            *
1304            * @param pk the primary key of the user group
1305            * @param teamPK the primary key of the team
1306            */
1307            public void removeTeam(long pk, long teamPK);
1308    
1309            /**
1310            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1311            *
1312            * @param pk the primary key of the user group
1313            * @param team the team
1314            */
1315            public void removeTeam(long pk, com.liferay.portal.kernel.model.Team team);
1316    
1317            /**
1318            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1319            *
1320            * @param pk the primary key of the user group
1321            * @param teamPKs the primary keys of the teams
1322            */
1323            public void removeTeams(long pk, long[] teamPKs);
1324    
1325            /**
1326            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1327            *
1328            * @param pk the primary key of the user group
1329            * @param teams the teams
1330            */
1331            public void removeTeams(long pk,
1332                    java.util.List<com.liferay.portal.kernel.model.Team> teams);
1333    
1334            /**
1335            * 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.
1336            *
1337            * @param pk the primary key of the user group
1338            * @param teamPKs the primary keys of the teams to be associated with the user group
1339            */
1340            public void setTeams(long pk, long[] teamPKs);
1341    
1342            /**
1343            * 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.
1344            *
1345            * @param pk the primary key of the user group
1346            * @param teams the teams to be associated with the user group
1347            */
1348            public void setTeams(long pk,
1349                    java.util.List<com.liferay.portal.kernel.model.Team> teams);
1350    
1351            /**
1352            * Returns the primaryKeys of users associated with the user group.
1353            *
1354            * @param pk the primary key of the user group
1355            * @return long[] of the primaryKeys of users associated with the user group
1356            */
1357            public long[] getUserPrimaryKeys(long pk);
1358    
1359            /**
1360            * Returns all the users associated with the user group.
1361            *
1362            * @param pk the primary key of the user group
1363            * @return the users associated with the user group
1364            */
1365            public java.util.List<com.liferay.portal.kernel.model.User> getUsers(
1366                    long pk);
1367    
1368            /**
1369            * Returns a range of all the users associated with the user group.
1370            *
1371            * <p>
1372            * 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.
1373            * </p>
1374            *
1375            * @param pk the primary key of the user group
1376            * @param start the lower bound of the range of user groups
1377            * @param end the upper bound of the range of user groups (not inclusive)
1378            * @return the range of users associated with the user group
1379            */
1380            public java.util.List<com.liferay.portal.kernel.model.User> getUsers(
1381                    long pk, int start, int end);
1382    
1383            /**
1384            * Returns an ordered range of all the users associated with the user group.
1385            *
1386            * <p>
1387            * 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.
1388            * </p>
1389            *
1390            * @param pk the primary key of the user group
1391            * @param start the lower bound of the range of user groups
1392            * @param end the upper bound of the range of user groups (not inclusive)
1393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1394            * @return the ordered range of users associated with the user group
1395            */
1396            public java.util.List<com.liferay.portal.kernel.model.User> getUsers(
1397                    long pk, int start, int end,
1398                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.User> orderByComparator);
1399    
1400            /**
1401            * Returns the number of users associated with the user group.
1402            *
1403            * @param pk the primary key of the user group
1404            * @return the number of users associated with the user group
1405            */
1406            public int getUsersSize(long pk);
1407    
1408            /**
1409            * Returns <code>true</code> if the user is associated with the user group.
1410            *
1411            * @param pk the primary key of the user group
1412            * @param userPK the primary key of the user
1413            * @return <code>true</code> if the user is associated with the user group; <code>false</code> otherwise
1414            */
1415            public boolean containsUser(long pk, long userPK);
1416    
1417            /**
1418            * Returns <code>true</code> if the user group has any users associated with it.
1419            *
1420            * @param pk the primary key of the user group to check for associations with users
1421            * @return <code>true</code> if the user group has any users associated with it; <code>false</code> otherwise
1422            */
1423            public boolean containsUsers(long pk);
1424    
1425            /**
1426            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1427            *
1428            * @param pk the primary key of the user group
1429            * @param userPK the primary key of the user
1430            */
1431            public void addUser(long pk, long userPK);
1432    
1433            /**
1434            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1435            *
1436            * @param pk the primary key of the user group
1437            * @param user the user
1438            */
1439            public void addUser(long pk, com.liferay.portal.kernel.model.User user);
1440    
1441            /**
1442            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1443            *
1444            * @param pk the primary key of the user group
1445            * @param userPKs the primary keys of the users
1446            */
1447            public void addUsers(long pk, long[] userPKs);
1448    
1449            /**
1450            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1451            *
1452            * @param pk the primary key of the user group
1453            * @param users the users
1454            */
1455            public void addUsers(long pk,
1456                    java.util.List<com.liferay.portal.kernel.model.User> users);
1457    
1458            /**
1459            * Clears all associations between the user group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1460            *
1461            * @param pk the primary key of the user group to clear the associated users from
1462            */
1463            public void clearUsers(long pk);
1464    
1465            /**
1466            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1467            *
1468            * @param pk the primary key of the user group
1469            * @param userPK the primary key of the user
1470            */
1471            public void removeUser(long pk, long userPK);
1472    
1473            /**
1474            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1475            *
1476            * @param pk the primary key of the user group
1477            * @param user the user
1478            */
1479            public void removeUser(long pk, com.liferay.portal.kernel.model.User user);
1480    
1481            /**
1482            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1483            *
1484            * @param pk the primary key of the user group
1485            * @param userPKs the primary keys of the users
1486            */
1487            public void removeUsers(long pk, long[] userPKs);
1488    
1489            /**
1490            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1491            *
1492            * @param pk the primary key of the user group
1493            * @param users the users
1494            */
1495            public void removeUsers(long pk,
1496                    java.util.List<com.liferay.portal.kernel.model.User> users);
1497    
1498            /**
1499            * 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.
1500            *
1501            * @param pk the primary key of the user group
1502            * @param userPKs the primary keys of the users to be associated with the user group
1503            */
1504            public void setUsers(long pk, long[] userPKs);
1505    
1506            /**
1507            * 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.
1508            *
1509            * @param pk the primary key of the user group
1510            * @param users the users to be associated with the user group
1511            */
1512            public void setUsers(long pk,
1513                    java.util.List<com.liferay.portal.kernel.model.User> users);
1514    
1515            @Override
1516            public java.util.Set<java.lang.String> getBadColumnNames();
1517    }