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