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