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