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