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