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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63; 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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63; and defaultPolicy = &#63; 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 = &#63; and defaultPolicy = &#63; 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 = &#63; and defaultPolicy = &#63; 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 = &#63; and defaultPolicy = &#63; 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 = &#63; and defaultPolicy = &#63;.
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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63;.
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    }