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