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