001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.model.UserGroup;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the user group service. This utility wraps {@link UserGroupPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
029     *
030     * <p>
031     * Caching information and settings can be found in <code>portal.properties</code>
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see UserGroupPersistence
036     * @see UserGroupPersistenceImpl
037     * @generated
038     */
039    public class UserGroupUtil {
040            /*
041             * NOTE FOR DEVELOPERS:
042             *
043             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
044             */
045    
046            /**
047             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
048             */
049            public static void clearCache() {
050                    getPersistence().clearCache();
051            }
052    
053            /**
054             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
055             */
056            public static void clearCache(UserGroup userGroup) {
057                    getPersistence().clearCache(userGroup);
058            }
059    
060            /**
061             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
062             */
063            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
064                    throws SystemException {
065                    return getPersistence().countWithDynamicQuery(dynamicQuery);
066            }
067    
068            /**
069             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
070             */
071            public static List<UserGroup> findWithDynamicQuery(
072                    DynamicQuery dynamicQuery) throws SystemException {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<UserGroup> findWithDynamicQuery(
080                    DynamicQuery dynamicQuery, int start, int end)
081                    throws SystemException {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<UserGroup> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator orderByComparator) throws SystemException {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static UserGroup update(UserGroup userGroup)
100                    throws SystemException {
101                    return getPersistence().update(userGroup);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static UserGroup update(UserGroup userGroup,
108                    ServiceContext serviceContext) throws SystemException {
109                    return getPersistence().update(userGroup, serviceContext);
110            }
111    
112            /**
113            * Returns all the user groups where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching user groups
117            * @throws SystemException if a system exception occurred
118            */
119            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid(
120                    java.lang.String uuid)
121                    throws com.liferay.portal.kernel.exception.SystemException {
122                    return getPersistence().findByUuid(uuid);
123            }
124    
125            /**
126            * Returns a range of all the user groups where uuid = &#63;.
127            *
128            * <p>
129            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
130            * </p>
131            *
132            * @param uuid the uuid
133            * @param start the lower bound of the range of user groups
134            * @param end the upper bound of the range of user groups (not inclusive)
135            * @return the range of matching user groups
136            * @throws SystemException if a system exception occurred
137            */
138            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid(
139                    java.lang.String uuid, int start, int end)
140                    throws com.liferay.portal.kernel.exception.SystemException {
141                    return getPersistence().findByUuid(uuid, start, end);
142            }
143    
144            /**
145            * Returns an ordered range of all the user groups where uuid = &#63;.
146            *
147            * <p>
148            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
149            * </p>
150            *
151            * @param uuid the uuid
152            * @param start the lower bound of the range of user groups
153            * @param end the upper bound of the range of user groups (not inclusive)
154            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
155            * @return the ordered range of matching user groups
156            * @throws SystemException if a system exception occurred
157            */
158            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid(
159                    java.lang.String uuid, int start, int end,
160                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
161                    throws com.liferay.portal.kernel.exception.SystemException {
162                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
163            }
164    
165            /**
166            * Returns the first user group in the ordered set where uuid = &#63;.
167            *
168            * @param uuid the uuid
169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
170            * @return the first matching user group
171            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portal.model.UserGroup findByUuid_First(
175                    java.lang.String uuid,
176                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
177                    throws com.liferay.portal.NoSuchUserGroupException,
178                            com.liferay.portal.kernel.exception.SystemException {
179                    return getPersistence().findByUuid_First(uuid, orderByComparator);
180            }
181    
182            /**
183            * Returns the first user group in the ordered set where uuid = &#63;.
184            *
185            * @param uuid the uuid
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
188            * @throws SystemException if a system exception occurred
189            */
190            public static com.liferay.portal.model.UserGroup fetchByUuid_First(
191                    java.lang.String uuid,
192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
193                    throws com.liferay.portal.kernel.exception.SystemException {
194                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last user group in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching user group
203            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
204            * @throws SystemException if a system exception occurred
205            */
206            public static com.liferay.portal.model.UserGroup findByUuid_Last(
207                    java.lang.String uuid,
208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
209                    throws com.liferay.portal.NoSuchUserGroupException,
210                            com.liferay.portal.kernel.exception.SystemException {
211                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
212            }
213    
214            /**
215            * Returns the last user group in the ordered set where uuid = &#63;.
216            *
217            * @param uuid the uuid
218            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
219            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
220            * @throws SystemException if a system exception occurred
221            */
222            public static com.liferay.portal.model.UserGroup fetchByUuid_Last(
223                    java.lang.String uuid,
224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
225                    throws com.liferay.portal.kernel.exception.SystemException {
226                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
227            }
228    
229            /**
230            * Returns the user groups before and after the current user group in the ordered set where uuid = &#63;.
231            *
232            * @param userGroupId the primary key of the current user group
233            * @param uuid the uuid
234            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
235            * @return the previous, current, and next user group
236            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
237            * @throws SystemException if a system exception occurred
238            */
239            public static com.liferay.portal.model.UserGroup[] findByUuid_PrevAndNext(
240                    long userGroupId, java.lang.String uuid,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.NoSuchUserGroupException,
243                            com.liferay.portal.kernel.exception.SystemException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(userGroupId, uuid, orderByComparator);
246            }
247    
248            /**
249            * Returns all the user groups that the user has permission to view where uuid = &#63;.
250            *
251            * @param uuid the uuid
252            * @return the matching user groups that the user has permission to view
253            * @throws SystemException if a system exception occurred
254            */
255            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid(
256                    java.lang.String uuid)
257                    throws com.liferay.portal.kernel.exception.SystemException {
258                    return getPersistence().filterFindByUuid(uuid);
259            }
260    
261            /**
262            * Returns a range of all the user groups that the user has permission to view where uuid = &#63;.
263            *
264            * <p>
265            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
266            * </p>
267            *
268            * @param uuid the uuid
269            * @param start the lower bound of the range of user groups
270            * @param end the upper bound of the range of user groups (not inclusive)
271            * @return the range of matching user groups that the user has permission to view
272            * @throws SystemException if a system exception occurred
273            */
274            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid(
275                    java.lang.String uuid, int start, int end)
276                    throws com.liferay.portal.kernel.exception.SystemException {
277                    return getPersistence().filterFindByUuid(uuid, start, end);
278            }
279    
280            /**
281            * Returns an ordered range of all the user groups that the user has permissions to view where uuid = &#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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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 start the lower bound of the range of user groups
289            * @param end the upper bound of the range of user groups (not inclusive)
290            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
291            * @return the ordered range of matching user groups that the user has permission to view
292            * @throws SystemException if a system exception occurred
293            */
294            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid(
295                    java.lang.String uuid, int start, int end,
296                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
297                    throws com.liferay.portal.kernel.exception.SystemException {
298                    return getPersistence()
299                                       .filterFindByUuid(uuid, start, end, orderByComparator);
300            }
301    
302            /**
303            * 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;.
304            *
305            * @param userGroupId the primary key of the current user group
306            * @param uuid the uuid
307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
308            * @return the previous, current, and next user group
309            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
310            * @throws SystemException if a system exception occurred
311            */
312            public static com.liferay.portal.model.UserGroup[] filterFindByUuid_PrevAndNext(
313                    long userGroupId, java.lang.String uuid,
314                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
315                    throws com.liferay.portal.NoSuchUserGroupException,
316                            com.liferay.portal.kernel.exception.SystemException {
317                    return getPersistence()
318                                       .filterFindByUuid_PrevAndNext(userGroupId, uuid,
319                            orderByComparator);
320            }
321    
322            /**
323            * Removes all the user groups where uuid = &#63; from the database.
324            *
325            * @param uuid the uuid
326            * @throws SystemException if a system exception occurred
327            */
328            public static void removeByUuid(java.lang.String uuid)
329                    throws com.liferay.portal.kernel.exception.SystemException {
330                    getPersistence().removeByUuid(uuid);
331            }
332    
333            /**
334            * Returns the number of user groups where uuid = &#63;.
335            *
336            * @param uuid the uuid
337            * @return the number of matching user groups
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUuid(java.lang.String uuid)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUuid(uuid);
343            }
344    
345            /**
346            * Returns the number of user groups that the user has permission to view where uuid = &#63;.
347            *
348            * @param uuid the uuid
349            * @return the number of matching user groups that the user has permission to view
350            * @throws SystemException if a system exception occurred
351            */
352            public static int filterCountByUuid(java.lang.String uuid)
353                    throws com.liferay.portal.kernel.exception.SystemException {
354                    return getPersistence().filterCountByUuid(uuid);
355            }
356    
357            /**
358            * Returns all the user groups where uuid = &#63; and companyId = &#63;.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @return the matching user groups
363            * @throws SystemException if a system exception occurred
364            */
365            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C(
366                    java.lang.String uuid, long companyId)
367                    throws com.liferay.portal.kernel.exception.SystemException {
368                    return getPersistence().findByUuid_C(uuid, companyId);
369            }
370    
371            /**
372            * Returns a range of all the user groups where uuid = &#63; and companyId = &#63;.
373            *
374            * <p>
375            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
376            * </p>
377            *
378            * @param uuid the uuid
379            * @param companyId the company ID
380            * @param start the lower bound of the range of user groups
381            * @param end the upper bound of the range of user groups (not inclusive)
382            * @return the range of matching user groups
383            * @throws SystemException if a system exception occurred
384            */
385            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C(
386                    java.lang.String uuid, long companyId, int start, int end)
387                    throws com.liferay.portal.kernel.exception.SystemException {
388                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
389            }
390    
391            /**
392            * Returns an ordered range of all the user groups where uuid = &#63; and companyId = &#63;.
393            *
394            * <p>
395            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
396            * </p>
397            *
398            * @param uuid the uuid
399            * @param companyId the company ID
400            * @param start the lower bound of the range of user groups
401            * @param end the upper bound of the range of user groups (not inclusive)
402            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
403            * @return the ordered range of matching user groups
404            * @throws SystemException if a system exception occurred
405            */
406            public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C(
407                    java.lang.String uuid, long companyId, int start, int end,
408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
409                    throws com.liferay.portal.kernel.exception.SystemException {
410                    return getPersistence()
411                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
412            }
413    
414            /**
415            * Returns the first user group in the ordered set where uuid = &#63; and companyId = &#63;.
416            *
417            * @param uuid the uuid
418            * @param companyId the company ID
419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
420            * @return the first matching user group
421            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
422            * @throws SystemException if a system exception occurred
423            */
424            public static com.liferay.portal.model.UserGroup findByUuid_C_First(
425                    java.lang.String uuid, long companyId,
426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
427                    throws com.liferay.portal.NoSuchUserGroupException,
428                            com.liferay.portal.kernel.exception.SystemException {
429                    return getPersistence()
430                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
431            }
432    
433            /**
434            * Returns the first user group in the ordered set where uuid = &#63; and companyId = &#63;.
435            *
436            * @param uuid the uuid
437            * @param companyId the company ID
438            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
439            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
440            * @throws SystemException if a system exception occurred
441            */
442            public static com.liferay.portal.model.UserGroup fetchByUuid_C_First(
443                    java.lang.String uuid, long companyId,
444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
445                    throws com.liferay.portal.kernel.exception.SystemException {
446                    return getPersistence()
447                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
448            }
449    
450            /**
451            * Returns the last user group in the ordered set where uuid = &#63; and companyId = &#63;.
452            *
453            * @param uuid the uuid
454            * @param companyId the company ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the last matching user group
457            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
458            * @throws SystemException if a system exception occurred
459            */
460            public static com.liferay.portal.model.UserGroup findByUuid_C_Last(
461                    java.lang.String uuid, long companyId,
462                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
463                    throws com.liferay.portal.NoSuchUserGroupException,
464                            com.liferay.portal.kernel.exception.SystemException {
465                    return getPersistence()
466                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
467            }
468    
469            /**
470            * Returns the last user group in the ordered set where uuid = &#63; and companyId = &#63;.
471            *
472            * @param uuid the uuid
473            * @param companyId the company ID
474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
475            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
476            * @throws SystemException if a system exception occurred
477            */
478            public static com.liferay.portal.model.UserGroup fetchByUuid_C_Last(
479                    java.lang.String uuid, long companyId,
480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
481                    throws com.liferay.portal.kernel.exception.SystemException {
482                    return getPersistence()
483                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
484            }
485    
486            /**
487            * Returns the user groups before and after the current user group in the ordered set where uuid = &#63; and companyId = &#63;.
488            *
489            * @param userGroupId the primary key of the current user group
490            * @param uuid the uuid
491            * @param companyId the company ID
492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
493            * @return the previous, current, and next user group
494            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
495            * @throws SystemException if a system exception occurred
496            */
497            public static com.liferay.portal.model.UserGroup[] findByUuid_C_PrevAndNext(
498                    long userGroupId, java.lang.String uuid, long companyId,
499                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
500                    throws com.liferay.portal.NoSuchUserGroupException,
501                            com.liferay.portal.kernel.exception.SystemException {
502                    return getPersistence()
503                                       .findByUuid_C_PrevAndNext(userGroupId, uuid, companyId,
504                            orderByComparator);
505            }
506    
507            /**
508            * Returns all the user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the matching user groups that the user has permission to view
513            * @throws SystemException if a system exception occurred
514            */
515            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C(
516                    java.lang.String uuid, long companyId)
517                    throws com.liferay.portal.kernel.exception.SystemException {
518                    return getPersistence().filterFindByUuid_C(uuid, companyId);
519            }
520    
521            /**
522            * Returns a range of all the user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
523            *
524            * <p>
525            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
526            * </p>
527            *
528            * @param uuid the uuid
529            * @param companyId the company ID
530            * @param start the lower bound of the range of user groups
531            * @param end the upper bound of the range of user groups (not inclusive)
532            * @return the range of matching user groups that the user has permission to view
533            * @throws SystemException if a system exception occurred
534            */
535            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C(
536                    java.lang.String uuid, long companyId, int start, int end)
537                    throws com.liferay.portal.kernel.exception.SystemException {
538                    return getPersistence().filterFindByUuid_C(uuid, companyId, start, end);
539            }
540    
541            /**
542            * Returns an ordered range of all the user groups that the user has permissions to view where uuid = &#63; and companyId = &#63;.
543            *
544            * <p>
545            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
546            * </p>
547            *
548            * @param uuid the uuid
549            * @param companyId the company ID
550            * @param start the lower bound of the range of user groups
551            * @param end the upper bound of the range of user groups (not inclusive)
552            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
553            * @return the ordered range of matching user groups that the user has permission to view
554            * @throws SystemException if a system exception occurred
555            */
556            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C(
557                    java.lang.String uuid, long companyId, int start, int end,
558                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
559                    throws com.liferay.portal.kernel.exception.SystemException {
560                    return getPersistence()
561                                       .filterFindByUuid_C(uuid, companyId, start, end,
562                            orderByComparator);
563            }
564    
565            /**
566            * 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;.
567            *
568            * @param userGroupId the primary key of the current user group
569            * @param uuid the uuid
570            * @param companyId the company ID
571            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
572            * @return the previous, current, and next user group
573            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
574            * @throws SystemException if a system exception occurred
575            */
576            public static com.liferay.portal.model.UserGroup[] filterFindByUuid_C_PrevAndNext(
577                    long userGroupId, java.lang.String uuid, long companyId,
578                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
579                    throws com.liferay.portal.NoSuchUserGroupException,
580                            com.liferay.portal.kernel.exception.SystemException {
581                    return getPersistence()
582                                       .filterFindByUuid_C_PrevAndNext(userGroupId, uuid,
583                            companyId, orderByComparator);
584            }
585    
586            /**
587            * Removes all the user groups where uuid = &#63; and companyId = &#63; from the database.
588            *
589            * @param uuid the uuid
590            * @param companyId the company ID
591            * @throws SystemException if a system exception occurred
592            */
593            public static void removeByUuid_C(java.lang.String uuid, long companyId)
594                    throws com.liferay.portal.kernel.exception.SystemException {
595                    getPersistence().removeByUuid_C(uuid, companyId);
596            }
597    
598            /**
599            * Returns the number of user groups where uuid = &#63; and companyId = &#63;.
600            *
601            * @param uuid the uuid
602            * @param companyId the company ID
603            * @return the number of matching user groups
604            * @throws SystemException if a system exception occurred
605            */
606            public static int countByUuid_C(java.lang.String uuid, long companyId)
607                    throws com.liferay.portal.kernel.exception.SystemException {
608                    return getPersistence().countByUuid_C(uuid, companyId);
609            }
610    
611            /**
612            * Returns the number of user groups that the user has permission to view where uuid = &#63; and companyId = &#63;.
613            *
614            * @param uuid the uuid
615            * @param companyId the company ID
616            * @return the number of matching user groups that the user has permission to view
617            * @throws SystemException if a system exception occurred
618            */
619            public static int filterCountByUuid_C(java.lang.String uuid, long companyId)
620                    throws com.liferay.portal.kernel.exception.SystemException {
621                    return getPersistence().filterCountByUuid_C(uuid, companyId);
622            }
623    
624            /**
625            * Returns all the user groups where companyId = &#63;.
626            *
627            * @param companyId the company ID
628            * @return the matching user groups
629            * @throws SystemException if a system exception occurred
630            */
631            public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId(
632                    long companyId)
633                    throws com.liferay.portal.kernel.exception.SystemException {
634                    return getPersistence().findByCompanyId(companyId);
635            }
636    
637            /**
638            * Returns a range of all the user groups where companyId = &#63;.
639            *
640            * <p>
641            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
642            * </p>
643            *
644            * @param companyId the company ID
645            * @param start the lower bound of the range of user groups
646            * @param end the upper bound of the range of user groups (not inclusive)
647            * @return the range of matching user groups
648            * @throws SystemException if a system exception occurred
649            */
650            public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId(
651                    long companyId, int start, int end)
652                    throws com.liferay.portal.kernel.exception.SystemException {
653                    return getPersistence().findByCompanyId(companyId, start, end);
654            }
655    
656            /**
657            * Returns an ordered range of all the user groups where companyId = &#63;.
658            *
659            * <p>
660            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
661            * </p>
662            *
663            * @param companyId the company ID
664            * @param start the lower bound of the range of user groups
665            * @param end the upper bound of the range of user groups (not inclusive)
666            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
667            * @return the ordered range of matching user groups
668            * @throws SystemException if a system exception occurred
669            */
670            public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId(
671                    long companyId, int start, int end,
672                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
673                    throws com.liferay.portal.kernel.exception.SystemException {
674                    return getPersistence()
675                                       .findByCompanyId(companyId, start, end, orderByComparator);
676            }
677    
678            /**
679            * Returns the first user group in the ordered set where companyId = &#63;.
680            *
681            * @param companyId the company ID
682            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
683            * @return the first matching user group
684            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
685            * @throws SystemException if a system exception occurred
686            */
687            public static com.liferay.portal.model.UserGroup findByCompanyId_First(
688                    long companyId,
689                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
690                    throws com.liferay.portal.NoSuchUserGroupException,
691                            com.liferay.portal.kernel.exception.SystemException {
692                    return getPersistence()
693                                       .findByCompanyId_First(companyId, orderByComparator);
694            }
695    
696            /**
697            * Returns the first user group in the ordered set where companyId = &#63;.
698            *
699            * @param companyId the company ID
700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
701            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
702            * @throws SystemException if a system exception occurred
703            */
704            public static com.liferay.portal.model.UserGroup fetchByCompanyId_First(
705                    long companyId,
706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
707                    throws com.liferay.portal.kernel.exception.SystemException {
708                    return getPersistence()
709                                       .fetchByCompanyId_First(companyId, orderByComparator);
710            }
711    
712            /**
713            * Returns the last user group in the ordered set where companyId = &#63;.
714            *
715            * @param companyId the company ID
716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
717            * @return the last matching user group
718            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
719            * @throws SystemException if a system exception occurred
720            */
721            public static com.liferay.portal.model.UserGroup findByCompanyId_Last(
722                    long companyId,
723                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
724                    throws com.liferay.portal.NoSuchUserGroupException,
725                            com.liferay.portal.kernel.exception.SystemException {
726                    return getPersistence()
727                                       .findByCompanyId_Last(companyId, orderByComparator);
728            }
729    
730            /**
731            * Returns the last user group in the ordered set where companyId = &#63;.
732            *
733            * @param companyId the company ID
734            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
735            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
736            * @throws SystemException if a system exception occurred
737            */
738            public static com.liferay.portal.model.UserGroup fetchByCompanyId_Last(
739                    long companyId,
740                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
741                    throws com.liferay.portal.kernel.exception.SystemException {
742                    return getPersistence()
743                                       .fetchByCompanyId_Last(companyId, orderByComparator);
744            }
745    
746            /**
747            * Returns the user groups before and after the current user group in the ordered set where companyId = &#63;.
748            *
749            * @param userGroupId the primary key of the current user group
750            * @param companyId the company ID
751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
752            * @return the previous, current, and next user group
753            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
754            * @throws SystemException if a system exception occurred
755            */
756            public static com.liferay.portal.model.UserGroup[] findByCompanyId_PrevAndNext(
757                    long userGroupId, long companyId,
758                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
759                    throws com.liferay.portal.NoSuchUserGroupException,
760                            com.liferay.portal.kernel.exception.SystemException {
761                    return getPersistence()
762                                       .findByCompanyId_PrevAndNext(userGroupId, companyId,
763                            orderByComparator);
764            }
765    
766            /**
767            * Returns all the user groups that the user has permission to view where companyId = &#63;.
768            *
769            * @param companyId the company ID
770            * @return the matching user groups that the user has permission to view
771            * @throws SystemException if a system exception occurred
772            */
773            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId(
774                    long companyId)
775                    throws com.liferay.portal.kernel.exception.SystemException {
776                    return getPersistence().filterFindByCompanyId(companyId);
777            }
778    
779            /**
780            * Returns a range of all the user groups that the user has permission to view where companyId = &#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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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 start the lower bound of the range of user groups
788            * @param end the upper bound of the range of user groups (not inclusive)
789            * @return the range of matching user groups that the user has permission to view
790            * @throws SystemException if a system exception occurred
791            */
792            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId(
793                    long companyId, int start, int end)
794                    throws com.liferay.portal.kernel.exception.SystemException {
795                    return getPersistence().filterFindByCompanyId(companyId, start, end);
796            }
797    
798            /**
799            * Returns an ordered range of all the user groups that the user has permissions to view where companyId = &#63;.
800            *
801            * <p>
802            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
803            * </p>
804            *
805            * @param companyId the company ID
806            * @param start the lower bound of the range of user groups
807            * @param end the upper bound of the range of user groups (not inclusive)
808            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
809            * @return the ordered range of matching user groups that the user has permission to view
810            * @throws SystemException if a system exception occurred
811            */
812            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId(
813                    long companyId, int start, int end,
814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
815                    throws com.liferay.portal.kernel.exception.SystemException {
816                    return getPersistence()
817                                       .filterFindByCompanyId(companyId, start, end,
818                            orderByComparator);
819            }
820    
821            /**
822            * 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;.
823            *
824            * @param userGroupId the primary key of the current user group
825            * @param companyId the company ID
826            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
827            * @return the previous, current, and next user group
828            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
829            * @throws SystemException if a system exception occurred
830            */
831            public static com.liferay.portal.model.UserGroup[] filterFindByCompanyId_PrevAndNext(
832                    long userGroupId, long companyId,
833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
834                    throws com.liferay.portal.NoSuchUserGroupException,
835                            com.liferay.portal.kernel.exception.SystemException {
836                    return getPersistence()
837                                       .filterFindByCompanyId_PrevAndNext(userGroupId, companyId,
838                            orderByComparator);
839            }
840    
841            /**
842            * Removes all the user groups where companyId = &#63; from the database.
843            *
844            * @param companyId the company ID
845            * @throws SystemException if a system exception occurred
846            */
847            public static void removeByCompanyId(long companyId)
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    getPersistence().removeByCompanyId(companyId);
850            }
851    
852            /**
853            * Returns the number of user groups where companyId = &#63;.
854            *
855            * @param companyId the company ID
856            * @return the number of matching user groups
857            * @throws SystemException if a system exception occurred
858            */
859            public static int countByCompanyId(long companyId)
860                    throws com.liferay.portal.kernel.exception.SystemException {
861                    return getPersistence().countByCompanyId(companyId);
862            }
863    
864            /**
865            * Returns the number of user groups that the user has permission to view where companyId = &#63;.
866            *
867            * @param companyId the company ID
868            * @return the number of matching user groups that the user has permission to view
869            * @throws SystemException if a system exception occurred
870            */
871            public static int filterCountByCompanyId(long companyId)
872                    throws com.liferay.portal.kernel.exception.SystemException {
873                    return getPersistence().filterCountByCompanyId(companyId);
874            }
875    
876            /**
877            * Returns all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
878            *
879            * @param companyId the company ID
880            * @param parentUserGroupId the parent user group ID
881            * @return the matching user groups
882            * @throws SystemException if a system exception occurred
883            */
884            public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P(
885                    long companyId, long parentUserGroupId)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence().findByC_P(companyId, parentUserGroupId);
888            }
889    
890            /**
891            * Returns a range of all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
892            *
893            * <p>
894            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
895            * </p>
896            *
897            * @param companyId the company ID
898            * @param parentUserGroupId the parent user group ID
899            * @param start the lower bound of the range of user groups
900            * @param end the upper bound of the range of user groups (not inclusive)
901            * @return the range of matching user groups
902            * @throws SystemException if a system exception occurred
903            */
904            public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P(
905                    long companyId, long parentUserGroupId, int start, int end)
906                    throws com.liferay.portal.kernel.exception.SystemException {
907                    return getPersistence()
908                                       .findByC_P(companyId, parentUserGroupId, start, end);
909            }
910    
911            /**
912            * Returns an ordered range of all the user groups where companyId = &#63; and parentUserGroupId = &#63;.
913            *
914            * <p>
915            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
916            * </p>
917            *
918            * @param companyId the company ID
919            * @param parentUserGroupId the parent user group ID
920            * @param start the lower bound of the range of user groups
921            * @param end the upper bound of the range of user groups (not inclusive)
922            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
923            * @return the ordered range of matching user groups
924            * @throws SystemException if a system exception occurred
925            */
926            public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P(
927                    long companyId, long parentUserGroupId, int start, int end,
928                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
929                    throws com.liferay.portal.kernel.exception.SystemException {
930                    return getPersistence()
931                                       .findByC_P(companyId, parentUserGroupId, start, end,
932                            orderByComparator);
933            }
934    
935            /**
936            * Returns the first user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
937            *
938            * @param companyId the company ID
939            * @param parentUserGroupId the parent user group ID
940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
941            * @return the first matching user group
942            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
943            * @throws SystemException if a system exception occurred
944            */
945            public static com.liferay.portal.model.UserGroup findByC_P_First(
946                    long companyId, long parentUserGroupId,
947                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
948                    throws com.liferay.portal.NoSuchUserGroupException,
949                            com.liferay.portal.kernel.exception.SystemException {
950                    return getPersistence()
951                                       .findByC_P_First(companyId, parentUserGroupId,
952                            orderByComparator);
953            }
954    
955            /**
956            * Returns the first user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
957            *
958            * @param companyId the company ID
959            * @param parentUserGroupId the parent user group ID
960            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
961            * @return the first matching user group, or <code>null</code> if a matching user group could not be found
962            * @throws SystemException if a system exception occurred
963            */
964            public static com.liferay.portal.model.UserGroup fetchByC_P_First(
965                    long companyId, long parentUserGroupId,
966                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
967                    throws com.liferay.portal.kernel.exception.SystemException {
968                    return getPersistence()
969                                       .fetchByC_P_First(companyId, parentUserGroupId,
970                            orderByComparator);
971            }
972    
973            /**
974            * Returns the last user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
975            *
976            * @param companyId the company ID
977            * @param parentUserGroupId the parent user group ID
978            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
979            * @return the last matching user group
980            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
981            * @throws SystemException if a system exception occurred
982            */
983            public static com.liferay.portal.model.UserGroup findByC_P_Last(
984                    long companyId, long parentUserGroupId,
985                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
986                    throws com.liferay.portal.NoSuchUserGroupException,
987                            com.liferay.portal.kernel.exception.SystemException {
988                    return getPersistence()
989                                       .findByC_P_Last(companyId, parentUserGroupId,
990                            orderByComparator);
991            }
992    
993            /**
994            * Returns the last user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
995            *
996            * @param companyId the company ID
997            * @param parentUserGroupId the parent user group ID
998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
999            * @return the last matching user group, or <code>null</code> if a matching user group could not be found
1000            * @throws SystemException if a system exception occurred
1001            */
1002            public static com.liferay.portal.model.UserGroup fetchByC_P_Last(
1003                    long companyId, long parentUserGroupId,
1004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1005                    throws com.liferay.portal.kernel.exception.SystemException {
1006                    return getPersistence()
1007                                       .fetchByC_P_Last(companyId, parentUserGroupId,
1008                            orderByComparator);
1009            }
1010    
1011            /**
1012            * Returns the user groups before and after the current user group in the ordered set where companyId = &#63; and parentUserGroupId = &#63;.
1013            *
1014            * @param userGroupId the primary key of the current user group
1015            * @param companyId the company ID
1016            * @param parentUserGroupId the parent user group ID
1017            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1018            * @return the previous, current, and next user group
1019            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
1020            * @throws SystemException if a system exception occurred
1021            */
1022            public static com.liferay.portal.model.UserGroup[] findByC_P_PrevAndNext(
1023                    long userGroupId, long companyId, long parentUserGroupId,
1024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1025                    throws com.liferay.portal.NoSuchUserGroupException,
1026                            com.liferay.portal.kernel.exception.SystemException {
1027                    return getPersistence()
1028                                       .findByC_P_PrevAndNext(userGroupId, companyId,
1029                            parentUserGroupId, orderByComparator);
1030            }
1031    
1032            /**
1033            * Returns all the user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
1034            *
1035            * @param companyId the company ID
1036            * @param parentUserGroupId the parent user group ID
1037            * @return the matching user groups that the user has permission to view
1038            * @throws SystemException if a system exception occurred
1039            */
1040            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P(
1041                    long companyId, long parentUserGroupId)
1042                    throws com.liferay.portal.kernel.exception.SystemException {
1043                    return getPersistence().filterFindByC_P(companyId, parentUserGroupId);
1044            }
1045    
1046            /**
1047            * Returns a range of all the user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
1048            *
1049            * <p>
1050            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1051            * </p>
1052            *
1053            * @param companyId the company ID
1054            * @param parentUserGroupId the parent user group ID
1055            * @param start the lower bound of the range of user groups
1056            * @param end the upper bound of the range of user groups (not inclusive)
1057            * @return the range of matching user groups that the user has permission to view
1058            * @throws SystemException if a system exception occurred
1059            */
1060            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P(
1061                    long companyId, long parentUserGroupId, int start, int end)
1062                    throws com.liferay.portal.kernel.exception.SystemException {
1063                    return getPersistence()
1064                                       .filterFindByC_P(companyId, parentUserGroupId, start, end);
1065            }
1066    
1067            /**
1068            * Returns an ordered range of all the user groups that the user has permissions to view where companyId = &#63; and parentUserGroupId = &#63;.
1069            *
1070            * <p>
1071            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1072            * </p>
1073            *
1074            * @param companyId the company ID
1075            * @param parentUserGroupId the parent user group ID
1076            * @param start the lower bound of the range of user groups
1077            * @param end the upper bound of the range of user groups (not inclusive)
1078            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1079            * @return the ordered range of matching user groups that the user has permission to view
1080            * @throws SystemException if a system exception occurred
1081            */
1082            public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P(
1083                    long companyId, long parentUserGroupId, int start, int end,
1084                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1085                    throws com.liferay.portal.kernel.exception.SystemException {
1086                    return getPersistence()
1087                                       .filterFindByC_P(companyId, parentUserGroupId, start, end,
1088                            orderByComparator);
1089            }
1090    
1091            /**
1092            * 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;.
1093            *
1094            * @param userGroupId the primary key of the current user group
1095            * @param companyId the company ID
1096            * @param parentUserGroupId the parent user group ID
1097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1098            * @return the previous, current, and next user group
1099            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
1100            * @throws SystemException if a system exception occurred
1101            */
1102            public static com.liferay.portal.model.UserGroup[] filterFindByC_P_PrevAndNext(
1103                    long userGroupId, long companyId, long parentUserGroupId,
1104                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1105                    throws com.liferay.portal.NoSuchUserGroupException,
1106                            com.liferay.portal.kernel.exception.SystemException {
1107                    return getPersistence()
1108                                       .filterFindByC_P_PrevAndNext(userGroupId, companyId,
1109                            parentUserGroupId, orderByComparator);
1110            }
1111    
1112            /**
1113            * Removes all the user groups where companyId = &#63; and parentUserGroupId = &#63; from the database.
1114            *
1115            * @param companyId the company ID
1116            * @param parentUserGroupId the parent user group ID
1117            * @throws SystemException if a system exception occurred
1118            */
1119            public static void removeByC_P(long companyId, long parentUserGroupId)
1120                    throws com.liferay.portal.kernel.exception.SystemException {
1121                    getPersistence().removeByC_P(companyId, parentUserGroupId);
1122            }
1123    
1124            /**
1125            * Returns the number of user groups where companyId = &#63; and parentUserGroupId = &#63;.
1126            *
1127            * @param companyId the company ID
1128            * @param parentUserGroupId the parent user group ID
1129            * @return the number of matching user groups
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static int countByC_P(long companyId, long parentUserGroupId)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    return getPersistence().countByC_P(companyId, parentUserGroupId);
1135            }
1136    
1137            /**
1138            * Returns the number of user groups that the user has permission to view where companyId = &#63; and parentUserGroupId = &#63;.
1139            *
1140            * @param companyId the company ID
1141            * @param parentUserGroupId the parent user group ID
1142            * @return the number of matching user groups that the user has permission to view
1143            * @throws SystemException if a system exception occurred
1144            */
1145            public static int filterCountByC_P(long companyId, long parentUserGroupId)
1146                    throws com.liferay.portal.kernel.exception.SystemException {
1147                    return getPersistence().filterCountByC_P(companyId, parentUserGroupId);
1148            }
1149    
1150            /**
1151            * Returns the user group where companyId = &#63; and name = &#63; or throws a {@link com.liferay.portal.NoSuchUserGroupException} if it could not be found.
1152            *
1153            * @param companyId the company ID
1154            * @param name the name
1155            * @return the matching user group
1156            * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found
1157            * @throws SystemException if a system exception occurred
1158            */
1159            public static com.liferay.portal.model.UserGroup findByC_N(long companyId,
1160                    java.lang.String name)
1161                    throws com.liferay.portal.NoSuchUserGroupException,
1162                            com.liferay.portal.kernel.exception.SystemException {
1163                    return getPersistence().findByC_N(companyId, name);
1164            }
1165    
1166            /**
1167            * 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.
1168            *
1169            * @param companyId the company ID
1170            * @param name the name
1171            * @return the matching user group, or <code>null</code> if a matching user group could not be found
1172            * @throws SystemException if a system exception occurred
1173            */
1174            public static com.liferay.portal.model.UserGroup fetchByC_N(
1175                    long companyId, java.lang.String name)
1176                    throws com.liferay.portal.kernel.exception.SystemException {
1177                    return getPersistence().fetchByC_N(companyId, name);
1178            }
1179    
1180            /**
1181            * 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.
1182            *
1183            * @param companyId the company ID
1184            * @param name the name
1185            * @param retrieveFromCache whether to use the finder cache
1186            * @return the matching user group, or <code>null</code> if a matching user group could not be found
1187            * @throws SystemException if a system exception occurred
1188            */
1189            public static com.liferay.portal.model.UserGroup fetchByC_N(
1190                    long companyId, java.lang.String name, boolean retrieveFromCache)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence().fetchByC_N(companyId, name, retrieveFromCache);
1193            }
1194    
1195            /**
1196            * Removes the user group where companyId = &#63; and name = &#63; from the database.
1197            *
1198            * @param companyId the company ID
1199            * @param name the name
1200            * @return the user group that was removed
1201            * @throws SystemException if a system exception occurred
1202            */
1203            public static com.liferay.portal.model.UserGroup removeByC_N(
1204                    long companyId, java.lang.String name)
1205                    throws com.liferay.portal.NoSuchUserGroupException,
1206                            com.liferay.portal.kernel.exception.SystemException {
1207                    return getPersistence().removeByC_N(companyId, name);
1208            }
1209    
1210            /**
1211            * Returns the number of user groups where companyId = &#63; and name = &#63;.
1212            *
1213            * @param companyId the company ID
1214            * @param name the name
1215            * @return the number of matching user groups
1216            * @throws SystemException if a system exception occurred
1217            */
1218            public static int countByC_N(long companyId, java.lang.String name)
1219                    throws com.liferay.portal.kernel.exception.SystemException {
1220                    return getPersistence().countByC_N(companyId, name);
1221            }
1222    
1223            /**
1224            * Caches the user group in the entity cache if it is enabled.
1225            *
1226            * @param userGroup the user group
1227            */
1228            public static void cacheResult(com.liferay.portal.model.UserGroup userGroup) {
1229                    getPersistence().cacheResult(userGroup);
1230            }
1231    
1232            /**
1233            * Caches the user groups in the entity cache if it is enabled.
1234            *
1235            * @param userGroups the user groups
1236            */
1237            public static void cacheResult(
1238                    java.util.List<com.liferay.portal.model.UserGroup> userGroups) {
1239                    getPersistence().cacheResult(userGroups);
1240            }
1241    
1242            /**
1243            * Creates a new user group with the primary key. Does not add the user group to the database.
1244            *
1245            * @param userGroupId the primary key for the new user group
1246            * @return the new user group
1247            */
1248            public static com.liferay.portal.model.UserGroup create(long userGroupId) {
1249                    return getPersistence().create(userGroupId);
1250            }
1251    
1252            /**
1253            * Removes the user group with the primary key from the database. Also notifies the appropriate model listeners.
1254            *
1255            * @param userGroupId the primary key of the user group
1256            * @return the user group that was removed
1257            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
1258            * @throws SystemException if a system exception occurred
1259            */
1260            public static com.liferay.portal.model.UserGroup remove(long userGroupId)
1261                    throws com.liferay.portal.NoSuchUserGroupException,
1262                            com.liferay.portal.kernel.exception.SystemException {
1263                    return getPersistence().remove(userGroupId);
1264            }
1265    
1266            public static com.liferay.portal.model.UserGroup updateImpl(
1267                    com.liferay.portal.model.UserGroup userGroup)
1268                    throws com.liferay.portal.kernel.exception.SystemException {
1269                    return getPersistence().updateImpl(userGroup);
1270            }
1271    
1272            /**
1273            * Returns the user group with the primary key or throws a {@link com.liferay.portal.NoSuchUserGroupException} if it could not be found.
1274            *
1275            * @param userGroupId the primary key of the user group
1276            * @return the user group
1277            * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found
1278            * @throws SystemException if a system exception occurred
1279            */
1280            public static com.liferay.portal.model.UserGroup findByPrimaryKey(
1281                    long userGroupId)
1282                    throws com.liferay.portal.NoSuchUserGroupException,
1283                            com.liferay.portal.kernel.exception.SystemException {
1284                    return getPersistence().findByPrimaryKey(userGroupId);
1285            }
1286    
1287            /**
1288            * Returns the user group with the primary key or returns <code>null</code> if it could not be found.
1289            *
1290            * @param userGroupId the primary key of the user group
1291            * @return the user group, or <code>null</code> if a user group with the primary key could not be found
1292            * @throws SystemException if a system exception occurred
1293            */
1294            public static com.liferay.portal.model.UserGroup fetchByPrimaryKey(
1295                    long userGroupId)
1296                    throws com.liferay.portal.kernel.exception.SystemException {
1297                    return getPersistence().fetchByPrimaryKey(userGroupId);
1298            }
1299    
1300            /**
1301            * Returns all the user groups.
1302            *
1303            * @return the user groups
1304            * @throws SystemException if a system exception occurred
1305            */
1306            public static java.util.List<com.liferay.portal.model.UserGroup> findAll()
1307                    throws com.liferay.portal.kernel.exception.SystemException {
1308                    return getPersistence().findAll();
1309            }
1310    
1311            /**
1312            * Returns a range of all the user groups.
1313            *
1314            * <p>
1315            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1316            * </p>
1317            *
1318            * @param start the lower bound of the range of user groups
1319            * @param end the upper bound of the range of user groups (not inclusive)
1320            * @return the range of user groups
1321            * @throws SystemException if a system exception occurred
1322            */
1323            public static java.util.List<com.liferay.portal.model.UserGroup> findAll(
1324                    int start, int end)
1325                    throws com.liferay.portal.kernel.exception.SystemException {
1326                    return getPersistence().findAll(start, end);
1327            }
1328    
1329            /**
1330            * Returns an ordered range of all the user groups.
1331            *
1332            * <p>
1333            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1334            * </p>
1335            *
1336            * @param start the lower bound of the range of user groups
1337            * @param end the upper bound of the range of user groups (not inclusive)
1338            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1339            * @return the ordered range of user groups
1340            * @throws SystemException if a system exception occurred
1341            */
1342            public static java.util.List<com.liferay.portal.model.UserGroup> findAll(
1343                    int start, int end,
1344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1345                    throws com.liferay.portal.kernel.exception.SystemException {
1346                    return getPersistence().findAll(start, end, orderByComparator);
1347            }
1348    
1349            /**
1350            * Removes all the user groups from the database.
1351            *
1352            * @throws SystemException if a system exception occurred
1353            */
1354            public static void removeAll()
1355                    throws com.liferay.portal.kernel.exception.SystemException {
1356                    getPersistence().removeAll();
1357            }
1358    
1359            /**
1360            * Returns the number of user groups.
1361            *
1362            * @return the number of user groups
1363            * @throws SystemException if a system exception occurred
1364            */
1365            public static int countAll()
1366                    throws com.liferay.portal.kernel.exception.SystemException {
1367                    return getPersistence().countAll();
1368            }
1369    
1370            /**
1371            * Returns all the groups associated with the user group.
1372            *
1373            * @param pk the primary key of the user group
1374            * @return the groups associated with the user group
1375            * @throws SystemException if a system exception occurred
1376            */
1377            public static java.util.List<com.liferay.portal.model.Group> getGroups(
1378                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
1379                    return getPersistence().getGroups(pk);
1380            }
1381    
1382            /**
1383            * Returns a range of all the groups associated with the user group.
1384            *
1385            * <p>
1386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1387            * </p>
1388            *
1389            * @param pk the primary key of the user group
1390            * @param start the lower bound of the range of user groups
1391            * @param end the upper bound of the range of user groups (not inclusive)
1392            * @return the range of groups associated with the user group
1393            * @throws SystemException if a system exception occurred
1394            */
1395            public static java.util.List<com.liferay.portal.model.Group> getGroups(
1396                    long pk, int start, int end)
1397                    throws com.liferay.portal.kernel.exception.SystemException {
1398                    return getPersistence().getGroups(pk, start, end);
1399            }
1400    
1401            /**
1402            * Returns an ordered range of all the groups associated with the user group.
1403            *
1404            * <p>
1405            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1406            * </p>
1407            *
1408            * @param pk the primary key of the user group
1409            * @param start the lower bound of the range of user groups
1410            * @param end the upper bound of the range of user groups (not inclusive)
1411            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1412            * @return the ordered range of groups associated with the user group
1413            * @throws SystemException if a system exception occurred
1414            */
1415            public static java.util.List<com.liferay.portal.model.Group> getGroups(
1416                    long pk, int start, int end,
1417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1418                    throws com.liferay.portal.kernel.exception.SystemException {
1419                    return getPersistence().getGroups(pk, start, end, orderByComparator);
1420            }
1421    
1422            /**
1423            * Returns the number of groups associated with the user group.
1424            *
1425            * @param pk the primary key of the user group
1426            * @return the number of groups associated with the user group
1427            * @throws SystemException if a system exception occurred
1428            */
1429            public static int getGroupsSize(long pk)
1430                    throws com.liferay.portal.kernel.exception.SystemException {
1431                    return getPersistence().getGroupsSize(pk);
1432            }
1433    
1434            /**
1435            * Returns <code>true</code> if the group is associated with the user group.
1436            *
1437            * @param pk the primary key of the user group
1438            * @param groupPK the primary key of the group
1439            * @return <code>true</code> if the group is associated with the user group; <code>false</code> otherwise
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static boolean containsGroup(long pk, long groupPK)
1443                    throws com.liferay.portal.kernel.exception.SystemException {
1444                    return getPersistence().containsGroup(pk, groupPK);
1445            }
1446    
1447            /**
1448            * Returns <code>true</code> if the user group has any groups associated with it.
1449            *
1450            * @param pk the primary key of the user group to check for associations with groups
1451            * @return <code>true</code> if the user group has any groups associated with it; <code>false</code> otherwise
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static boolean containsGroups(long pk)
1455                    throws com.liferay.portal.kernel.exception.SystemException {
1456                    return getPersistence().containsGroups(pk);
1457            }
1458    
1459            /**
1460            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1461            *
1462            * @param pk the primary key of the user group
1463            * @param groupPK the primary key of the group
1464            * @throws SystemException if a system exception occurred
1465            */
1466            public static void addGroup(long pk, long groupPK)
1467                    throws com.liferay.portal.kernel.exception.SystemException {
1468                    getPersistence().addGroup(pk, groupPK);
1469            }
1470    
1471            /**
1472            * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1473            *
1474            * @param pk the primary key of the user group
1475            * @param group the group
1476            * @throws SystemException if a system exception occurred
1477            */
1478            public static void addGroup(long pk, com.liferay.portal.model.Group group)
1479                    throws com.liferay.portal.kernel.exception.SystemException {
1480                    getPersistence().addGroup(pk, group);
1481            }
1482    
1483            /**
1484            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1485            *
1486            * @param pk the primary key of the user group
1487            * @param groupPKs the primary keys of the groups
1488            * @throws SystemException if a system exception occurred
1489            */
1490            public static void addGroups(long pk, long[] groupPKs)
1491                    throws com.liferay.portal.kernel.exception.SystemException {
1492                    getPersistence().addGroups(pk, groupPKs);
1493            }
1494    
1495            /**
1496            * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1497            *
1498            * @param pk the primary key of the user group
1499            * @param groups the groups
1500            * @throws SystemException if a system exception occurred
1501            */
1502            public static void addGroups(long pk,
1503                    java.util.List<com.liferay.portal.model.Group> groups)
1504                    throws com.liferay.portal.kernel.exception.SystemException {
1505                    getPersistence().addGroups(pk, groups);
1506            }
1507    
1508            /**
1509            * Clears all associations between the user group and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1510            *
1511            * @param pk the primary key of the user group to clear the associated groups from
1512            * @throws SystemException if a system exception occurred
1513            */
1514            public static void clearGroups(long pk)
1515                    throws com.liferay.portal.kernel.exception.SystemException {
1516                    getPersistence().clearGroups(pk);
1517            }
1518    
1519            /**
1520            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1521            *
1522            * @param pk the primary key of the user group
1523            * @param groupPK the primary key of the group
1524            * @throws SystemException if a system exception occurred
1525            */
1526            public static void removeGroup(long pk, long groupPK)
1527                    throws com.liferay.portal.kernel.exception.SystemException {
1528                    getPersistence().removeGroup(pk, groupPK);
1529            }
1530    
1531            /**
1532            * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1533            *
1534            * @param pk the primary key of the user group
1535            * @param group the group
1536            * @throws SystemException if a system exception occurred
1537            */
1538            public static void removeGroup(long pk, com.liferay.portal.model.Group group)
1539                    throws com.liferay.portal.kernel.exception.SystemException {
1540                    getPersistence().removeGroup(pk, group);
1541            }
1542    
1543            /**
1544            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1545            *
1546            * @param pk the primary key of the user group
1547            * @param groupPKs the primary keys of the groups
1548            * @throws SystemException if a system exception occurred
1549            */
1550            public static void removeGroups(long pk, long[] groupPKs)
1551                    throws com.liferay.portal.kernel.exception.SystemException {
1552                    getPersistence().removeGroups(pk, groupPKs);
1553            }
1554    
1555            /**
1556            * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1557            *
1558            * @param pk the primary key of the user group
1559            * @param groups the groups
1560            * @throws SystemException if a system exception occurred
1561            */
1562            public static void removeGroups(long pk,
1563                    java.util.List<com.liferay.portal.model.Group> groups)
1564                    throws com.liferay.portal.kernel.exception.SystemException {
1565                    getPersistence().removeGroups(pk, groups);
1566            }
1567    
1568            /**
1569            * 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.
1570            *
1571            * @param pk the primary key of the user group
1572            * @param groupPKs the primary keys of the groups to be associated with the user group
1573            * @throws SystemException if a system exception occurred
1574            */
1575            public static void setGroups(long pk, long[] groupPKs)
1576                    throws com.liferay.portal.kernel.exception.SystemException {
1577                    getPersistence().setGroups(pk, groupPKs);
1578            }
1579    
1580            /**
1581            * 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.
1582            *
1583            * @param pk the primary key of the user group
1584            * @param groups the groups to be associated with the user group
1585            * @throws SystemException if a system exception occurred
1586            */
1587            public static void setGroups(long pk,
1588                    java.util.List<com.liferay.portal.model.Group> groups)
1589                    throws com.liferay.portal.kernel.exception.SystemException {
1590                    getPersistence().setGroups(pk, groups);
1591            }
1592    
1593            /**
1594            * Returns all the teams associated with the user group.
1595            *
1596            * @param pk the primary key of the user group
1597            * @return the teams associated with the user group
1598            * @throws SystemException if a system exception occurred
1599            */
1600            public static java.util.List<com.liferay.portal.model.Team> getTeams(
1601                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
1602                    return getPersistence().getTeams(pk);
1603            }
1604    
1605            /**
1606            * Returns a range of all the teams associated with the user group.
1607            *
1608            * <p>
1609            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1610            * </p>
1611            *
1612            * @param pk the primary key of the user group
1613            * @param start the lower bound of the range of user groups
1614            * @param end the upper bound of the range of user groups (not inclusive)
1615            * @return the range of teams associated with the user group
1616            * @throws SystemException if a system exception occurred
1617            */
1618            public static java.util.List<com.liferay.portal.model.Team> getTeams(
1619                    long pk, int start, int end)
1620                    throws com.liferay.portal.kernel.exception.SystemException {
1621                    return getPersistence().getTeams(pk, start, end);
1622            }
1623    
1624            /**
1625            * Returns an ordered range of all the teams associated with the user group.
1626            *
1627            * <p>
1628            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1629            * </p>
1630            *
1631            * @param pk the primary key of the user group
1632            * @param start the lower bound of the range of user groups
1633            * @param end the upper bound of the range of user groups (not inclusive)
1634            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1635            * @return the ordered range of teams associated with the user group
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static java.util.List<com.liferay.portal.model.Team> getTeams(
1639                    long pk, int start, int end,
1640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1641                    throws com.liferay.portal.kernel.exception.SystemException {
1642                    return getPersistence().getTeams(pk, start, end, orderByComparator);
1643            }
1644    
1645            /**
1646            * Returns the number of teams associated with the user group.
1647            *
1648            * @param pk the primary key of the user group
1649            * @return the number of teams associated with the user group
1650            * @throws SystemException if a system exception occurred
1651            */
1652            public static int getTeamsSize(long pk)
1653                    throws com.liferay.portal.kernel.exception.SystemException {
1654                    return getPersistence().getTeamsSize(pk);
1655            }
1656    
1657            /**
1658            * Returns <code>true</code> if the team is associated with the user group.
1659            *
1660            * @param pk the primary key of the user group
1661            * @param teamPK the primary key of the team
1662            * @return <code>true</code> if the team is associated with the user group; <code>false</code> otherwise
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static boolean containsTeam(long pk, long teamPK)
1666                    throws com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence().containsTeam(pk, teamPK);
1668            }
1669    
1670            /**
1671            * Returns <code>true</code> if the user group has any teams associated with it.
1672            *
1673            * @param pk the primary key of the user group to check for associations with teams
1674            * @return <code>true</code> if the user group has any teams associated with it; <code>false</code> otherwise
1675            * @throws SystemException if a system exception occurred
1676            */
1677            public static boolean containsTeams(long pk)
1678                    throws com.liferay.portal.kernel.exception.SystemException {
1679                    return getPersistence().containsTeams(pk);
1680            }
1681    
1682            /**
1683            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1684            *
1685            * @param pk the primary key of the user group
1686            * @param teamPK the primary key of the team
1687            * @throws SystemException if a system exception occurred
1688            */
1689            public static void addTeam(long pk, long teamPK)
1690                    throws com.liferay.portal.kernel.exception.SystemException {
1691                    getPersistence().addTeam(pk, teamPK);
1692            }
1693    
1694            /**
1695            * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1696            *
1697            * @param pk the primary key of the user group
1698            * @param team the team
1699            * @throws SystemException if a system exception occurred
1700            */
1701            public static void addTeam(long pk, com.liferay.portal.model.Team team)
1702                    throws com.liferay.portal.kernel.exception.SystemException {
1703                    getPersistence().addTeam(pk, team);
1704            }
1705    
1706            /**
1707            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1708            *
1709            * @param pk the primary key of the user group
1710            * @param teamPKs the primary keys of the teams
1711            * @throws SystemException if a system exception occurred
1712            */
1713            public static void addTeams(long pk, long[] teamPKs)
1714                    throws com.liferay.portal.kernel.exception.SystemException {
1715                    getPersistence().addTeams(pk, teamPKs);
1716            }
1717    
1718            /**
1719            * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1720            *
1721            * @param pk the primary key of the user group
1722            * @param teams the teams
1723            * @throws SystemException if a system exception occurred
1724            */
1725            public static void addTeams(long pk,
1726                    java.util.List<com.liferay.portal.model.Team> teams)
1727                    throws com.liferay.portal.kernel.exception.SystemException {
1728                    getPersistence().addTeams(pk, teams);
1729            }
1730    
1731            /**
1732            * Clears all associations between the user group and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1733            *
1734            * @param pk the primary key of the user group to clear the associated teams from
1735            * @throws SystemException if a system exception occurred
1736            */
1737            public static void clearTeams(long pk)
1738                    throws com.liferay.portal.kernel.exception.SystemException {
1739                    getPersistence().clearTeams(pk);
1740            }
1741    
1742            /**
1743            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1744            *
1745            * @param pk the primary key of the user group
1746            * @param teamPK the primary key of the team
1747            * @throws SystemException if a system exception occurred
1748            */
1749            public static void removeTeam(long pk, long teamPK)
1750                    throws com.liferay.portal.kernel.exception.SystemException {
1751                    getPersistence().removeTeam(pk, teamPK);
1752            }
1753    
1754            /**
1755            * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1756            *
1757            * @param pk the primary key of the user group
1758            * @param team the team
1759            * @throws SystemException if a system exception occurred
1760            */
1761            public static void removeTeam(long pk, com.liferay.portal.model.Team team)
1762                    throws com.liferay.portal.kernel.exception.SystemException {
1763                    getPersistence().removeTeam(pk, team);
1764            }
1765    
1766            /**
1767            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1768            *
1769            * @param pk the primary key of the user group
1770            * @param teamPKs the primary keys of the teams
1771            * @throws SystemException if a system exception occurred
1772            */
1773            public static void removeTeams(long pk, long[] teamPKs)
1774                    throws com.liferay.portal.kernel.exception.SystemException {
1775                    getPersistence().removeTeams(pk, teamPKs);
1776            }
1777    
1778            /**
1779            * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1780            *
1781            * @param pk the primary key of the user group
1782            * @param teams the teams
1783            * @throws SystemException if a system exception occurred
1784            */
1785            public static void removeTeams(long pk,
1786                    java.util.List<com.liferay.portal.model.Team> teams)
1787                    throws com.liferay.portal.kernel.exception.SystemException {
1788                    getPersistence().removeTeams(pk, teams);
1789            }
1790    
1791            /**
1792            * 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.
1793            *
1794            * @param pk the primary key of the user group
1795            * @param teamPKs the primary keys of the teams to be associated with the user group
1796            * @throws SystemException if a system exception occurred
1797            */
1798            public static void setTeams(long pk, long[] teamPKs)
1799                    throws com.liferay.portal.kernel.exception.SystemException {
1800                    getPersistence().setTeams(pk, teamPKs);
1801            }
1802    
1803            /**
1804            * 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.
1805            *
1806            * @param pk the primary key of the user group
1807            * @param teams the teams to be associated with the user group
1808            * @throws SystemException if a system exception occurred
1809            */
1810            public static void setTeams(long pk,
1811                    java.util.List<com.liferay.portal.model.Team> teams)
1812                    throws com.liferay.portal.kernel.exception.SystemException {
1813                    getPersistence().setTeams(pk, teams);
1814            }
1815    
1816            /**
1817            * Returns all the users associated with the user group.
1818            *
1819            * @param pk the primary key of the user group
1820            * @return the users associated with the user group
1821            * @throws SystemException if a system exception occurred
1822            */
1823            public static java.util.List<com.liferay.portal.model.User> getUsers(
1824                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
1825                    return getPersistence().getUsers(pk);
1826            }
1827    
1828            /**
1829            * Returns a range of all the users associated with the user group.
1830            *
1831            * <p>
1832            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1833            * </p>
1834            *
1835            * @param pk the primary key of the user group
1836            * @param start the lower bound of the range of user groups
1837            * @param end the upper bound of the range of user groups (not inclusive)
1838            * @return the range of users associated with the user group
1839            * @throws SystemException if a system exception occurred
1840            */
1841            public static java.util.List<com.liferay.portal.model.User> getUsers(
1842                    long pk, int start, int end)
1843                    throws com.liferay.portal.kernel.exception.SystemException {
1844                    return getPersistence().getUsers(pk, start, end);
1845            }
1846    
1847            /**
1848            * Returns an ordered range of all the users associated with the user group.
1849            *
1850            * <p>
1851            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1852            * </p>
1853            *
1854            * @param pk the primary key of the user group
1855            * @param start the lower bound of the range of user groups
1856            * @param end the upper bound of the range of user groups (not inclusive)
1857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1858            * @return the ordered range of users associated with the user group
1859            * @throws SystemException if a system exception occurred
1860            */
1861            public static java.util.List<com.liferay.portal.model.User> getUsers(
1862                    long pk, int start, int end,
1863                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1864                    throws com.liferay.portal.kernel.exception.SystemException {
1865                    return getPersistence().getUsers(pk, start, end, orderByComparator);
1866            }
1867    
1868            /**
1869            * Returns the number of users associated with the user group.
1870            *
1871            * @param pk the primary key of the user group
1872            * @return the number of users associated with the user group
1873            * @throws SystemException if a system exception occurred
1874            */
1875            public static int getUsersSize(long pk)
1876                    throws com.liferay.portal.kernel.exception.SystemException {
1877                    return getPersistence().getUsersSize(pk);
1878            }
1879    
1880            /**
1881            * Returns <code>true</code> if the user is associated with the user group.
1882            *
1883            * @param pk the primary key of the user group
1884            * @param userPK the primary key of the user
1885            * @return <code>true</code> if the user is associated with the user group; <code>false</code> otherwise
1886            * @throws SystemException if a system exception occurred
1887            */
1888            public static boolean containsUser(long pk, long userPK)
1889                    throws com.liferay.portal.kernel.exception.SystemException {
1890                    return getPersistence().containsUser(pk, userPK);
1891            }
1892    
1893            /**
1894            * Returns <code>true</code> if the user group has any users associated with it.
1895            *
1896            * @param pk the primary key of the user group to check for associations with users
1897            * @return <code>true</code> if the user group has any users associated with it; <code>false</code> otherwise
1898            * @throws SystemException if a system exception occurred
1899            */
1900            public static boolean containsUsers(long pk)
1901                    throws com.liferay.portal.kernel.exception.SystemException {
1902                    return getPersistence().containsUsers(pk);
1903            }
1904    
1905            /**
1906            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1907            *
1908            * @param pk the primary key of the user group
1909            * @param userPK the primary key of the user
1910            * @throws SystemException if a system exception occurred
1911            */
1912            public static void addUser(long pk, long userPK)
1913                    throws com.liferay.portal.kernel.exception.SystemException {
1914                    getPersistence().addUser(pk, userPK);
1915            }
1916    
1917            /**
1918            * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1919            *
1920            * @param pk the primary key of the user group
1921            * @param user the user
1922            * @throws SystemException if a system exception occurred
1923            */
1924            public static void addUser(long pk, com.liferay.portal.model.User user)
1925                    throws com.liferay.portal.kernel.exception.SystemException {
1926                    getPersistence().addUser(pk, user);
1927            }
1928    
1929            /**
1930            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1931            *
1932            * @param pk the primary key of the user group
1933            * @param userPKs the primary keys of the users
1934            * @throws SystemException if a system exception occurred
1935            */
1936            public static void addUsers(long pk, long[] userPKs)
1937                    throws com.liferay.portal.kernel.exception.SystemException {
1938                    getPersistence().addUsers(pk, userPKs);
1939            }
1940    
1941            /**
1942            * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1943            *
1944            * @param pk the primary key of the user group
1945            * @param users the users
1946            * @throws SystemException if a system exception occurred
1947            */
1948            public static void addUsers(long pk,
1949                    java.util.List<com.liferay.portal.model.User> users)
1950                    throws com.liferay.portal.kernel.exception.SystemException {
1951                    getPersistence().addUsers(pk, users);
1952            }
1953    
1954            /**
1955            * Clears all associations between the user group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1956            *
1957            * @param pk the primary key of the user group to clear the associated users from
1958            * @throws SystemException if a system exception occurred
1959            */
1960            public static void clearUsers(long pk)
1961                    throws com.liferay.portal.kernel.exception.SystemException {
1962                    getPersistence().clearUsers(pk);
1963            }
1964    
1965            /**
1966            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1967            *
1968            * @param pk the primary key of the user group
1969            * @param userPK the primary key of the user
1970            * @throws SystemException if a system exception occurred
1971            */
1972            public static void removeUser(long pk, long userPK)
1973                    throws com.liferay.portal.kernel.exception.SystemException {
1974                    getPersistence().removeUser(pk, userPK);
1975            }
1976    
1977            /**
1978            * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1979            *
1980            * @param pk the primary key of the user group
1981            * @param user the user
1982            * @throws SystemException if a system exception occurred
1983            */
1984            public static void removeUser(long pk, com.liferay.portal.model.User user)
1985                    throws com.liferay.portal.kernel.exception.SystemException {
1986                    getPersistence().removeUser(pk, user);
1987            }
1988    
1989            /**
1990            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1991            *
1992            * @param pk the primary key of the user group
1993            * @param userPKs the primary keys of the users
1994            * @throws SystemException if a system exception occurred
1995            */
1996            public static void removeUsers(long pk, long[] userPKs)
1997                    throws com.liferay.portal.kernel.exception.SystemException {
1998                    getPersistence().removeUsers(pk, userPKs);
1999            }
2000    
2001            /**
2002            * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2003            *
2004            * @param pk the primary key of the user group
2005            * @param users the users
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static void removeUsers(long pk,
2009                    java.util.List<com.liferay.portal.model.User> users)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    getPersistence().removeUsers(pk, users);
2012            }
2013    
2014            /**
2015            * 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.
2016            *
2017            * @param pk the primary key of the user group
2018            * @param userPKs the primary keys of the users to be associated with the user group
2019            * @throws SystemException if a system exception occurred
2020            */
2021            public static void setUsers(long pk, long[] userPKs)
2022                    throws com.liferay.portal.kernel.exception.SystemException {
2023                    getPersistence().setUsers(pk, userPKs);
2024            }
2025    
2026            /**
2027            * 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.
2028            *
2029            * @param pk the primary key of the user group
2030            * @param users the users to be associated with the user group
2031            * @throws SystemException if a system exception occurred
2032            */
2033            public static void setUsers(long pk,
2034                    java.util.List<com.liferay.portal.model.User> users)
2035                    throws com.liferay.portal.kernel.exception.SystemException {
2036                    getPersistence().setUsers(pk, users);
2037            }
2038    
2039            public static UserGroupPersistence getPersistence() {
2040                    if (_persistence == null) {
2041                            _persistence = (UserGroupPersistence)PortalBeanLocatorUtil.locate(UserGroupPersistence.class.getName());
2042    
2043                            ReferenceRegistry.registerReference(UserGroupUtil.class,
2044                                    "_persistence");
2045                    }
2046    
2047                    return _persistence;
2048            }
2049    
2050            /**
2051             * @deprecated As of 6.2.0
2052             */
2053            public void setPersistence(UserGroupPersistence persistence) {
2054            }
2055    
2056            private static UserGroupPersistence _persistence;
2057    }