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