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