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