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