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