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