001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.PasswordPolicy; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the password policy service. This utility wraps {@link PasswordPolicyPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see PasswordPolicyPersistence 037 * @see PasswordPolicyPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class PasswordPolicyUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(PasswordPolicy passwordPolicy) { 059 getPersistence().clearCache(passwordPolicy); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<PasswordPolicy> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<PasswordPolicy> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<PasswordPolicy> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<PasswordPolicy> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static PasswordPolicy update(PasswordPolicy passwordPolicy) { 100 return getPersistence().update(passwordPolicy); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static PasswordPolicy update(PasswordPolicy passwordPolicy, 107 ServiceContext serviceContext) { 108 return getPersistence().update(passwordPolicy, serviceContext); 109 } 110 111 /** 112 * Returns all the password policies where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching password policies 116 */ 117 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 118 java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the password policies where uuid = ?. 124 * 125 * <p> 126 * 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.PasswordPolicyModelImpl}. 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. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of password policies 131 * @param end the upper bound of the range of password policies (not inclusive) 132 * @return the range of matching password policies 133 */ 134 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 135 java.lang.String uuid, int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the password policies where uuid = ?. 141 * 142 * <p> 143 * 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.PasswordPolicyModelImpl}. 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. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of password policies 148 * @param end the upper bound of the range of password policies (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching password policies 151 */ 152 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid( 153 java.lang.String uuid, int start, int end, 154 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 155 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns the first password policy in the ordered set where uuid = ?. 160 * 161 * @param uuid the uuid 162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 163 * @return the first matching password policy 164 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 165 */ 166 public static com.liferay.portal.model.PasswordPolicy findByUuid_First( 167 java.lang.String uuid, 168 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 169 throws com.liferay.portal.NoSuchPasswordPolicyException { 170 return getPersistence().findByUuid_First(uuid, orderByComparator); 171 } 172 173 /** 174 * Returns the first password policy in the ordered set where uuid = ?. 175 * 176 * @param uuid the uuid 177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 178 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 179 */ 180 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_First( 181 java.lang.String uuid, 182 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 183 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 184 } 185 186 /** 187 * Returns the last password policy in the ordered set where uuid = ?. 188 * 189 * @param uuid the uuid 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the last matching password policy 192 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 193 */ 194 public static com.liferay.portal.model.PasswordPolicy findByUuid_Last( 195 java.lang.String uuid, 196 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 197 throws com.liferay.portal.NoSuchPasswordPolicyException { 198 return getPersistence().findByUuid_Last(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last password policy in the ordered set where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 207 */ 208 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_Last( 209 java.lang.String uuid, 210 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 211 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 212 } 213 214 /** 215 * Returns the password policies before and after the current password policy in the ordered set where uuid = ?. 216 * 217 * @param passwordPolicyId the primary key of the current password policy 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the previous, current, and next password policy 221 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 222 */ 223 public static com.liferay.portal.model.PasswordPolicy[] findByUuid_PrevAndNext( 224 long passwordPolicyId, java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 226 throws com.liferay.portal.NoSuchPasswordPolicyException { 227 return getPersistence() 228 .findByUuid_PrevAndNext(passwordPolicyId, uuid, 229 orderByComparator); 230 } 231 232 /** 233 * Returns all the password policies that the user has permission to view where uuid = ?. 234 * 235 * @param uuid the uuid 236 * @return the matching password policies that the user has permission to view 237 */ 238 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 239 java.lang.String uuid) { 240 return getPersistence().filterFindByUuid(uuid); 241 } 242 243 /** 244 * Returns a range of all the password policies that the user has permission to view where uuid = ?. 245 * 246 * <p> 247 * 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.PasswordPolicyModelImpl}. 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. 248 * </p> 249 * 250 * @param uuid the uuid 251 * @param start the lower bound of the range of password policies 252 * @param end the upper bound of the range of password policies (not inclusive) 253 * @return the range of matching password policies that the user has permission to view 254 */ 255 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 256 java.lang.String uuid, int start, int end) { 257 return getPersistence().filterFindByUuid(uuid, start, end); 258 } 259 260 /** 261 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ?. 262 * 263 * <p> 264 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 265 * </p> 266 * 267 * @param uuid the uuid 268 * @param start the lower bound of the range of password policies 269 * @param end the upper bound of the range of password policies (not inclusive) 270 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 271 * @return the ordered range of matching password policies that the user has permission to view 272 */ 273 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid( 274 java.lang.String uuid, int start, int end, 275 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 276 return getPersistence() 277 .filterFindByUuid(uuid, start, end, orderByComparator); 278 } 279 280 /** 281 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where uuid = ?. 282 * 283 * @param passwordPolicyId the primary key of the current password policy 284 * @param uuid the uuid 285 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 286 * @return the previous, current, and next password policy 287 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 288 */ 289 public static com.liferay.portal.model.PasswordPolicy[] filterFindByUuid_PrevAndNext( 290 long passwordPolicyId, java.lang.String uuid, 291 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 292 throws com.liferay.portal.NoSuchPasswordPolicyException { 293 return getPersistence() 294 .filterFindByUuid_PrevAndNext(passwordPolicyId, uuid, 295 orderByComparator); 296 } 297 298 /** 299 * Removes all the password policies where uuid = ? from the database. 300 * 301 * @param uuid the uuid 302 */ 303 public static void removeByUuid(java.lang.String uuid) { 304 getPersistence().removeByUuid(uuid); 305 } 306 307 /** 308 * Returns the number of password policies where uuid = ?. 309 * 310 * @param uuid the uuid 311 * @return the number of matching password policies 312 */ 313 public static int countByUuid(java.lang.String uuid) { 314 return getPersistence().countByUuid(uuid); 315 } 316 317 /** 318 * Returns the number of password policies that the user has permission to view where uuid = ?. 319 * 320 * @param uuid the uuid 321 * @return the number of matching password policies that the user has permission to view 322 */ 323 public static int filterCountByUuid(java.lang.String uuid) { 324 return getPersistence().filterCountByUuid(uuid); 325 } 326 327 /** 328 * Returns all the password policies where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @return the matching password policies 333 */ 334 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 335 java.lang.String uuid, long companyId) { 336 return getPersistence().findByUuid_C(uuid, companyId); 337 } 338 339 /** 340 * Returns a range of all the password policies where uuid = ? and companyId = ?. 341 * 342 * <p> 343 * 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.PasswordPolicyModelImpl}. 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. 344 * </p> 345 * 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param start the lower bound of the range of password policies 349 * @param end the upper bound of the range of password policies (not inclusive) 350 * @return the range of matching password policies 351 */ 352 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 353 java.lang.String uuid, long companyId, int start, int end) { 354 return getPersistence().findByUuid_C(uuid, companyId, start, end); 355 } 356 357 /** 358 * Returns an ordered range of all the password policies where uuid = ? and companyId = ?. 359 * 360 * <p> 361 * 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.PasswordPolicyModelImpl}. 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. 362 * </p> 363 * 364 * @param uuid the uuid 365 * @param companyId the company ID 366 * @param start the lower bound of the range of password policies 367 * @param end the upper bound of the range of password policies (not inclusive) 368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 369 * @return the ordered range of matching password policies 370 */ 371 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByUuid_C( 372 java.lang.String uuid, long companyId, int start, int end, 373 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 374 return getPersistence() 375 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 376 } 377 378 /** 379 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 380 * 381 * @param uuid the uuid 382 * @param companyId the company ID 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 384 * @return the first matching password policy 385 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 386 */ 387 public static com.liferay.portal.model.PasswordPolicy findByUuid_C_First( 388 java.lang.String uuid, long companyId, 389 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 390 throws com.liferay.portal.NoSuchPasswordPolicyException { 391 return getPersistence() 392 .findByUuid_C_First(uuid, companyId, orderByComparator); 393 } 394 395 /** 396 * Returns the first password policy in the ordered set where uuid = ? and companyId = ?. 397 * 398 * @param uuid the uuid 399 * @param companyId the company ID 400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 401 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 402 */ 403 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_C_First( 404 java.lang.String uuid, long companyId, 405 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 406 return getPersistence() 407 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 408 } 409 410 /** 411 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 412 * 413 * @param uuid the uuid 414 * @param companyId the company ID 415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 416 * @return the last matching password policy 417 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 418 */ 419 public static com.liferay.portal.model.PasswordPolicy findByUuid_C_Last( 420 java.lang.String uuid, long companyId, 421 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 422 throws com.liferay.portal.NoSuchPasswordPolicyException { 423 return getPersistence() 424 .findByUuid_C_Last(uuid, companyId, orderByComparator); 425 } 426 427 /** 428 * Returns the last password policy in the ordered set where uuid = ? and companyId = ?. 429 * 430 * @param uuid the uuid 431 * @param companyId the company ID 432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 433 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 434 */ 435 public static com.liferay.portal.model.PasswordPolicy fetchByUuid_C_Last( 436 java.lang.String uuid, long companyId, 437 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 438 return getPersistence() 439 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 440 } 441 442 /** 443 * Returns the password policies before and after the current password policy in the ordered set where uuid = ? and companyId = ?. 444 * 445 * @param passwordPolicyId the primary key of the current password policy 446 * @param uuid the uuid 447 * @param companyId the company ID 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the previous, current, and next password policy 450 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 451 */ 452 public static com.liferay.portal.model.PasswordPolicy[] findByUuid_C_PrevAndNext( 453 long passwordPolicyId, java.lang.String uuid, long companyId, 454 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 455 throws com.liferay.portal.NoSuchPasswordPolicyException { 456 return getPersistence() 457 .findByUuid_C_PrevAndNext(passwordPolicyId, uuid, companyId, 458 orderByComparator); 459 } 460 461 /** 462 * Returns all the password policies that the user has permission to view where uuid = ? and companyId = ?. 463 * 464 * @param uuid the uuid 465 * @param companyId the company ID 466 * @return the matching password policies that the user has permission to view 467 */ 468 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 469 java.lang.String uuid, long companyId) { 470 return getPersistence().filterFindByUuid_C(uuid, companyId); 471 } 472 473 /** 474 * Returns a range of all the password policies that the user has permission to view where uuid = ? and companyId = ?. 475 * 476 * <p> 477 * 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.PasswordPolicyModelImpl}. 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. 478 * </p> 479 * 480 * @param uuid the uuid 481 * @param companyId the company ID 482 * @param start the lower bound of the range of password policies 483 * @param end the upper bound of the range of password policies (not inclusive) 484 * @return the range of matching password policies that the user has permission to view 485 */ 486 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 487 java.lang.String uuid, long companyId, int start, int end) { 488 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 489 } 490 491 /** 492 * Returns an ordered range of all the password policies that the user has permissions to view where uuid = ? and companyId = ?. 493 * 494 * <p> 495 * 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.PasswordPolicyModelImpl}. 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. 496 * </p> 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @param start the lower bound of the range of password policies 501 * @param end the upper bound of the range of password policies (not inclusive) 502 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 503 * @return the ordered range of matching password policies that the user has permission to view 504 */ 505 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByUuid_C( 506 java.lang.String uuid, long companyId, int start, int end, 507 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 508 return getPersistence() 509 .filterFindByUuid_C(uuid, companyId, start, end, 510 orderByComparator); 511 } 512 513 /** 514 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where uuid = ? and companyId = ?. 515 * 516 * @param passwordPolicyId the primary key of the current password policy 517 * @param uuid the uuid 518 * @param companyId the company ID 519 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 520 * @return the previous, current, and next password policy 521 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 522 */ 523 public static com.liferay.portal.model.PasswordPolicy[] filterFindByUuid_C_PrevAndNext( 524 long passwordPolicyId, java.lang.String uuid, long companyId, 525 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 526 throws com.liferay.portal.NoSuchPasswordPolicyException { 527 return getPersistence() 528 .filterFindByUuid_C_PrevAndNext(passwordPolicyId, uuid, 529 companyId, orderByComparator); 530 } 531 532 /** 533 * Removes all the password policies where uuid = ? and companyId = ? from the database. 534 * 535 * @param uuid the uuid 536 * @param companyId the company ID 537 */ 538 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 539 getPersistence().removeByUuid_C(uuid, companyId); 540 } 541 542 /** 543 * Returns the number of password policies where uuid = ? and companyId = ?. 544 * 545 * @param uuid the uuid 546 * @param companyId the company ID 547 * @return the number of matching password policies 548 */ 549 public static int countByUuid_C(java.lang.String uuid, long companyId) { 550 return getPersistence().countByUuid_C(uuid, companyId); 551 } 552 553 /** 554 * Returns the number of password policies that the user has permission to view where uuid = ? and companyId = ?. 555 * 556 * @param uuid the uuid 557 * @param companyId the company ID 558 * @return the number of matching password policies that the user has permission to view 559 */ 560 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) { 561 return getPersistence().filterCountByUuid_C(uuid, companyId); 562 } 563 564 /** 565 * Returns all the password policies where companyId = ?. 566 * 567 * @param companyId the company ID 568 * @return the matching password policies 569 */ 570 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 571 long companyId) { 572 return getPersistence().findByCompanyId(companyId); 573 } 574 575 /** 576 * Returns a range of all the password policies where companyId = ?. 577 * 578 * <p> 579 * 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.PasswordPolicyModelImpl}. 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. 580 * </p> 581 * 582 * @param companyId the company ID 583 * @param start the lower bound of the range of password policies 584 * @param end the upper bound of the range of password policies (not inclusive) 585 * @return the range of matching password policies 586 */ 587 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 588 long companyId, int start, int end) { 589 return getPersistence().findByCompanyId(companyId, start, end); 590 } 591 592 /** 593 * Returns an ordered range of all the password policies where companyId = ?. 594 * 595 * <p> 596 * 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.PasswordPolicyModelImpl}. 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. 597 * </p> 598 * 599 * @param companyId the company ID 600 * @param start the lower bound of the range of password policies 601 * @param end the upper bound of the range of password policies (not inclusive) 602 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 603 * @return the ordered range of matching password policies 604 */ 605 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findByCompanyId( 606 long companyId, int start, int end, 607 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 608 return getPersistence() 609 .findByCompanyId(companyId, start, end, orderByComparator); 610 } 611 612 /** 613 * Returns the first password policy in the ordered set where companyId = ?. 614 * 615 * @param companyId the company ID 616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 617 * @return the first matching password policy 618 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 619 */ 620 public static com.liferay.portal.model.PasswordPolicy findByCompanyId_First( 621 long companyId, 622 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 623 throws com.liferay.portal.NoSuchPasswordPolicyException { 624 return getPersistence() 625 .findByCompanyId_First(companyId, orderByComparator); 626 } 627 628 /** 629 * Returns the first password policy in the ordered set where companyId = ?. 630 * 631 * @param companyId the company ID 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found 634 */ 635 public static com.liferay.portal.model.PasswordPolicy fetchByCompanyId_First( 636 long companyId, 637 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 638 return getPersistence() 639 .fetchByCompanyId_First(companyId, orderByComparator); 640 } 641 642 /** 643 * Returns the last password policy in the ordered set where companyId = ?. 644 * 645 * @param companyId the company ID 646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 647 * @return the last matching password policy 648 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 649 */ 650 public static com.liferay.portal.model.PasswordPolicy findByCompanyId_Last( 651 long companyId, 652 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 653 throws com.liferay.portal.NoSuchPasswordPolicyException { 654 return getPersistence() 655 .findByCompanyId_Last(companyId, orderByComparator); 656 } 657 658 /** 659 * Returns the last password policy in the ordered set where companyId = ?. 660 * 661 * @param companyId the company ID 662 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 663 * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found 664 */ 665 public static com.liferay.portal.model.PasswordPolicy fetchByCompanyId_Last( 666 long companyId, 667 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 668 return getPersistence() 669 .fetchByCompanyId_Last(companyId, orderByComparator); 670 } 671 672 /** 673 * Returns the password policies before and after the current password policy in the ordered set where companyId = ?. 674 * 675 * @param passwordPolicyId the primary key of the current password policy 676 * @param companyId the company ID 677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 678 * @return the previous, current, and next password policy 679 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 680 */ 681 public static com.liferay.portal.model.PasswordPolicy[] findByCompanyId_PrevAndNext( 682 long passwordPolicyId, long companyId, 683 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 684 throws com.liferay.portal.NoSuchPasswordPolicyException { 685 return getPersistence() 686 .findByCompanyId_PrevAndNext(passwordPolicyId, companyId, 687 orderByComparator); 688 } 689 690 /** 691 * Returns all the password policies that the user has permission to view where companyId = ?. 692 * 693 * @param companyId the company ID 694 * @return the matching password policies that the user has permission to view 695 */ 696 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 697 long companyId) { 698 return getPersistence().filterFindByCompanyId(companyId); 699 } 700 701 /** 702 * Returns a range of all the password policies that the user has permission to view where companyId = ?. 703 * 704 * <p> 705 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 706 * </p> 707 * 708 * @param companyId the company ID 709 * @param start the lower bound of the range of password policies 710 * @param end the upper bound of the range of password policies (not inclusive) 711 * @return the range of matching password policies that the user has permission to view 712 */ 713 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 714 long companyId, int start, int end) { 715 return getPersistence().filterFindByCompanyId(companyId, start, end); 716 } 717 718 /** 719 * Returns an ordered range of all the password policies that the user has permissions to view where companyId = ?. 720 * 721 * <p> 722 * 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.PasswordPolicyModelImpl}. 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. 723 * </p> 724 * 725 * @param companyId the company ID 726 * @param start the lower bound of the range of password policies 727 * @param end the upper bound of the range of password policies (not inclusive) 728 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 729 * @return the ordered range of matching password policies that the user has permission to view 730 */ 731 public static java.util.List<com.liferay.portal.model.PasswordPolicy> filterFindByCompanyId( 732 long companyId, int start, int end, 733 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 734 return getPersistence() 735 .filterFindByCompanyId(companyId, start, end, 736 orderByComparator); 737 } 738 739 /** 740 * Returns the password policies before and after the current password policy in the ordered set of password policies that the user has permission to view where companyId = ?. 741 * 742 * @param passwordPolicyId the primary key of the current password policy 743 * @param companyId the company ID 744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 745 * @return the previous, current, and next password policy 746 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 747 */ 748 public static com.liferay.portal.model.PasswordPolicy[] filterFindByCompanyId_PrevAndNext( 749 long passwordPolicyId, long companyId, 750 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) 751 throws com.liferay.portal.NoSuchPasswordPolicyException { 752 return getPersistence() 753 .filterFindByCompanyId_PrevAndNext(passwordPolicyId, 754 companyId, orderByComparator); 755 } 756 757 /** 758 * Removes all the password policies where companyId = ? from the database. 759 * 760 * @param companyId the company ID 761 */ 762 public static void removeByCompanyId(long companyId) { 763 getPersistence().removeByCompanyId(companyId); 764 } 765 766 /** 767 * Returns the number of password policies where companyId = ?. 768 * 769 * @param companyId the company ID 770 * @return the number of matching password policies 771 */ 772 public static int countByCompanyId(long companyId) { 773 return getPersistence().countByCompanyId(companyId); 774 } 775 776 /** 777 * Returns the number of password policies that the user has permission to view where companyId = ?. 778 * 779 * @param companyId the company ID 780 * @return the number of matching password policies that the user has permission to view 781 */ 782 public static int filterCountByCompanyId(long companyId) { 783 return getPersistence().filterCountByCompanyId(companyId); 784 } 785 786 /** 787 * Returns the password policy where companyId = ? and defaultPolicy = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 788 * 789 * @param companyId the company ID 790 * @param defaultPolicy the default policy 791 * @return the matching password policy 792 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 793 */ 794 public static com.liferay.portal.model.PasswordPolicy findByC_DP( 795 long companyId, boolean defaultPolicy) 796 throws com.liferay.portal.NoSuchPasswordPolicyException { 797 return getPersistence().findByC_DP(companyId, defaultPolicy); 798 } 799 800 /** 801 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 802 * 803 * @param companyId the company ID 804 * @param defaultPolicy the default policy 805 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 806 */ 807 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 808 long companyId, boolean defaultPolicy) { 809 return getPersistence().fetchByC_DP(companyId, defaultPolicy); 810 } 811 812 /** 813 * Returns the password policy where companyId = ? and defaultPolicy = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 814 * 815 * @param companyId the company ID 816 * @param defaultPolicy the default policy 817 * @param retrieveFromCache whether to use the finder cache 818 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 819 */ 820 public static com.liferay.portal.model.PasswordPolicy fetchByC_DP( 821 long companyId, boolean defaultPolicy, boolean retrieveFromCache) { 822 return getPersistence() 823 .fetchByC_DP(companyId, defaultPolicy, retrieveFromCache); 824 } 825 826 /** 827 * Removes the password policy where companyId = ? and defaultPolicy = ? from the database. 828 * 829 * @param companyId the company ID 830 * @param defaultPolicy the default policy 831 * @return the password policy that was removed 832 */ 833 public static com.liferay.portal.model.PasswordPolicy removeByC_DP( 834 long companyId, boolean defaultPolicy) 835 throws com.liferay.portal.NoSuchPasswordPolicyException { 836 return getPersistence().removeByC_DP(companyId, defaultPolicy); 837 } 838 839 /** 840 * Returns the number of password policies where companyId = ? and defaultPolicy = ?. 841 * 842 * @param companyId the company ID 843 * @param defaultPolicy the default policy 844 * @return the number of matching password policies 845 */ 846 public static int countByC_DP(long companyId, boolean defaultPolicy) { 847 return getPersistence().countByC_DP(companyId, defaultPolicy); 848 } 849 850 /** 851 * Returns the password policy where companyId = ? and name = ? or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 852 * 853 * @param companyId the company ID 854 * @param name the name 855 * @return the matching password policy 856 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found 857 */ 858 public static com.liferay.portal.model.PasswordPolicy findByC_N( 859 long companyId, java.lang.String name) 860 throws com.liferay.portal.NoSuchPasswordPolicyException { 861 return getPersistence().findByC_N(companyId, name); 862 } 863 864 /** 865 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 866 * 867 * @param companyId the company ID 868 * @param name the name 869 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 870 */ 871 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 872 long companyId, java.lang.String name) { 873 return getPersistence().fetchByC_N(companyId, name); 874 } 875 876 /** 877 * Returns the password policy where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 878 * 879 * @param companyId the company ID 880 * @param name the name 881 * @param retrieveFromCache whether to use the finder cache 882 * @return the matching password policy, or <code>null</code> if a matching password policy could not be found 883 */ 884 public static com.liferay.portal.model.PasswordPolicy fetchByC_N( 885 long companyId, java.lang.String name, boolean retrieveFromCache) { 886 return getPersistence().fetchByC_N(companyId, name, retrieveFromCache); 887 } 888 889 /** 890 * Removes the password policy where companyId = ? and name = ? from the database. 891 * 892 * @param companyId the company ID 893 * @param name the name 894 * @return the password policy that was removed 895 */ 896 public static com.liferay.portal.model.PasswordPolicy removeByC_N( 897 long companyId, java.lang.String name) 898 throws com.liferay.portal.NoSuchPasswordPolicyException { 899 return getPersistence().removeByC_N(companyId, name); 900 } 901 902 /** 903 * Returns the number of password policies where companyId = ? and name = ?. 904 * 905 * @param companyId the company ID 906 * @param name the name 907 * @return the number of matching password policies 908 */ 909 public static int countByC_N(long companyId, java.lang.String name) { 910 return getPersistence().countByC_N(companyId, name); 911 } 912 913 /** 914 * Caches the password policy in the entity cache if it is enabled. 915 * 916 * @param passwordPolicy the password policy 917 */ 918 public static void cacheResult( 919 com.liferay.portal.model.PasswordPolicy passwordPolicy) { 920 getPersistence().cacheResult(passwordPolicy); 921 } 922 923 /** 924 * Caches the password policies in the entity cache if it is enabled. 925 * 926 * @param passwordPolicies the password policies 927 */ 928 public static void cacheResult( 929 java.util.List<com.liferay.portal.model.PasswordPolicy> passwordPolicies) { 930 getPersistence().cacheResult(passwordPolicies); 931 } 932 933 /** 934 * Creates a new password policy with the primary key. Does not add the password policy to the database. 935 * 936 * @param passwordPolicyId the primary key for the new password policy 937 * @return the new password policy 938 */ 939 public static com.liferay.portal.model.PasswordPolicy create( 940 long passwordPolicyId) { 941 return getPersistence().create(passwordPolicyId); 942 } 943 944 /** 945 * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners. 946 * 947 * @param passwordPolicyId the primary key of the password policy 948 * @return the password policy that was removed 949 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 950 */ 951 public static com.liferay.portal.model.PasswordPolicy remove( 952 long passwordPolicyId) 953 throws com.liferay.portal.NoSuchPasswordPolicyException { 954 return getPersistence().remove(passwordPolicyId); 955 } 956 957 public static com.liferay.portal.model.PasswordPolicy updateImpl( 958 com.liferay.portal.model.PasswordPolicy passwordPolicy) { 959 return getPersistence().updateImpl(passwordPolicy); 960 } 961 962 /** 963 * Returns the password policy with the primary key or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found. 964 * 965 * @param passwordPolicyId the primary key of the password policy 966 * @return the password policy 967 * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found 968 */ 969 public static com.liferay.portal.model.PasswordPolicy findByPrimaryKey( 970 long passwordPolicyId) 971 throws com.liferay.portal.NoSuchPasswordPolicyException { 972 return getPersistence().findByPrimaryKey(passwordPolicyId); 973 } 974 975 /** 976 * Returns the password policy with the primary key or returns <code>null</code> if it could not be found. 977 * 978 * @param passwordPolicyId the primary key of the password policy 979 * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found 980 */ 981 public static com.liferay.portal.model.PasswordPolicy fetchByPrimaryKey( 982 long passwordPolicyId) { 983 return getPersistence().fetchByPrimaryKey(passwordPolicyId); 984 } 985 986 public static java.util.Map<java.io.Serializable, com.liferay.portal.model.PasswordPolicy> fetchByPrimaryKeys( 987 java.util.Set<java.io.Serializable> primaryKeys) { 988 return getPersistence().fetchByPrimaryKeys(primaryKeys); 989 } 990 991 /** 992 * Returns all the password policies. 993 * 994 * @return the password policies 995 */ 996 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll() { 997 return getPersistence().findAll(); 998 } 999 1000 /** 1001 * Returns a range of all the password policies. 1002 * 1003 * <p> 1004 * 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.PasswordPolicyModelImpl}. 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. 1005 * </p> 1006 * 1007 * @param start the lower bound of the range of password policies 1008 * @param end the upper bound of the range of password policies (not inclusive) 1009 * @return the range of password policies 1010 */ 1011 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 1012 int start, int end) { 1013 return getPersistence().findAll(start, end); 1014 } 1015 1016 /** 1017 * Returns an ordered range of all the password policies. 1018 * 1019 * <p> 1020 * 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.PasswordPolicyModelImpl}. 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. 1021 * </p> 1022 * 1023 * @param start the lower bound of the range of password policies 1024 * @param end the upper bound of the range of password policies (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @return the ordered range of password policies 1027 */ 1028 public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll( 1029 int start, int end, 1030 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.PasswordPolicy> orderByComparator) { 1031 return getPersistence().findAll(start, end, orderByComparator); 1032 } 1033 1034 /** 1035 * Removes all the password policies from the database. 1036 */ 1037 public static void removeAll() { 1038 getPersistence().removeAll(); 1039 } 1040 1041 /** 1042 * Returns the number of password policies. 1043 * 1044 * @return the number of password policies 1045 */ 1046 public static int countAll() { 1047 return getPersistence().countAll(); 1048 } 1049 1050 public static PasswordPolicyPersistence getPersistence() { 1051 if (_persistence == null) { 1052 _persistence = (PasswordPolicyPersistence)PortalBeanLocatorUtil.locate(PasswordPolicyPersistence.class.getName()); 1053 1054 ReferenceRegistry.registerReference(PasswordPolicyUtil.class, 1055 "_persistence"); 1056 } 1057 1058 return _persistence; 1059 } 1060 1061 /** 1062 * @deprecated As of 6.2.0 1063 */ 1064 @Deprecated 1065 public void setPersistence(PasswordPolicyPersistence persistence) { 1066 } 1067 1068 private static PasswordPolicyPersistence _persistence; 1069 }