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.Role;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the role service. This utility wraps {@link com.liferay.portal.service.persistence.impl.RolePersistenceImpl} 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 RolePersistence
037     * @see com.liferay.portal.service.persistence.impl.RolePersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class RoleUtil {
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(Role role) {
059                    getPersistence().clearCache(role);
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<Role> 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<Role> 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<Role> findWithDynamicQuery(DynamicQuery dynamicQuery,
088                    int start, int end, OrderByComparator<Role> 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 Role update(Role role) {
098                    return getPersistence().update(role);
099            }
100    
101            /**
102             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
103             */
104            public static Role update(Role role, ServiceContext serviceContext) {
105                    return getPersistence().update(role, serviceContext);
106            }
107    
108            /**
109            * Returns all the roles where uuid = &#63;.
110            *
111            * @param uuid the uuid
112            * @return the matching roles
113            */
114            public static List<Role> findByUuid(java.lang.String uuid) {
115                    return getPersistence().findByUuid(uuid);
116            }
117    
118            /**
119            * Returns a range of all the roles where uuid = &#63;.
120            *
121            * <p>
122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
123            * </p>
124            *
125            * @param uuid the uuid
126            * @param start the lower bound of the range of roles
127            * @param end the upper bound of the range of roles (not inclusive)
128            * @return the range of matching roles
129            */
130            public static List<Role> findByUuid(java.lang.String uuid, int start,
131                    int end) {
132                    return getPersistence().findByUuid(uuid, start, end);
133            }
134    
135            /**
136            * Returns an ordered range of all the roles where uuid = &#63;.
137            *
138            * <p>
139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
140            * </p>
141            *
142            * @param uuid the uuid
143            * @param start the lower bound of the range of roles
144            * @param end the upper bound of the range of roles (not inclusive)
145            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
146            * @return the ordered range of matching roles
147            */
148            public static List<Role> findByUuid(java.lang.String uuid, int start,
149                    int end, OrderByComparator<Role> orderByComparator) {
150                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
151            }
152    
153            /**
154            * Returns the first role in the ordered set where uuid = &#63;.
155            *
156            * @param uuid the uuid
157            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
158            * @return the first matching role
159            * @throws NoSuchRoleException if a matching role could not be found
160            */
161            public static Role findByUuid_First(java.lang.String uuid,
162                    OrderByComparator<Role> orderByComparator)
163                    throws com.liferay.portal.NoSuchRoleException {
164                    return getPersistence().findByUuid_First(uuid, orderByComparator);
165            }
166    
167            /**
168            * Returns the first role in the ordered set where uuid = &#63;.
169            *
170            * @param uuid the uuid
171            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
172            * @return the first matching role, or <code>null</code> if a matching role could not be found
173            */
174            public static Role fetchByUuid_First(java.lang.String uuid,
175                    OrderByComparator<Role> orderByComparator) {
176                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
177            }
178    
179            /**
180            * Returns the last role in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the last matching role
185            * @throws NoSuchRoleException if a matching role could not be found
186            */
187            public static Role findByUuid_Last(java.lang.String uuid,
188                    OrderByComparator<Role> orderByComparator)
189                    throws com.liferay.portal.NoSuchRoleException {
190                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the last role in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the last matching role, or <code>null</code> if a matching role could not be found
199            */
200            public static Role fetchByUuid_Last(java.lang.String uuid,
201                    OrderByComparator<Role> orderByComparator) {
202                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the roles before and after the current role in the ordered set where uuid = &#63;.
207            *
208            * @param roleId the primary key of the current role
209            * @param uuid the uuid
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the previous, current, and next role
212            * @throws NoSuchRoleException if a role with the primary key could not be found
213            */
214            public static Role[] findByUuid_PrevAndNext(long roleId,
215                    java.lang.String uuid, OrderByComparator<Role> orderByComparator)
216                    throws com.liferay.portal.NoSuchRoleException {
217                    return getPersistence()
218                                       .findByUuid_PrevAndNext(roleId, uuid, orderByComparator);
219            }
220    
221            /**
222            * Returns all the roles that the user has permission to view where uuid = &#63;.
223            *
224            * @param uuid the uuid
225            * @return the matching roles that the user has permission to view
226            */
227            public static List<Role> filterFindByUuid(java.lang.String uuid) {
228                    return getPersistence().filterFindByUuid(uuid);
229            }
230    
231            /**
232            * Returns a range of all the roles that the user has permission to view where uuid = &#63;.
233            *
234            * <p>
235            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
236            * </p>
237            *
238            * @param uuid the uuid
239            * @param start the lower bound of the range of roles
240            * @param end the upper bound of the range of roles (not inclusive)
241            * @return the range of matching roles that the user has permission to view
242            */
243            public static List<Role> filterFindByUuid(java.lang.String uuid, int start,
244                    int end) {
245                    return getPersistence().filterFindByUuid(uuid, start, end);
246            }
247    
248            /**
249            * Returns an ordered range of all the roles that the user has permissions to view where uuid = &#63;.
250            *
251            * <p>
252            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
253            * </p>
254            *
255            * @param uuid the uuid
256            * @param start the lower bound of the range of roles
257            * @param end the upper bound of the range of roles (not inclusive)
258            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
259            * @return the ordered range of matching roles that the user has permission to view
260            */
261            public static List<Role> filterFindByUuid(java.lang.String uuid, int start,
262                    int end, OrderByComparator<Role> orderByComparator) {
263                    return getPersistence()
264                                       .filterFindByUuid(uuid, start, end, orderByComparator);
265            }
266    
267            /**
268            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where uuid = &#63;.
269            *
270            * @param roleId the primary key of the current role
271            * @param uuid the uuid
272            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
273            * @return the previous, current, and next role
274            * @throws NoSuchRoleException if a role with the primary key could not be found
275            */
276            public static Role[] filterFindByUuid_PrevAndNext(long roleId,
277                    java.lang.String uuid, OrderByComparator<Role> orderByComparator)
278                    throws com.liferay.portal.NoSuchRoleException {
279                    return getPersistence()
280                                       .filterFindByUuid_PrevAndNext(roleId, uuid, orderByComparator);
281            }
282    
283            /**
284            * Removes all the roles where uuid = &#63; from the database.
285            *
286            * @param uuid the uuid
287            */
288            public static void removeByUuid(java.lang.String uuid) {
289                    getPersistence().removeByUuid(uuid);
290            }
291    
292            /**
293            * Returns the number of roles where uuid = &#63;.
294            *
295            * @param uuid the uuid
296            * @return the number of matching roles
297            */
298            public static int countByUuid(java.lang.String uuid) {
299                    return getPersistence().countByUuid(uuid);
300            }
301    
302            /**
303            * Returns the number of roles that the user has permission to view where uuid = &#63;.
304            *
305            * @param uuid the uuid
306            * @return the number of matching roles that the user has permission to view
307            */
308            public static int filterCountByUuid(java.lang.String uuid) {
309                    return getPersistence().filterCountByUuid(uuid);
310            }
311    
312            /**
313            * Returns all the roles where uuid = &#63; and companyId = &#63;.
314            *
315            * @param uuid the uuid
316            * @param companyId the company ID
317            * @return the matching roles
318            */
319            public static List<Role> findByUuid_C(java.lang.String uuid, long companyId) {
320                    return getPersistence().findByUuid_C(uuid, companyId);
321            }
322    
323            /**
324            * Returns a range of all the roles where uuid = &#63; and companyId = &#63;.
325            *
326            * <p>
327            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
328            * </p>
329            *
330            * @param uuid the uuid
331            * @param companyId the company ID
332            * @param start the lower bound of the range of roles
333            * @param end the upper bound of the range of roles (not inclusive)
334            * @return the range of matching roles
335            */
336            public static List<Role> findByUuid_C(java.lang.String uuid,
337                    long companyId, int start, int end) {
338                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
339            }
340    
341            /**
342            * Returns an ordered range of all the roles where uuid = &#63; and companyId = &#63;.
343            *
344            * <p>
345            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
346            * </p>
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @param start the lower bound of the range of roles
351            * @param end the upper bound of the range of roles (not inclusive)
352            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
353            * @return the ordered range of matching roles
354            */
355            public static List<Role> findByUuid_C(java.lang.String uuid,
356                    long companyId, int start, int end,
357                    OrderByComparator<Role> orderByComparator) {
358                    return getPersistence()
359                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
360            }
361    
362            /**
363            * Returns the first role in the ordered set where uuid = &#63; and companyId = &#63;.
364            *
365            * @param uuid the uuid
366            * @param companyId the company ID
367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
368            * @return the first matching role
369            * @throws NoSuchRoleException if a matching role could not be found
370            */
371            public static Role findByUuid_C_First(java.lang.String uuid,
372                    long companyId, OrderByComparator<Role> orderByComparator)
373                    throws com.liferay.portal.NoSuchRoleException {
374                    return getPersistence()
375                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
376            }
377    
378            /**
379            * Returns the first role 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 role, or <code>null</code> if a matching role could not be found
385            */
386            public static Role fetchByUuid_C_First(java.lang.String uuid,
387                    long companyId, OrderByComparator<Role> orderByComparator) {
388                    return getPersistence()
389                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
390            }
391    
392            /**
393            * Returns the last role in the ordered set where uuid = &#63; and companyId = &#63;.
394            *
395            * @param uuid the uuid
396            * @param companyId the company ID
397            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
398            * @return the last matching role
399            * @throws NoSuchRoleException if a matching role could not be found
400            */
401            public static Role findByUuid_C_Last(java.lang.String uuid, long companyId,
402                    OrderByComparator<Role> orderByComparator)
403                    throws com.liferay.portal.NoSuchRoleException {
404                    return getPersistence()
405                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
406            }
407    
408            /**
409            * Returns the last role in the ordered set where uuid = &#63; and companyId = &#63;.
410            *
411            * @param uuid the uuid
412            * @param companyId the company ID
413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
414            * @return the last matching role, or <code>null</code> if a matching role could not be found
415            */
416            public static Role fetchByUuid_C_Last(java.lang.String uuid,
417                    long companyId, OrderByComparator<Role> orderByComparator) {
418                    return getPersistence()
419                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
420            }
421    
422            /**
423            * Returns the roles before and after the current role in the ordered set where uuid = &#63; and companyId = &#63;.
424            *
425            * @param roleId the primary key of the current role
426            * @param uuid the uuid
427            * @param companyId the company ID
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the previous, current, and next role
430            * @throws NoSuchRoleException if a role with the primary key could not be found
431            */
432            public static Role[] findByUuid_C_PrevAndNext(long roleId,
433                    java.lang.String uuid, long companyId,
434                    OrderByComparator<Role> orderByComparator)
435                    throws com.liferay.portal.NoSuchRoleException {
436                    return getPersistence()
437                                       .findByUuid_C_PrevAndNext(roleId, uuid, companyId,
438                            orderByComparator);
439            }
440    
441            /**
442            * Returns all the roles that the user has permission to view where uuid = &#63; and companyId = &#63;.
443            *
444            * @param uuid the uuid
445            * @param companyId the company ID
446            * @return the matching roles that the user has permission to view
447            */
448            public static List<Role> filterFindByUuid_C(java.lang.String uuid,
449                    long companyId) {
450                    return getPersistence().filterFindByUuid_C(uuid, companyId);
451            }
452    
453            /**
454            * Returns a range of all the roles that the user has permission to view where uuid = &#63; and companyId = &#63;.
455            *
456            * <p>
457            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
458            * </p>
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param start the lower bound of the range of roles
463            * @param end the upper bound of the range of roles (not inclusive)
464            * @return the range of matching roles that the user has permission to view
465            */
466            public static List<Role> filterFindByUuid_C(java.lang.String uuid,
467                    long companyId, int start, int end) {
468                    return getPersistence().filterFindByUuid_C(uuid, companyId, start, end);
469            }
470    
471            /**
472            * Returns an ordered range of all the roles that the user has permissions to view where uuid = &#63; and companyId = &#63;.
473            *
474            * <p>
475            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
476            * </p>
477            *
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param start the lower bound of the range of roles
481            * @param end the upper bound of the range of roles (not inclusive)
482            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
483            * @return the ordered range of matching roles that the user has permission to view
484            */
485            public static List<Role> filterFindByUuid_C(java.lang.String uuid,
486                    long companyId, int start, int end,
487                    OrderByComparator<Role> orderByComparator) {
488                    return getPersistence()
489                                       .filterFindByUuid_C(uuid, companyId, start, end,
490                            orderByComparator);
491            }
492    
493            /**
494            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where uuid = &#63; and companyId = &#63;.
495            *
496            * @param roleId the primary key of the current role
497            * @param uuid the uuid
498            * @param companyId the company ID
499            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
500            * @return the previous, current, and next role
501            * @throws NoSuchRoleException if a role with the primary key could not be found
502            */
503            public static Role[] filterFindByUuid_C_PrevAndNext(long roleId,
504                    java.lang.String uuid, long companyId,
505                    OrderByComparator<Role> orderByComparator)
506                    throws com.liferay.portal.NoSuchRoleException {
507                    return getPersistence()
508                                       .filterFindByUuid_C_PrevAndNext(roleId, uuid, companyId,
509                            orderByComparator);
510            }
511    
512            /**
513            * Removes all the roles where uuid = &#63; and companyId = &#63; from the database.
514            *
515            * @param uuid the uuid
516            * @param companyId the company ID
517            */
518            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
519                    getPersistence().removeByUuid_C(uuid, companyId);
520            }
521    
522            /**
523            * Returns the number of roles where uuid = &#63; and companyId = &#63;.
524            *
525            * @param uuid the uuid
526            * @param companyId the company ID
527            * @return the number of matching roles
528            */
529            public static int countByUuid_C(java.lang.String uuid, long companyId) {
530                    return getPersistence().countByUuid_C(uuid, companyId);
531            }
532    
533            /**
534            * Returns the number of roles that the user has permission to view where uuid = &#63; and companyId = &#63;.
535            *
536            * @param uuid the uuid
537            * @param companyId the company ID
538            * @return the number of matching roles that the user has permission to view
539            */
540            public static int filterCountByUuid_C(java.lang.String uuid, long companyId) {
541                    return getPersistence().filterCountByUuid_C(uuid, companyId);
542            }
543    
544            /**
545            * Returns all the roles where companyId = &#63;.
546            *
547            * @param companyId the company ID
548            * @return the matching roles
549            */
550            public static List<Role> findByCompanyId(long companyId) {
551                    return getPersistence().findByCompanyId(companyId);
552            }
553    
554            /**
555            * Returns a range of all the roles where companyId = &#63;.
556            *
557            * <p>
558            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
559            * </p>
560            *
561            * @param companyId the company ID
562            * @param start the lower bound of the range of roles
563            * @param end the upper bound of the range of roles (not inclusive)
564            * @return the range of matching roles
565            */
566            public static List<Role> findByCompanyId(long companyId, int start, int end) {
567                    return getPersistence().findByCompanyId(companyId, start, end);
568            }
569    
570            /**
571            * Returns an ordered range of all the roles where companyId = &#63;.
572            *
573            * <p>
574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
575            * </p>
576            *
577            * @param companyId the company ID
578            * @param start the lower bound of the range of roles
579            * @param end the upper bound of the range of roles (not inclusive)
580            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
581            * @return the ordered range of matching roles
582            */
583            public static List<Role> findByCompanyId(long companyId, int start,
584                    int end, OrderByComparator<Role> orderByComparator) {
585                    return getPersistence()
586                                       .findByCompanyId(companyId, start, end, orderByComparator);
587            }
588    
589            /**
590            * Returns the first role in the ordered set where companyId = &#63;.
591            *
592            * @param companyId the company ID
593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
594            * @return the first matching role
595            * @throws NoSuchRoleException if a matching role could not be found
596            */
597            public static Role findByCompanyId_First(long companyId,
598                    OrderByComparator<Role> orderByComparator)
599                    throws com.liferay.portal.NoSuchRoleException {
600                    return getPersistence()
601                                       .findByCompanyId_First(companyId, orderByComparator);
602            }
603    
604            /**
605            * Returns the first role in the ordered set where companyId = &#63;.
606            *
607            * @param companyId the company ID
608            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
609            * @return the first matching role, or <code>null</code> if a matching role could not be found
610            */
611            public static Role fetchByCompanyId_First(long companyId,
612                    OrderByComparator<Role> orderByComparator) {
613                    return getPersistence()
614                                       .fetchByCompanyId_First(companyId, orderByComparator);
615            }
616    
617            /**
618            * Returns the last role in the ordered set where companyId = &#63;.
619            *
620            * @param companyId the company ID
621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
622            * @return the last matching role
623            * @throws NoSuchRoleException if a matching role could not be found
624            */
625            public static Role findByCompanyId_Last(long companyId,
626                    OrderByComparator<Role> orderByComparator)
627                    throws com.liferay.portal.NoSuchRoleException {
628                    return getPersistence()
629                                       .findByCompanyId_Last(companyId, orderByComparator);
630            }
631    
632            /**
633            * Returns the last role in the ordered set where companyId = &#63;.
634            *
635            * @param companyId the company ID
636            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
637            * @return the last matching role, or <code>null</code> if a matching role could not be found
638            */
639            public static Role fetchByCompanyId_Last(long companyId,
640                    OrderByComparator<Role> orderByComparator) {
641                    return getPersistence()
642                                       .fetchByCompanyId_Last(companyId, orderByComparator);
643            }
644    
645            /**
646            * Returns the roles before and after the current role in the ordered set where companyId = &#63;.
647            *
648            * @param roleId the primary key of the current role
649            * @param companyId the company ID
650            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
651            * @return the previous, current, and next role
652            * @throws NoSuchRoleException if a role with the primary key could not be found
653            */
654            public static Role[] findByCompanyId_PrevAndNext(long roleId,
655                    long companyId, OrderByComparator<Role> orderByComparator)
656                    throws com.liferay.portal.NoSuchRoleException {
657                    return getPersistence()
658                                       .findByCompanyId_PrevAndNext(roleId, companyId,
659                            orderByComparator);
660            }
661    
662            /**
663            * Returns all the roles that the user has permission to view where companyId = &#63;.
664            *
665            * @param companyId the company ID
666            * @return the matching roles that the user has permission to view
667            */
668            public static List<Role> filterFindByCompanyId(long companyId) {
669                    return getPersistence().filterFindByCompanyId(companyId);
670            }
671    
672            /**
673            * Returns a range of all the roles that the user has permission to view where companyId = &#63;.
674            *
675            * <p>
676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
677            * </p>
678            *
679            * @param companyId the company ID
680            * @param start the lower bound of the range of roles
681            * @param end the upper bound of the range of roles (not inclusive)
682            * @return the range of matching roles that the user has permission to view
683            */
684            public static List<Role> filterFindByCompanyId(long companyId, int start,
685                    int end) {
686                    return getPersistence().filterFindByCompanyId(companyId, start, end);
687            }
688    
689            /**
690            * Returns an ordered range of all the roles that the user has permissions to view where companyId = &#63;.
691            *
692            * <p>
693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
694            * </p>
695            *
696            * @param companyId the company ID
697            * @param start the lower bound of the range of roles
698            * @param end the upper bound of the range of roles (not inclusive)
699            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
700            * @return the ordered range of matching roles that the user has permission to view
701            */
702            public static List<Role> filterFindByCompanyId(long companyId, int start,
703                    int end, OrderByComparator<Role> orderByComparator) {
704                    return getPersistence()
705                                       .filterFindByCompanyId(companyId, start, end,
706                            orderByComparator);
707            }
708    
709            /**
710            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where companyId = &#63;.
711            *
712            * @param roleId the primary key of the current role
713            * @param companyId the company ID
714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
715            * @return the previous, current, and next role
716            * @throws NoSuchRoleException if a role with the primary key could not be found
717            */
718            public static Role[] filterFindByCompanyId_PrevAndNext(long roleId,
719                    long companyId, OrderByComparator<Role> orderByComparator)
720                    throws com.liferay.portal.NoSuchRoleException {
721                    return getPersistence()
722                                       .filterFindByCompanyId_PrevAndNext(roleId, companyId,
723                            orderByComparator);
724            }
725    
726            /**
727            * Removes all the roles where companyId = &#63; from the database.
728            *
729            * @param companyId the company ID
730            */
731            public static void removeByCompanyId(long companyId) {
732                    getPersistence().removeByCompanyId(companyId);
733            }
734    
735            /**
736            * Returns the number of roles where companyId = &#63;.
737            *
738            * @param companyId the company ID
739            * @return the number of matching roles
740            */
741            public static int countByCompanyId(long companyId) {
742                    return getPersistence().countByCompanyId(companyId);
743            }
744    
745            /**
746            * Returns the number of roles that the user has permission to view where companyId = &#63;.
747            *
748            * @param companyId the company ID
749            * @return the number of matching roles that the user has permission to view
750            */
751            public static int filterCountByCompanyId(long companyId) {
752                    return getPersistence().filterCountByCompanyId(companyId);
753            }
754    
755            /**
756            * Returns all the roles where name = &#63;.
757            *
758            * @param name the name
759            * @return the matching roles
760            */
761            public static List<Role> findByName(java.lang.String name) {
762                    return getPersistence().findByName(name);
763            }
764    
765            /**
766            * Returns a range of all the roles where name = &#63;.
767            *
768            * <p>
769            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
770            * </p>
771            *
772            * @param name the name
773            * @param start the lower bound of the range of roles
774            * @param end the upper bound of the range of roles (not inclusive)
775            * @return the range of matching roles
776            */
777            public static List<Role> findByName(java.lang.String name, int start,
778                    int end) {
779                    return getPersistence().findByName(name, start, end);
780            }
781    
782            /**
783            * Returns an ordered range of all the roles where name = &#63;.
784            *
785            * <p>
786            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
787            * </p>
788            *
789            * @param name the name
790            * @param start the lower bound of the range of roles
791            * @param end the upper bound of the range of roles (not inclusive)
792            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
793            * @return the ordered range of matching roles
794            */
795            public static List<Role> findByName(java.lang.String name, int start,
796                    int end, OrderByComparator<Role> orderByComparator) {
797                    return getPersistence().findByName(name, start, end, orderByComparator);
798            }
799    
800            /**
801            * Returns the first role in the ordered set where name = &#63;.
802            *
803            * @param name the name
804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
805            * @return the first matching role
806            * @throws NoSuchRoleException if a matching role could not be found
807            */
808            public static Role findByName_First(java.lang.String name,
809                    OrderByComparator<Role> orderByComparator)
810                    throws com.liferay.portal.NoSuchRoleException {
811                    return getPersistence().findByName_First(name, orderByComparator);
812            }
813    
814            /**
815            * Returns the first role in the ordered set where name = &#63;.
816            *
817            * @param name the name
818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
819            * @return the first matching role, or <code>null</code> if a matching role could not be found
820            */
821            public static Role fetchByName_First(java.lang.String name,
822                    OrderByComparator<Role> orderByComparator) {
823                    return getPersistence().fetchByName_First(name, orderByComparator);
824            }
825    
826            /**
827            * Returns the last role in the ordered set where name = &#63;.
828            *
829            * @param name the name
830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
831            * @return the last matching role
832            * @throws NoSuchRoleException if a matching role could not be found
833            */
834            public static Role findByName_Last(java.lang.String name,
835                    OrderByComparator<Role> orderByComparator)
836                    throws com.liferay.portal.NoSuchRoleException {
837                    return getPersistence().findByName_Last(name, orderByComparator);
838            }
839    
840            /**
841            * Returns the last role in the ordered set where name = &#63;.
842            *
843            * @param name the name
844            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
845            * @return the last matching role, or <code>null</code> if a matching role could not be found
846            */
847            public static Role fetchByName_Last(java.lang.String name,
848                    OrderByComparator<Role> orderByComparator) {
849                    return getPersistence().fetchByName_Last(name, orderByComparator);
850            }
851    
852            /**
853            * Returns the roles before and after the current role in the ordered set where name = &#63;.
854            *
855            * @param roleId the primary key of the current role
856            * @param name the name
857            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
858            * @return the previous, current, and next role
859            * @throws NoSuchRoleException if a role with the primary key could not be found
860            */
861            public static Role[] findByName_PrevAndNext(long roleId,
862                    java.lang.String name, OrderByComparator<Role> orderByComparator)
863                    throws com.liferay.portal.NoSuchRoleException {
864                    return getPersistence()
865                                       .findByName_PrevAndNext(roleId, name, orderByComparator);
866            }
867    
868            /**
869            * Returns all the roles that the user has permission to view where name = &#63;.
870            *
871            * @param name the name
872            * @return the matching roles that the user has permission to view
873            */
874            public static List<Role> filterFindByName(java.lang.String name) {
875                    return getPersistence().filterFindByName(name);
876            }
877    
878            /**
879            * Returns a range of all the roles that the user has permission to view where name = &#63;.
880            *
881            * <p>
882            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
883            * </p>
884            *
885            * @param name the name
886            * @param start the lower bound of the range of roles
887            * @param end the upper bound of the range of roles (not inclusive)
888            * @return the range of matching roles that the user has permission to view
889            */
890            public static List<Role> filterFindByName(java.lang.String name, int start,
891                    int end) {
892                    return getPersistence().filterFindByName(name, start, end);
893            }
894    
895            /**
896            * Returns an ordered range of all the roles that the user has permissions to view where name = &#63;.
897            *
898            * <p>
899            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
900            * </p>
901            *
902            * @param name the name
903            * @param start the lower bound of the range of roles
904            * @param end the upper bound of the range of roles (not inclusive)
905            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
906            * @return the ordered range of matching roles that the user has permission to view
907            */
908            public static List<Role> filterFindByName(java.lang.String name, int start,
909                    int end, OrderByComparator<Role> orderByComparator) {
910                    return getPersistence()
911                                       .filterFindByName(name, start, end, orderByComparator);
912            }
913    
914            /**
915            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where name = &#63;.
916            *
917            * @param roleId the primary key of the current role
918            * @param name the name
919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
920            * @return the previous, current, and next role
921            * @throws NoSuchRoleException if a role with the primary key could not be found
922            */
923            public static Role[] filterFindByName_PrevAndNext(long roleId,
924                    java.lang.String name, OrderByComparator<Role> orderByComparator)
925                    throws com.liferay.portal.NoSuchRoleException {
926                    return getPersistence()
927                                       .filterFindByName_PrevAndNext(roleId, name, orderByComparator);
928            }
929    
930            /**
931            * Removes all the roles where name = &#63; from the database.
932            *
933            * @param name the name
934            */
935            public static void removeByName(java.lang.String name) {
936                    getPersistence().removeByName(name);
937            }
938    
939            /**
940            * Returns the number of roles where name = &#63;.
941            *
942            * @param name the name
943            * @return the number of matching roles
944            */
945            public static int countByName(java.lang.String name) {
946                    return getPersistence().countByName(name);
947            }
948    
949            /**
950            * Returns the number of roles that the user has permission to view where name = &#63;.
951            *
952            * @param name the name
953            * @return the number of matching roles that the user has permission to view
954            */
955            public static int filterCountByName(java.lang.String name) {
956                    return getPersistence().filterCountByName(name);
957            }
958    
959            /**
960            * Returns all the roles where type = &#63;.
961            *
962            * @param type the type
963            * @return the matching roles
964            */
965            public static List<Role> findByType(int type) {
966                    return getPersistence().findByType(type);
967            }
968    
969            /**
970            * Returns a range of all the roles where type = &#63;.
971            *
972            * <p>
973            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
974            * </p>
975            *
976            * @param type the type
977            * @param start the lower bound of the range of roles
978            * @param end the upper bound of the range of roles (not inclusive)
979            * @return the range of matching roles
980            */
981            public static List<Role> findByType(int type, int start, int end) {
982                    return getPersistence().findByType(type, start, end);
983            }
984    
985            /**
986            * Returns an ordered range of all the roles where type = &#63;.
987            *
988            * <p>
989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
990            * </p>
991            *
992            * @param type the type
993            * @param start the lower bound of the range of roles
994            * @param end the upper bound of the range of roles (not inclusive)
995            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
996            * @return the ordered range of matching roles
997            */
998            public static List<Role> findByType(int type, int start, int end,
999                    OrderByComparator<Role> orderByComparator) {
1000                    return getPersistence().findByType(type, start, end, orderByComparator);
1001            }
1002    
1003            /**
1004            * Returns the first role in the ordered set where type = &#63;.
1005            *
1006            * @param type the type
1007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1008            * @return the first matching role
1009            * @throws NoSuchRoleException if a matching role could not be found
1010            */
1011            public static Role findByType_First(int type,
1012                    OrderByComparator<Role> orderByComparator)
1013                    throws com.liferay.portal.NoSuchRoleException {
1014                    return getPersistence().findByType_First(type, orderByComparator);
1015            }
1016    
1017            /**
1018            * Returns the first role in the ordered set where type = &#63;.
1019            *
1020            * @param type the type
1021            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1022            * @return the first matching role, or <code>null</code> if a matching role could not be found
1023            */
1024            public static Role fetchByType_First(int type,
1025                    OrderByComparator<Role> orderByComparator) {
1026                    return getPersistence().fetchByType_First(type, orderByComparator);
1027            }
1028    
1029            /**
1030            * Returns the last role in the ordered set where type = &#63;.
1031            *
1032            * @param type the type
1033            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1034            * @return the last matching role
1035            * @throws NoSuchRoleException if a matching role could not be found
1036            */
1037            public static Role findByType_Last(int type,
1038                    OrderByComparator<Role> orderByComparator)
1039                    throws com.liferay.portal.NoSuchRoleException {
1040                    return getPersistence().findByType_Last(type, orderByComparator);
1041            }
1042    
1043            /**
1044            * Returns the last role in the ordered set where type = &#63;.
1045            *
1046            * @param type the type
1047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1048            * @return the last matching role, or <code>null</code> if a matching role could not be found
1049            */
1050            public static Role fetchByType_Last(int type,
1051                    OrderByComparator<Role> orderByComparator) {
1052                    return getPersistence().fetchByType_Last(type, orderByComparator);
1053            }
1054    
1055            /**
1056            * Returns the roles before and after the current role in the ordered set where type = &#63;.
1057            *
1058            * @param roleId the primary key of the current role
1059            * @param type the type
1060            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1061            * @return the previous, current, and next role
1062            * @throws NoSuchRoleException if a role with the primary key could not be found
1063            */
1064            public static Role[] findByType_PrevAndNext(long roleId, int type,
1065                    OrderByComparator<Role> orderByComparator)
1066                    throws com.liferay.portal.NoSuchRoleException {
1067                    return getPersistence()
1068                                       .findByType_PrevAndNext(roleId, type, orderByComparator);
1069            }
1070    
1071            /**
1072            * Returns all the roles that the user has permission to view where type = &#63;.
1073            *
1074            * @param type the type
1075            * @return the matching roles that the user has permission to view
1076            */
1077            public static List<Role> filterFindByType(int type) {
1078                    return getPersistence().filterFindByType(type);
1079            }
1080    
1081            /**
1082            * Returns a range of all the roles that the user has permission to view where type = &#63;.
1083            *
1084            * <p>
1085            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1086            * </p>
1087            *
1088            * @param type the type
1089            * @param start the lower bound of the range of roles
1090            * @param end the upper bound of the range of roles (not inclusive)
1091            * @return the range of matching roles that the user has permission to view
1092            */
1093            public static List<Role> filterFindByType(int type, int start, int end) {
1094                    return getPersistence().filterFindByType(type, start, end);
1095            }
1096    
1097            /**
1098            * Returns an ordered range of all the roles that the user has permissions to view where type = &#63;.
1099            *
1100            * <p>
1101            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1102            * </p>
1103            *
1104            * @param type the type
1105            * @param start the lower bound of the range of roles
1106            * @param end the upper bound of the range of roles (not inclusive)
1107            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1108            * @return the ordered range of matching roles that the user has permission to view
1109            */
1110            public static List<Role> filterFindByType(int type, int start, int end,
1111                    OrderByComparator<Role> orderByComparator) {
1112                    return getPersistence()
1113                                       .filterFindByType(type, start, end, orderByComparator);
1114            }
1115    
1116            /**
1117            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where type = &#63;.
1118            *
1119            * @param roleId the primary key of the current role
1120            * @param type the type
1121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1122            * @return the previous, current, and next role
1123            * @throws NoSuchRoleException if a role with the primary key could not be found
1124            */
1125            public static Role[] filterFindByType_PrevAndNext(long roleId, int type,
1126                    OrderByComparator<Role> orderByComparator)
1127                    throws com.liferay.portal.NoSuchRoleException {
1128                    return getPersistence()
1129                                       .filterFindByType_PrevAndNext(roleId, type, orderByComparator);
1130            }
1131    
1132            /**
1133            * Removes all the roles where type = &#63; from the database.
1134            *
1135            * @param type the type
1136            */
1137            public static void removeByType(int type) {
1138                    getPersistence().removeByType(type);
1139            }
1140    
1141            /**
1142            * Returns the number of roles where type = &#63;.
1143            *
1144            * @param type the type
1145            * @return the number of matching roles
1146            */
1147            public static int countByType(int type) {
1148                    return getPersistence().countByType(type);
1149            }
1150    
1151            /**
1152            * Returns the number of roles that the user has permission to view where type = &#63;.
1153            *
1154            * @param type the type
1155            * @return the number of matching roles that the user has permission to view
1156            */
1157            public static int filterCountByType(int type) {
1158                    return getPersistence().filterCountByType(type);
1159            }
1160    
1161            /**
1162            * Returns all the roles where subtype = &#63;.
1163            *
1164            * @param subtype the subtype
1165            * @return the matching roles
1166            */
1167            public static List<Role> findBySubtype(java.lang.String subtype) {
1168                    return getPersistence().findBySubtype(subtype);
1169            }
1170    
1171            /**
1172            * Returns a range of all the roles where subtype = &#63;.
1173            *
1174            * <p>
1175            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1176            * </p>
1177            *
1178            * @param subtype the subtype
1179            * @param start the lower bound of the range of roles
1180            * @param end the upper bound of the range of roles (not inclusive)
1181            * @return the range of matching roles
1182            */
1183            public static List<Role> findBySubtype(java.lang.String subtype, int start,
1184                    int end) {
1185                    return getPersistence().findBySubtype(subtype, start, end);
1186            }
1187    
1188            /**
1189            * Returns an ordered range of all the roles where subtype = &#63;.
1190            *
1191            * <p>
1192            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1193            * </p>
1194            *
1195            * @param subtype the subtype
1196            * @param start the lower bound of the range of roles
1197            * @param end the upper bound of the range of roles (not inclusive)
1198            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1199            * @return the ordered range of matching roles
1200            */
1201            public static List<Role> findBySubtype(java.lang.String subtype, int start,
1202                    int end, OrderByComparator<Role> orderByComparator) {
1203                    return getPersistence()
1204                                       .findBySubtype(subtype, start, end, orderByComparator);
1205            }
1206    
1207            /**
1208            * Returns the first role in the ordered set where subtype = &#63;.
1209            *
1210            * @param subtype the subtype
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the first matching role
1213            * @throws NoSuchRoleException if a matching role could not be found
1214            */
1215            public static Role findBySubtype_First(java.lang.String subtype,
1216                    OrderByComparator<Role> orderByComparator)
1217                    throws com.liferay.portal.NoSuchRoleException {
1218                    return getPersistence().findBySubtype_First(subtype, orderByComparator);
1219            }
1220    
1221            /**
1222            * Returns the first role in the ordered set where subtype = &#63;.
1223            *
1224            * @param subtype the subtype
1225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1226            * @return the first matching role, or <code>null</code> if a matching role could not be found
1227            */
1228            public static Role fetchBySubtype_First(java.lang.String subtype,
1229                    OrderByComparator<Role> orderByComparator) {
1230                    return getPersistence().fetchBySubtype_First(subtype, orderByComparator);
1231            }
1232    
1233            /**
1234            * Returns the last role in the ordered set where subtype = &#63;.
1235            *
1236            * @param subtype the subtype
1237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1238            * @return the last matching role
1239            * @throws NoSuchRoleException if a matching role could not be found
1240            */
1241            public static Role findBySubtype_Last(java.lang.String subtype,
1242                    OrderByComparator<Role> orderByComparator)
1243                    throws com.liferay.portal.NoSuchRoleException {
1244                    return getPersistence().findBySubtype_Last(subtype, orderByComparator);
1245            }
1246    
1247            /**
1248            * Returns the last role in the ordered set where subtype = &#63;.
1249            *
1250            * @param subtype the subtype
1251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1252            * @return the last matching role, or <code>null</code> if a matching role could not be found
1253            */
1254            public static Role fetchBySubtype_Last(java.lang.String subtype,
1255                    OrderByComparator<Role> orderByComparator) {
1256                    return getPersistence().fetchBySubtype_Last(subtype, orderByComparator);
1257            }
1258    
1259            /**
1260            * Returns the roles before and after the current role in the ordered set where subtype = &#63;.
1261            *
1262            * @param roleId the primary key of the current role
1263            * @param subtype the subtype
1264            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1265            * @return the previous, current, and next role
1266            * @throws NoSuchRoleException if a role with the primary key could not be found
1267            */
1268            public static Role[] findBySubtype_PrevAndNext(long roleId,
1269                    java.lang.String subtype, OrderByComparator<Role> orderByComparator)
1270                    throws com.liferay.portal.NoSuchRoleException {
1271                    return getPersistence()
1272                                       .findBySubtype_PrevAndNext(roleId, subtype, orderByComparator);
1273            }
1274    
1275            /**
1276            * Returns all the roles that the user has permission to view where subtype = &#63;.
1277            *
1278            * @param subtype the subtype
1279            * @return the matching roles that the user has permission to view
1280            */
1281            public static List<Role> filterFindBySubtype(java.lang.String subtype) {
1282                    return getPersistence().filterFindBySubtype(subtype);
1283            }
1284    
1285            /**
1286            * Returns a range of all the roles that the user has permission to view where subtype = &#63;.
1287            *
1288            * <p>
1289            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1290            * </p>
1291            *
1292            * @param subtype the subtype
1293            * @param start the lower bound of the range of roles
1294            * @param end the upper bound of the range of roles (not inclusive)
1295            * @return the range of matching roles that the user has permission to view
1296            */
1297            public static List<Role> filterFindBySubtype(java.lang.String subtype,
1298                    int start, int end) {
1299                    return getPersistence().filterFindBySubtype(subtype, start, end);
1300            }
1301    
1302            /**
1303            * Returns an ordered range of all the roles that the user has permissions to view where subtype = &#63;.
1304            *
1305            * <p>
1306            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1307            * </p>
1308            *
1309            * @param subtype the subtype
1310            * @param start the lower bound of the range of roles
1311            * @param end the upper bound of the range of roles (not inclusive)
1312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1313            * @return the ordered range of matching roles that the user has permission to view
1314            */
1315            public static List<Role> filterFindBySubtype(java.lang.String subtype,
1316                    int start, int end, OrderByComparator<Role> orderByComparator) {
1317                    return getPersistence()
1318                                       .filterFindBySubtype(subtype, start, end, orderByComparator);
1319            }
1320    
1321            /**
1322            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where subtype = &#63;.
1323            *
1324            * @param roleId the primary key of the current role
1325            * @param subtype the subtype
1326            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1327            * @return the previous, current, and next role
1328            * @throws NoSuchRoleException if a role with the primary key could not be found
1329            */
1330            public static Role[] filterFindBySubtype_PrevAndNext(long roleId,
1331                    java.lang.String subtype, OrderByComparator<Role> orderByComparator)
1332                    throws com.liferay.portal.NoSuchRoleException {
1333                    return getPersistence()
1334                                       .filterFindBySubtype_PrevAndNext(roleId, subtype,
1335                            orderByComparator);
1336            }
1337    
1338            /**
1339            * Removes all the roles where subtype = &#63; from the database.
1340            *
1341            * @param subtype the subtype
1342            */
1343            public static void removeBySubtype(java.lang.String subtype) {
1344                    getPersistence().removeBySubtype(subtype);
1345            }
1346    
1347            /**
1348            * Returns the number of roles where subtype = &#63;.
1349            *
1350            * @param subtype the subtype
1351            * @return the number of matching roles
1352            */
1353            public static int countBySubtype(java.lang.String subtype) {
1354                    return getPersistence().countBySubtype(subtype);
1355            }
1356    
1357            /**
1358            * Returns the number of roles that the user has permission to view where subtype = &#63;.
1359            *
1360            * @param subtype the subtype
1361            * @return the number of matching roles that the user has permission to view
1362            */
1363            public static int filterCountBySubtype(java.lang.String subtype) {
1364                    return getPersistence().filterCountBySubtype(subtype);
1365            }
1366    
1367            /**
1368            * Returns the role where companyId = &#63; and name = &#63; or throws a {@link NoSuchRoleException} if it could not be found.
1369            *
1370            * @param companyId the company ID
1371            * @param name the name
1372            * @return the matching role
1373            * @throws NoSuchRoleException if a matching role could not be found
1374            */
1375            public static Role findByC_N(long companyId, java.lang.String name)
1376                    throws com.liferay.portal.NoSuchRoleException {
1377                    return getPersistence().findByC_N(companyId, name);
1378            }
1379    
1380            /**
1381            * Returns the role where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1382            *
1383            * @param companyId the company ID
1384            * @param name the name
1385            * @return the matching role, or <code>null</code> if a matching role could not be found
1386            */
1387            public static Role fetchByC_N(long companyId, java.lang.String name) {
1388                    return getPersistence().fetchByC_N(companyId, name);
1389            }
1390    
1391            /**
1392            * Returns the role where companyId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1393            *
1394            * @param companyId the company ID
1395            * @param name the name
1396            * @param retrieveFromCache whether to use the finder cache
1397            * @return the matching role, or <code>null</code> if a matching role could not be found
1398            */
1399            public static Role fetchByC_N(long companyId, java.lang.String name,
1400                    boolean retrieveFromCache) {
1401                    return getPersistence().fetchByC_N(companyId, name, retrieveFromCache);
1402            }
1403    
1404            /**
1405            * Removes the role where companyId = &#63; and name = &#63; from the database.
1406            *
1407            * @param companyId the company ID
1408            * @param name the name
1409            * @return the role that was removed
1410            */
1411            public static Role removeByC_N(long companyId, java.lang.String name)
1412                    throws com.liferay.portal.NoSuchRoleException {
1413                    return getPersistence().removeByC_N(companyId, name);
1414            }
1415    
1416            /**
1417            * Returns the number of roles where companyId = &#63; and name = &#63;.
1418            *
1419            * @param companyId the company ID
1420            * @param name the name
1421            * @return the number of matching roles
1422            */
1423            public static int countByC_N(long companyId, java.lang.String name) {
1424                    return getPersistence().countByC_N(companyId, name);
1425            }
1426    
1427            /**
1428            * Returns all the roles where companyId = &#63; and type = &#63;.
1429            *
1430            * @param companyId the company ID
1431            * @param type the type
1432            * @return the matching roles
1433            */
1434            public static List<Role> findByC_T(long companyId, int type) {
1435                    return getPersistence().findByC_T(companyId, type);
1436            }
1437    
1438            /**
1439            * Returns a range of all the roles where companyId = &#63; and type = &#63;.
1440            *
1441            * <p>
1442            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1443            * </p>
1444            *
1445            * @param companyId the company ID
1446            * @param type the type
1447            * @param start the lower bound of the range of roles
1448            * @param end the upper bound of the range of roles (not inclusive)
1449            * @return the range of matching roles
1450            */
1451            public static List<Role> findByC_T(long companyId, int type, int start,
1452                    int end) {
1453                    return getPersistence().findByC_T(companyId, type, start, end);
1454            }
1455    
1456            /**
1457            * Returns an ordered range of all the roles where companyId = &#63; and type = &#63;.
1458            *
1459            * <p>
1460            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1461            * </p>
1462            *
1463            * @param companyId the company ID
1464            * @param type the type
1465            * @param start the lower bound of the range of roles
1466            * @param end the upper bound of the range of roles (not inclusive)
1467            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1468            * @return the ordered range of matching roles
1469            */
1470            public static List<Role> findByC_T(long companyId, int type, int start,
1471                    int end, OrderByComparator<Role> orderByComparator) {
1472                    return getPersistence()
1473                                       .findByC_T(companyId, type, start, end, orderByComparator);
1474            }
1475    
1476            /**
1477            * Returns the first role in the ordered set where companyId = &#63; and type = &#63;.
1478            *
1479            * @param companyId the company ID
1480            * @param type the type
1481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1482            * @return the first matching role
1483            * @throws NoSuchRoleException if a matching role could not be found
1484            */
1485            public static Role findByC_T_First(long companyId, int type,
1486                    OrderByComparator<Role> orderByComparator)
1487                    throws com.liferay.portal.NoSuchRoleException {
1488                    return getPersistence()
1489                                       .findByC_T_First(companyId, type, orderByComparator);
1490            }
1491    
1492            /**
1493            * Returns the first role in the ordered set where companyId = &#63; and type = &#63;.
1494            *
1495            * @param companyId the company ID
1496            * @param type the type
1497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1498            * @return the first matching role, or <code>null</code> if a matching role could not be found
1499            */
1500            public static Role fetchByC_T_First(long companyId, int type,
1501                    OrderByComparator<Role> orderByComparator) {
1502                    return getPersistence()
1503                                       .fetchByC_T_First(companyId, type, orderByComparator);
1504            }
1505    
1506            /**
1507            * Returns the last role in the ordered set where companyId = &#63; and type = &#63;.
1508            *
1509            * @param companyId the company ID
1510            * @param type the type
1511            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1512            * @return the last matching role
1513            * @throws NoSuchRoleException if a matching role could not be found
1514            */
1515            public static Role findByC_T_Last(long companyId, int type,
1516                    OrderByComparator<Role> orderByComparator)
1517                    throws com.liferay.portal.NoSuchRoleException {
1518                    return getPersistence()
1519                                       .findByC_T_Last(companyId, type, orderByComparator);
1520            }
1521    
1522            /**
1523            * Returns the last role in the ordered set where companyId = &#63; and type = &#63;.
1524            *
1525            * @param companyId the company ID
1526            * @param type the type
1527            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1528            * @return the last matching role, or <code>null</code> if a matching role could not be found
1529            */
1530            public static Role fetchByC_T_Last(long companyId, int type,
1531                    OrderByComparator<Role> orderByComparator) {
1532                    return getPersistence()
1533                                       .fetchByC_T_Last(companyId, type, orderByComparator);
1534            }
1535    
1536            /**
1537            * Returns the roles before and after the current role in the ordered set where companyId = &#63; and type = &#63;.
1538            *
1539            * @param roleId the primary key of the current role
1540            * @param companyId the company ID
1541            * @param type the type
1542            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1543            * @return the previous, current, and next role
1544            * @throws NoSuchRoleException if a role with the primary key could not be found
1545            */
1546            public static Role[] findByC_T_PrevAndNext(long roleId, long companyId,
1547                    int type, OrderByComparator<Role> orderByComparator)
1548                    throws com.liferay.portal.NoSuchRoleException {
1549                    return getPersistence()
1550                                       .findByC_T_PrevAndNext(roleId, companyId, type,
1551                            orderByComparator);
1552            }
1553    
1554            /**
1555            * Returns all the roles that the user has permission to view where companyId = &#63; and type = &#63;.
1556            *
1557            * @param companyId the company ID
1558            * @param type the type
1559            * @return the matching roles that the user has permission to view
1560            */
1561            public static List<Role> filterFindByC_T(long companyId, int type) {
1562                    return getPersistence().filterFindByC_T(companyId, type);
1563            }
1564    
1565            /**
1566            * Returns a range of all the roles that the user has permission to view where companyId = &#63; and type = &#63;.
1567            *
1568            * <p>
1569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1570            * </p>
1571            *
1572            * @param companyId the company ID
1573            * @param type the type
1574            * @param start the lower bound of the range of roles
1575            * @param end the upper bound of the range of roles (not inclusive)
1576            * @return the range of matching roles that the user has permission to view
1577            */
1578            public static List<Role> filterFindByC_T(long companyId, int type,
1579                    int start, int end) {
1580                    return getPersistence().filterFindByC_T(companyId, type, start, end);
1581            }
1582    
1583            /**
1584            * Returns an ordered range of all the roles that the user has permissions to view where companyId = &#63; and type = &#63;.
1585            *
1586            * <p>
1587            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1588            * </p>
1589            *
1590            * @param companyId the company ID
1591            * @param type the type
1592            * @param start the lower bound of the range of roles
1593            * @param end the upper bound of the range of roles (not inclusive)
1594            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1595            * @return the ordered range of matching roles that the user has permission to view
1596            */
1597            public static List<Role> filterFindByC_T(long companyId, int type,
1598                    int start, int end, OrderByComparator<Role> orderByComparator) {
1599                    return getPersistence()
1600                                       .filterFindByC_T(companyId, type, start, end,
1601                            orderByComparator);
1602            }
1603    
1604            /**
1605            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where companyId = &#63; and type = &#63;.
1606            *
1607            * @param roleId the primary key of the current role
1608            * @param companyId the company ID
1609            * @param type the type
1610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1611            * @return the previous, current, and next role
1612            * @throws NoSuchRoleException if a role with the primary key could not be found
1613            */
1614            public static Role[] filterFindByC_T_PrevAndNext(long roleId,
1615                    long companyId, int type, OrderByComparator<Role> orderByComparator)
1616                    throws com.liferay.portal.NoSuchRoleException {
1617                    return getPersistence()
1618                                       .filterFindByC_T_PrevAndNext(roleId, companyId, type,
1619                            orderByComparator);
1620            }
1621    
1622            /**
1623            * Returns all the roles that the user has permission to view where companyId = &#63; and type = any &#63;.
1624            *
1625            * @param companyId the company ID
1626            * @param types the types
1627            * @return the matching roles that the user has permission to view
1628            */
1629            public static List<Role> filterFindByC_T(long companyId, int[] types) {
1630                    return getPersistence().filterFindByC_T(companyId, types);
1631            }
1632    
1633            /**
1634            * Returns a range of all the roles that the user has permission to view where companyId = &#63; and type = any &#63;.
1635            *
1636            * <p>
1637            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1638            * </p>
1639            *
1640            * @param companyId the company ID
1641            * @param types the types
1642            * @param start the lower bound of the range of roles
1643            * @param end the upper bound of the range of roles (not inclusive)
1644            * @return the range of matching roles that the user has permission to view
1645            */
1646            public static List<Role> filterFindByC_T(long companyId, int[] types,
1647                    int start, int end) {
1648                    return getPersistence().filterFindByC_T(companyId, types, start, end);
1649            }
1650    
1651            /**
1652            * Returns an ordered range of all the roles that the user has permission to view where companyId = &#63; and type = any &#63;.
1653            *
1654            * <p>
1655            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1656            * </p>
1657            *
1658            * @param companyId the company ID
1659            * @param types the types
1660            * @param start the lower bound of the range of roles
1661            * @param end the upper bound of the range of roles (not inclusive)
1662            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1663            * @return the ordered range of matching roles that the user has permission to view
1664            */
1665            public static List<Role> filterFindByC_T(long companyId, int[] types,
1666                    int start, int end, OrderByComparator<Role> orderByComparator) {
1667                    return getPersistence()
1668                                       .filterFindByC_T(companyId, types, start, end,
1669                            orderByComparator);
1670            }
1671    
1672            /**
1673            * Returns all the roles where companyId = &#63; and type = any &#63;.
1674            *
1675            * <p>
1676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1677            * </p>
1678            *
1679            * @param companyId the company ID
1680            * @param types the types
1681            * @return the matching roles
1682            */
1683            public static List<Role> findByC_T(long companyId, int[] types) {
1684                    return getPersistence().findByC_T(companyId, types);
1685            }
1686    
1687            /**
1688            * Returns a range of all the roles where companyId = &#63; and type = any &#63;.
1689            *
1690            * <p>
1691            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1692            * </p>
1693            *
1694            * @param companyId the company ID
1695            * @param types the types
1696            * @param start the lower bound of the range of roles
1697            * @param end the upper bound of the range of roles (not inclusive)
1698            * @return the range of matching roles
1699            */
1700            public static List<Role> findByC_T(long companyId, int[] types, int start,
1701                    int end) {
1702                    return getPersistence().findByC_T(companyId, types, start, end);
1703            }
1704    
1705            /**
1706            * Returns an ordered range of all the roles where companyId = &#63; and type = any &#63;.
1707            *
1708            * <p>
1709            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1710            * </p>
1711            *
1712            * @param companyId the company ID
1713            * @param types the types
1714            * @param start the lower bound of the range of roles
1715            * @param end the upper bound of the range of roles (not inclusive)
1716            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1717            * @return the ordered range of matching roles
1718            */
1719            public static List<Role> findByC_T(long companyId, int[] types, int start,
1720                    int end, OrderByComparator<Role> orderByComparator) {
1721                    return getPersistence()
1722                                       .findByC_T(companyId, types, start, end, orderByComparator);
1723            }
1724    
1725            /**
1726            * Removes all the roles where companyId = &#63; and type = &#63; from the database.
1727            *
1728            * @param companyId the company ID
1729            * @param type the type
1730            */
1731            public static void removeByC_T(long companyId, int type) {
1732                    getPersistence().removeByC_T(companyId, type);
1733            }
1734    
1735            /**
1736            * Returns the number of roles where companyId = &#63; and type = &#63;.
1737            *
1738            * @param companyId the company ID
1739            * @param type the type
1740            * @return the number of matching roles
1741            */
1742            public static int countByC_T(long companyId, int type) {
1743                    return getPersistence().countByC_T(companyId, type);
1744            }
1745    
1746            /**
1747            * Returns the number of roles where companyId = &#63; and type = any &#63;.
1748            *
1749            * @param companyId the company ID
1750            * @param types the types
1751            * @return the number of matching roles
1752            */
1753            public static int countByC_T(long companyId, int[] types) {
1754                    return getPersistence().countByC_T(companyId, types);
1755            }
1756    
1757            /**
1758            * Returns the number of roles that the user has permission to view where companyId = &#63; and type = &#63;.
1759            *
1760            * @param companyId the company ID
1761            * @param type the type
1762            * @return the number of matching roles that the user has permission to view
1763            */
1764            public static int filterCountByC_T(long companyId, int type) {
1765                    return getPersistence().filterCountByC_T(companyId, type);
1766            }
1767    
1768            /**
1769            * Returns the number of roles that the user has permission to view where companyId = &#63; and type = any &#63;.
1770            *
1771            * @param companyId the company ID
1772            * @param types the types
1773            * @return the number of matching roles that the user has permission to view
1774            */
1775            public static int filterCountByC_T(long companyId, int[] types) {
1776                    return getPersistence().filterCountByC_T(companyId, types);
1777            }
1778    
1779            /**
1780            * Returns all the roles where type = &#63; and subtype = &#63;.
1781            *
1782            * @param type the type
1783            * @param subtype the subtype
1784            * @return the matching roles
1785            */
1786            public static List<Role> findByT_S(int type, java.lang.String subtype) {
1787                    return getPersistence().findByT_S(type, subtype);
1788            }
1789    
1790            /**
1791            * Returns a range of all the roles where type = &#63; and subtype = &#63;.
1792            *
1793            * <p>
1794            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1795            * </p>
1796            *
1797            * @param type the type
1798            * @param subtype the subtype
1799            * @param start the lower bound of the range of roles
1800            * @param end the upper bound of the range of roles (not inclusive)
1801            * @return the range of matching roles
1802            */
1803            public static List<Role> findByT_S(int type, java.lang.String subtype,
1804                    int start, int end) {
1805                    return getPersistence().findByT_S(type, subtype, start, end);
1806            }
1807    
1808            /**
1809            * Returns an ordered range of all the roles where type = &#63; and subtype = &#63;.
1810            *
1811            * <p>
1812            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1813            * </p>
1814            *
1815            * @param type the type
1816            * @param subtype the subtype
1817            * @param start the lower bound of the range of roles
1818            * @param end the upper bound of the range of roles (not inclusive)
1819            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1820            * @return the ordered range of matching roles
1821            */
1822            public static List<Role> findByT_S(int type, java.lang.String subtype,
1823                    int start, int end, OrderByComparator<Role> orderByComparator) {
1824                    return getPersistence()
1825                                       .findByT_S(type, subtype, start, end, orderByComparator);
1826            }
1827    
1828            /**
1829            * Returns the first role in the ordered set where type = &#63; and subtype = &#63;.
1830            *
1831            * @param type the type
1832            * @param subtype the subtype
1833            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1834            * @return the first matching role
1835            * @throws NoSuchRoleException if a matching role could not be found
1836            */
1837            public static Role findByT_S_First(int type, java.lang.String subtype,
1838                    OrderByComparator<Role> orderByComparator)
1839                    throws com.liferay.portal.NoSuchRoleException {
1840                    return getPersistence().findByT_S_First(type, subtype, orderByComparator);
1841            }
1842    
1843            /**
1844            * Returns the first role in the ordered set where type = &#63; and subtype = &#63;.
1845            *
1846            * @param type the type
1847            * @param subtype the subtype
1848            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1849            * @return the first matching role, or <code>null</code> if a matching role could not be found
1850            */
1851            public static Role fetchByT_S_First(int type, java.lang.String subtype,
1852                    OrderByComparator<Role> orderByComparator) {
1853                    return getPersistence()
1854                                       .fetchByT_S_First(type, subtype, orderByComparator);
1855            }
1856    
1857            /**
1858            * Returns the last role in the ordered set where type = &#63; and subtype = &#63;.
1859            *
1860            * @param type the type
1861            * @param subtype the subtype
1862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1863            * @return the last matching role
1864            * @throws NoSuchRoleException if a matching role could not be found
1865            */
1866            public static Role findByT_S_Last(int type, java.lang.String subtype,
1867                    OrderByComparator<Role> orderByComparator)
1868                    throws com.liferay.portal.NoSuchRoleException {
1869                    return getPersistence().findByT_S_Last(type, subtype, orderByComparator);
1870            }
1871    
1872            /**
1873            * Returns the last role in the ordered set where type = &#63; and subtype = &#63;.
1874            *
1875            * @param type the type
1876            * @param subtype the subtype
1877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1878            * @return the last matching role, or <code>null</code> if a matching role could not be found
1879            */
1880            public static Role fetchByT_S_Last(int type, java.lang.String subtype,
1881                    OrderByComparator<Role> orderByComparator) {
1882                    return getPersistence().fetchByT_S_Last(type, subtype, orderByComparator);
1883            }
1884    
1885            /**
1886            * Returns the roles before and after the current role in the ordered set where type = &#63; and subtype = &#63;.
1887            *
1888            * @param roleId the primary key of the current role
1889            * @param type the type
1890            * @param subtype the subtype
1891            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1892            * @return the previous, current, and next role
1893            * @throws NoSuchRoleException if a role with the primary key could not be found
1894            */
1895            public static Role[] findByT_S_PrevAndNext(long roleId, int type,
1896                    java.lang.String subtype, OrderByComparator<Role> orderByComparator)
1897                    throws com.liferay.portal.NoSuchRoleException {
1898                    return getPersistence()
1899                                       .findByT_S_PrevAndNext(roleId, type, subtype,
1900                            orderByComparator);
1901            }
1902    
1903            /**
1904            * Returns all the roles that the user has permission to view where type = &#63; and subtype = &#63;.
1905            *
1906            * @param type the type
1907            * @param subtype the subtype
1908            * @return the matching roles that the user has permission to view
1909            */
1910            public static List<Role> filterFindByT_S(int type, java.lang.String subtype) {
1911                    return getPersistence().filterFindByT_S(type, subtype);
1912            }
1913    
1914            /**
1915            * Returns a range of all the roles that the user has permission to view where type = &#63; and subtype = &#63;.
1916            *
1917            * <p>
1918            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1919            * </p>
1920            *
1921            * @param type the type
1922            * @param subtype the subtype
1923            * @param start the lower bound of the range of roles
1924            * @param end the upper bound of the range of roles (not inclusive)
1925            * @return the range of matching roles that the user has permission to view
1926            */
1927            public static List<Role> filterFindByT_S(int type,
1928                    java.lang.String subtype, int start, int end) {
1929                    return getPersistence().filterFindByT_S(type, subtype, start, end);
1930            }
1931    
1932            /**
1933            * Returns an ordered range of all the roles that the user has permissions to view where type = &#63; and subtype = &#63;.
1934            *
1935            * <p>
1936            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
1937            * </p>
1938            *
1939            * @param type the type
1940            * @param subtype the subtype
1941            * @param start the lower bound of the range of roles
1942            * @param end the upper bound of the range of roles (not inclusive)
1943            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1944            * @return the ordered range of matching roles that the user has permission to view
1945            */
1946            public static List<Role> filterFindByT_S(int type,
1947                    java.lang.String subtype, int start, int end,
1948                    OrderByComparator<Role> orderByComparator) {
1949                    return getPersistence()
1950                                       .filterFindByT_S(type, subtype, start, end, orderByComparator);
1951            }
1952    
1953            /**
1954            * Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where type = &#63; and subtype = &#63;.
1955            *
1956            * @param roleId the primary key of the current role
1957            * @param type the type
1958            * @param subtype the subtype
1959            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1960            * @return the previous, current, and next role
1961            * @throws NoSuchRoleException if a role with the primary key could not be found
1962            */
1963            public static Role[] filterFindByT_S_PrevAndNext(long roleId, int type,
1964                    java.lang.String subtype, OrderByComparator<Role> orderByComparator)
1965                    throws com.liferay.portal.NoSuchRoleException {
1966                    return getPersistence()
1967                                       .filterFindByT_S_PrevAndNext(roleId, type, subtype,
1968                            orderByComparator);
1969            }
1970    
1971            /**
1972            * Removes all the roles where type = &#63; and subtype = &#63; from the database.
1973            *
1974            * @param type the type
1975            * @param subtype the subtype
1976            */
1977            public static void removeByT_S(int type, java.lang.String subtype) {
1978                    getPersistence().removeByT_S(type, subtype);
1979            }
1980    
1981            /**
1982            * Returns the number of roles where type = &#63; and subtype = &#63;.
1983            *
1984            * @param type the type
1985            * @param subtype the subtype
1986            * @return the number of matching roles
1987            */
1988            public static int countByT_S(int type, java.lang.String subtype) {
1989                    return getPersistence().countByT_S(type, subtype);
1990            }
1991    
1992            /**
1993            * Returns the number of roles that the user has permission to view where type = &#63; and subtype = &#63;.
1994            *
1995            * @param type the type
1996            * @param subtype the subtype
1997            * @return the number of matching roles that the user has permission to view
1998            */
1999            public static int filterCountByT_S(int type, java.lang.String subtype) {
2000                    return getPersistence().filterCountByT_S(type, subtype);
2001            }
2002    
2003            /**
2004            * Returns the role where companyId = &#63; and classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchRoleException} if it could not be found.
2005            *
2006            * @param companyId the company ID
2007            * @param classNameId the class name ID
2008            * @param classPK the class p k
2009            * @return the matching role
2010            * @throws NoSuchRoleException if a matching role could not be found
2011            */
2012            public static Role findByC_C_C(long companyId, long classNameId,
2013                    long classPK) throws com.liferay.portal.NoSuchRoleException {
2014                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
2015            }
2016    
2017            /**
2018            * Returns the role where companyId = &#63; and classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2019            *
2020            * @param companyId the company ID
2021            * @param classNameId the class name ID
2022            * @param classPK the class p k
2023            * @return the matching role, or <code>null</code> if a matching role could not be found
2024            */
2025            public static Role fetchByC_C_C(long companyId, long classNameId,
2026                    long classPK) {
2027                    return getPersistence().fetchByC_C_C(companyId, classNameId, classPK);
2028            }
2029    
2030            /**
2031            * Returns the role 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.
2032            *
2033            * @param companyId the company ID
2034            * @param classNameId the class name ID
2035            * @param classPK the class p k
2036            * @param retrieveFromCache whether to use the finder cache
2037            * @return the matching role, or <code>null</code> if a matching role could not be found
2038            */
2039            public static Role fetchByC_C_C(long companyId, long classNameId,
2040                    long classPK, boolean retrieveFromCache) {
2041                    return getPersistence()
2042                                       .fetchByC_C_C(companyId, classNameId, classPK,
2043                            retrieveFromCache);
2044            }
2045    
2046            /**
2047            * Removes the role where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
2048            *
2049            * @param companyId the company ID
2050            * @param classNameId the class name ID
2051            * @param classPK the class p k
2052            * @return the role that was removed
2053            */
2054            public static Role removeByC_C_C(long companyId, long classNameId,
2055                    long classPK) throws com.liferay.portal.NoSuchRoleException {
2056                    return getPersistence().removeByC_C_C(companyId, classNameId, classPK);
2057            }
2058    
2059            /**
2060            * Returns the number of roles where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
2061            *
2062            * @param companyId the company ID
2063            * @param classNameId the class name ID
2064            * @param classPK the class p k
2065            * @return the number of matching roles
2066            */
2067            public static int countByC_C_C(long companyId, long classNameId,
2068                    long classPK) {
2069                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
2070            }
2071    
2072            /**
2073            * Caches the role in the entity cache if it is enabled.
2074            *
2075            * @param role the role
2076            */
2077            public static void cacheResult(Role role) {
2078                    getPersistence().cacheResult(role);
2079            }
2080    
2081            /**
2082            * Caches the roles in the entity cache if it is enabled.
2083            *
2084            * @param roles the roles
2085            */
2086            public static void cacheResult(List<Role> roles) {
2087                    getPersistence().cacheResult(roles);
2088            }
2089    
2090            /**
2091            * Creates a new role with the primary key. Does not add the role to the database.
2092            *
2093            * @param roleId the primary key for the new role
2094            * @return the new role
2095            */
2096            public static Role create(long roleId) {
2097                    return getPersistence().create(roleId);
2098            }
2099    
2100            /**
2101            * Removes the role with the primary key from the database. Also notifies the appropriate model listeners.
2102            *
2103            * @param roleId the primary key of the role
2104            * @return the role that was removed
2105            * @throws NoSuchRoleException if a role with the primary key could not be found
2106            */
2107            public static Role remove(long roleId)
2108                    throws com.liferay.portal.NoSuchRoleException {
2109                    return getPersistence().remove(roleId);
2110            }
2111    
2112            public static Role updateImpl(Role role) {
2113                    return getPersistence().updateImpl(role);
2114            }
2115    
2116            /**
2117            * Returns the role with the primary key or throws a {@link NoSuchRoleException} if it could not be found.
2118            *
2119            * @param roleId the primary key of the role
2120            * @return the role
2121            * @throws NoSuchRoleException if a role with the primary key could not be found
2122            */
2123            public static Role findByPrimaryKey(long roleId)
2124                    throws com.liferay.portal.NoSuchRoleException {
2125                    return getPersistence().findByPrimaryKey(roleId);
2126            }
2127    
2128            /**
2129            * Returns the role with the primary key or returns <code>null</code> if it could not be found.
2130            *
2131            * @param roleId the primary key of the role
2132            * @return the role, or <code>null</code> if a role with the primary key could not be found
2133            */
2134            public static Role fetchByPrimaryKey(long roleId) {
2135                    return getPersistence().fetchByPrimaryKey(roleId);
2136            }
2137    
2138            public static java.util.Map<java.io.Serializable, Role> fetchByPrimaryKeys(
2139                    java.util.Set<java.io.Serializable> primaryKeys) {
2140                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2141            }
2142    
2143            /**
2144            * Returns all the roles.
2145            *
2146            * @return the roles
2147            */
2148            public static List<Role> findAll() {
2149                    return getPersistence().findAll();
2150            }
2151    
2152            /**
2153            * Returns a range of all the roles.
2154            *
2155            * <p>
2156            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2157            * </p>
2158            *
2159            * @param start the lower bound of the range of roles
2160            * @param end the upper bound of the range of roles (not inclusive)
2161            * @return the range of roles
2162            */
2163            public static List<Role> findAll(int start, int end) {
2164                    return getPersistence().findAll(start, end);
2165            }
2166    
2167            /**
2168            * Returns an ordered range of all the roles.
2169            *
2170            * <p>
2171            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2172            * </p>
2173            *
2174            * @param start the lower bound of the range of roles
2175            * @param end the upper bound of the range of roles (not inclusive)
2176            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2177            * @return the ordered range of roles
2178            */
2179            public static List<Role> findAll(int start, int end,
2180                    OrderByComparator<Role> orderByComparator) {
2181                    return getPersistence().findAll(start, end, orderByComparator);
2182            }
2183    
2184            /**
2185            * Removes all the roles from the database.
2186            */
2187            public static void removeAll() {
2188                    getPersistence().removeAll();
2189            }
2190    
2191            /**
2192            * Returns the number of roles.
2193            *
2194            * @return the number of roles
2195            */
2196            public static int countAll() {
2197                    return getPersistence().countAll();
2198            }
2199    
2200            /**
2201            * Returns the primaryKeys of groups associated with the role.
2202            *
2203            * @param pk the primary key of the role
2204            * @return long[] of the primaryKeys of groups associated with the role
2205            */
2206            public static long[] getGroupPrimaryKeys(long pk) {
2207                    return getPersistence().getGroupPrimaryKeys(pk);
2208            }
2209    
2210            /**
2211            * Returns all the groups associated with the role.
2212            *
2213            * @param pk the primary key of the role
2214            * @return the groups associated with the role
2215            */
2216            public static List<com.liferay.portal.model.Group> getGroups(long pk) {
2217                    return getPersistence().getGroups(pk);
2218            }
2219    
2220            /**
2221            * Returns a range of all the groups associated with the role.
2222            *
2223            * <p>
2224            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2225            * </p>
2226            *
2227            * @param pk the primary key of the role
2228            * @param start the lower bound of the range of roles
2229            * @param end the upper bound of the range of roles (not inclusive)
2230            * @return the range of groups associated with the role
2231            */
2232            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2233                    int start, int end) {
2234                    return getPersistence().getGroups(pk, start, end);
2235            }
2236    
2237            /**
2238            * Returns an ordered range of all the groups associated with the role.
2239            *
2240            * <p>
2241            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2242            * </p>
2243            *
2244            * @param pk the primary key of the role
2245            * @param start the lower bound of the range of roles
2246            * @param end the upper bound of the range of roles (not inclusive)
2247            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2248            * @return the ordered range of groups associated with the role
2249            */
2250            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2251                    int start, int end,
2252                    OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
2253                    return getPersistence().getGroups(pk, start, end, orderByComparator);
2254            }
2255    
2256            /**
2257            * Returns the number of groups associated with the role.
2258            *
2259            * @param pk the primary key of the role
2260            * @return the number of groups associated with the role
2261            */
2262            public static int getGroupsSize(long pk) {
2263                    return getPersistence().getGroupsSize(pk);
2264            }
2265    
2266            /**
2267            * Returns <code>true</code> if the group is associated with the role.
2268            *
2269            * @param pk the primary key of the role
2270            * @param groupPK the primary key of the group
2271            * @return <code>true</code> if the group is associated with the role; <code>false</code> otherwise
2272            */
2273            public static boolean containsGroup(long pk, long groupPK) {
2274                    return getPersistence().containsGroup(pk, groupPK);
2275            }
2276    
2277            /**
2278            * Returns <code>true</code> if the role has any groups associated with it.
2279            *
2280            * @param pk the primary key of the role to check for associations with groups
2281            * @return <code>true</code> if the role has any groups associated with it; <code>false</code> otherwise
2282            */
2283            public static boolean containsGroups(long pk) {
2284                    return getPersistence().containsGroups(pk);
2285            }
2286    
2287            /**
2288            * Adds an association between the role and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2289            *
2290            * @param pk the primary key of the role
2291            * @param groupPK the primary key of the group
2292            */
2293            public static void addGroup(long pk, long groupPK) {
2294                    getPersistence().addGroup(pk, groupPK);
2295            }
2296    
2297            /**
2298            * Adds an association between the role and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2299            *
2300            * @param pk the primary key of the role
2301            * @param group the group
2302            */
2303            public static void addGroup(long pk, com.liferay.portal.model.Group group) {
2304                    getPersistence().addGroup(pk, group);
2305            }
2306    
2307            /**
2308            * Adds an association between the role and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2309            *
2310            * @param pk the primary key of the role
2311            * @param groupPKs the primary keys of the groups
2312            */
2313            public static void addGroups(long pk, long[] groupPKs) {
2314                    getPersistence().addGroups(pk, groupPKs);
2315            }
2316    
2317            /**
2318            * Adds an association between the role and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2319            *
2320            * @param pk the primary key of the role
2321            * @param groups the groups
2322            */
2323            public static void addGroups(long pk,
2324                    List<com.liferay.portal.model.Group> groups) {
2325                    getPersistence().addGroups(pk, groups);
2326            }
2327    
2328            /**
2329            * Clears all associations between the role and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2330            *
2331            * @param pk the primary key of the role to clear the associated groups from
2332            */
2333            public static void clearGroups(long pk) {
2334                    getPersistence().clearGroups(pk);
2335            }
2336    
2337            /**
2338            * Removes the association between the role and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2339            *
2340            * @param pk the primary key of the role
2341            * @param groupPK the primary key of the group
2342            */
2343            public static void removeGroup(long pk, long groupPK) {
2344                    getPersistence().removeGroup(pk, groupPK);
2345            }
2346    
2347            /**
2348            * Removes the association between the role and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2349            *
2350            * @param pk the primary key of the role
2351            * @param group the group
2352            */
2353            public static void removeGroup(long pk, com.liferay.portal.model.Group group) {
2354                    getPersistence().removeGroup(pk, group);
2355            }
2356    
2357            /**
2358            * Removes the association between the role and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2359            *
2360            * @param pk the primary key of the role
2361            * @param groupPKs the primary keys of the groups
2362            */
2363            public static void removeGroups(long pk, long[] groupPKs) {
2364                    getPersistence().removeGroups(pk, groupPKs);
2365            }
2366    
2367            /**
2368            * Removes the association between the role and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2369            *
2370            * @param pk the primary key of the role
2371            * @param groups the groups
2372            */
2373            public static void removeGroups(long pk,
2374                    List<com.liferay.portal.model.Group> groups) {
2375                    getPersistence().removeGroups(pk, groups);
2376            }
2377    
2378            /**
2379            * Sets the groups associated with the role, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2380            *
2381            * @param pk the primary key of the role
2382            * @param groupPKs the primary keys of the groups to be associated with the role
2383            */
2384            public static void setGroups(long pk, long[] groupPKs) {
2385                    getPersistence().setGroups(pk, groupPKs);
2386            }
2387    
2388            /**
2389            * Sets the groups associated with the role, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2390            *
2391            * @param pk the primary key of the role
2392            * @param groups the groups to be associated with the role
2393            */
2394            public static void setGroups(long pk,
2395                    List<com.liferay.portal.model.Group> groups) {
2396                    getPersistence().setGroups(pk, groups);
2397            }
2398    
2399            /**
2400            * Returns the primaryKeys of users associated with the role.
2401            *
2402            * @param pk the primary key of the role
2403            * @return long[] of the primaryKeys of users associated with the role
2404            */
2405            public static long[] getUserPrimaryKeys(long pk) {
2406                    return getPersistence().getUserPrimaryKeys(pk);
2407            }
2408    
2409            /**
2410            * Returns all the users associated with the role.
2411            *
2412            * @param pk the primary key of the role
2413            * @return the users associated with the role
2414            */
2415            public static List<com.liferay.portal.model.User> getUsers(long pk) {
2416                    return getPersistence().getUsers(pk);
2417            }
2418    
2419            /**
2420            * Returns a range of all the users associated with the role.
2421            *
2422            * <p>
2423            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2424            * </p>
2425            *
2426            * @param pk the primary key of the role
2427            * @param start the lower bound of the range of roles
2428            * @param end the upper bound of the range of roles (not inclusive)
2429            * @return the range of users associated with the role
2430            */
2431            public static List<com.liferay.portal.model.User> getUsers(long pk,
2432                    int start, int end) {
2433                    return getPersistence().getUsers(pk, start, end);
2434            }
2435    
2436            /**
2437            * Returns an ordered range of all the users associated with the role.
2438            *
2439            * <p>
2440            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RoleModelImpl}. 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.
2441            * </p>
2442            *
2443            * @param pk the primary key of the role
2444            * @param start the lower bound of the range of roles
2445            * @param end the upper bound of the range of roles (not inclusive)
2446            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2447            * @return the ordered range of users associated with the role
2448            */
2449            public static List<com.liferay.portal.model.User> getUsers(long pk,
2450                    int start, int end,
2451                    OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
2452                    return getPersistence().getUsers(pk, start, end, orderByComparator);
2453            }
2454    
2455            /**
2456            * Returns the number of users associated with the role.
2457            *
2458            * @param pk the primary key of the role
2459            * @return the number of users associated with the role
2460            */
2461            public static int getUsersSize(long pk) {
2462                    return getPersistence().getUsersSize(pk);
2463            }
2464    
2465            /**
2466            * Returns <code>true</code> if the user is associated with the role.
2467            *
2468            * @param pk the primary key of the role
2469            * @param userPK the primary key of the user
2470            * @return <code>true</code> if the user is associated with the role; <code>false</code> otherwise
2471            */
2472            public static boolean containsUser(long pk, long userPK) {
2473                    return getPersistence().containsUser(pk, userPK);
2474            }
2475    
2476            /**
2477            * Returns <code>true</code> if the role has any users associated with it.
2478            *
2479            * @param pk the primary key of the role to check for associations with users
2480            * @return <code>true</code> if the role has any users associated with it; <code>false</code> otherwise
2481            */
2482            public static boolean containsUsers(long pk) {
2483                    return getPersistence().containsUsers(pk);
2484            }
2485    
2486            /**
2487            * Adds an association between the role and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2488            *
2489            * @param pk the primary key of the role
2490            * @param userPK the primary key of the user
2491            */
2492            public static void addUser(long pk, long userPK) {
2493                    getPersistence().addUser(pk, userPK);
2494            }
2495    
2496            /**
2497            * Adds an association between the role and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2498            *
2499            * @param pk the primary key of the role
2500            * @param user the user
2501            */
2502            public static void addUser(long pk, com.liferay.portal.model.User user) {
2503                    getPersistence().addUser(pk, user);
2504            }
2505    
2506            /**
2507            * Adds an association between the role and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2508            *
2509            * @param pk the primary key of the role
2510            * @param userPKs the primary keys of the users
2511            */
2512            public static void addUsers(long pk, long[] userPKs) {
2513                    getPersistence().addUsers(pk, userPKs);
2514            }
2515    
2516            /**
2517            * Adds an association between the role and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2518            *
2519            * @param pk the primary key of the role
2520            * @param users the users
2521            */
2522            public static void addUsers(long pk,
2523                    List<com.liferay.portal.model.User> users) {
2524                    getPersistence().addUsers(pk, users);
2525            }
2526    
2527            /**
2528            * Clears all associations between the role and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2529            *
2530            * @param pk the primary key of the role to clear the associated users from
2531            */
2532            public static void clearUsers(long pk) {
2533                    getPersistence().clearUsers(pk);
2534            }
2535    
2536            /**
2537            * Removes the association between the role and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2538            *
2539            * @param pk the primary key of the role
2540            * @param userPK the primary key of the user
2541            */
2542            public static void removeUser(long pk, long userPK) {
2543                    getPersistence().removeUser(pk, userPK);
2544            }
2545    
2546            /**
2547            * Removes the association between the role and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2548            *
2549            * @param pk the primary key of the role
2550            * @param user the user
2551            */
2552            public static void removeUser(long pk, com.liferay.portal.model.User user) {
2553                    getPersistence().removeUser(pk, user);
2554            }
2555    
2556            /**
2557            * Removes the association between the role and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2558            *
2559            * @param pk the primary key of the role
2560            * @param userPKs the primary keys of the users
2561            */
2562            public static void removeUsers(long pk, long[] userPKs) {
2563                    getPersistence().removeUsers(pk, userPKs);
2564            }
2565    
2566            /**
2567            * Removes the association between the role and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2568            *
2569            * @param pk the primary key of the role
2570            * @param users the users
2571            */
2572            public static void removeUsers(long pk,
2573                    List<com.liferay.portal.model.User> users) {
2574                    getPersistence().removeUsers(pk, users);
2575            }
2576    
2577            /**
2578            * Sets the users associated with the role, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2579            *
2580            * @param pk the primary key of the role
2581            * @param userPKs the primary keys of the users to be associated with the role
2582            */
2583            public static void setUsers(long pk, long[] userPKs) {
2584                    getPersistence().setUsers(pk, userPKs);
2585            }
2586    
2587            /**
2588            * Sets the users associated with the role, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2589            *
2590            * @param pk the primary key of the role
2591            * @param users the users to be associated with the role
2592            */
2593            public static void setUsers(long pk,
2594                    List<com.liferay.portal.model.User> users) {
2595                    getPersistence().setUsers(pk, users);
2596            }
2597    
2598            public static RolePersistence getPersistence() {
2599                    if (_persistence == null) {
2600                            _persistence = (RolePersistence)PortalBeanLocatorUtil.locate(RolePersistence.class.getName());
2601    
2602                            ReferenceRegistry.registerReference(RoleUtil.class, "_persistence");
2603                    }
2604    
2605                    return _persistence;
2606            }
2607    
2608            /**
2609             * @deprecated As of 6.2.0
2610             */
2611            @Deprecated
2612            public void setPersistence(RolePersistence persistence) {
2613            }
2614    
2615            private static RolePersistence _persistence;
2616    }