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 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 the password policy where companyId = &#63; and defaultPolicy = &#63; or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found.
627            *
628            * @param companyId the company ID
629            * @param defaultPolicy the default policy
630            * @return the matching password policy
631            * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found
632            * @throws SystemException if a system exception occurred
633            */
634            public static com.liferay.portal.model.PasswordPolicy findByC_DP(
635                    long companyId, boolean defaultPolicy)
636                    throws com.liferay.portal.NoSuchPasswordPolicyException,
637                            com.liferay.portal.kernel.exception.SystemException {
638                    return getPersistence().findByC_DP(companyId, defaultPolicy);
639            }
640    
641            /**
642            * 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.
643            *
644            * @param companyId the company ID
645            * @param defaultPolicy the default policy
646            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
647            * @throws SystemException if a system exception occurred
648            */
649            public static com.liferay.portal.model.PasswordPolicy fetchByC_DP(
650                    long companyId, boolean defaultPolicy)
651                    throws com.liferay.portal.kernel.exception.SystemException {
652                    return getPersistence().fetchByC_DP(companyId, defaultPolicy);
653            }
654    
655            /**
656            * 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.
657            *
658            * @param companyId the company ID
659            * @param defaultPolicy the default policy
660            * @param retrieveFromCache whether to use the finder cache
661            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
662            * @throws SystemException if a system exception occurred
663            */
664            public static com.liferay.portal.model.PasswordPolicy fetchByC_DP(
665                    long companyId, boolean defaultPolicy, boolean retrieveFromCache)
666                    throws com.liferay.portal.kernel.exception.SystemException {
667                    return getPersistence()
668                                       .fetchByC_DP(companyId, defaultPolicy, retrieveFromCache);
669            }
670    
671            /**
672            * Removes the password policy where companyId = &#63; and defaultPolicy = &#63; from the database.
673            *
674            * @param companyId the company ID
675            * @param defaultPolicy the default policy
676            * @return the password policy that was removed
677            * @throws SystemException if a system exception occurred
678            */
679            public static com.liferay.portal.model.PasswordPolicy removeByC_DP(
680                    long companyId, boolean defaultPolicy)
681                    throws com.liferay.portal.NoSuchPasswordPolicyException,
682                            com.liferay.portal.kernel.exception.SystemException {
683                    return getPersistence().removeByC_DP(companyId, defaultPolicy);
684            }
685    
686            /**
687            * Returns the number of password policies where companyId = &#63; and defaultPolicy = &#63;.
688            *
689            * @param companyId the company ID
690            * @param defaultPolicy the default policy
691            * @return the number of matching password policies
692            * @throws SystemException if a system exception occurred
693            */
694            public static int countByC_DP(long companyId, boolean defaultPolicy)
695                    throws com.liferay.portal.kernel.exception.SystemException {
696                    return getPersistence().countByC_DP(companyId, defaultPolicy);
697            }
698    
699            /**
700            * Returns the password policy where companyId = &#63; and name = &#63; or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found.
701            *
702            * @param companyId the company ID
703            * @param name the name
704            * @return the matching password policy
705            * @throws com.liferay.portal.NoSuchPasswordPolicyException if a matching password policy could not be found
706            * @throws SystemException if a system exception occurred
707            */
708            public static com.liferay.portal.model.PasswordPolicy findByC_N(
709                    long companyId, java.lang.String name)
710                    throws com.liferay.portal.NoSuchPasswordPolicyException,
711                            com.liferay.portal.kernel.exception.SystemException {
712                    return getPersistence().findByC_N(companyId, name);
713            }
714    
715            /**
716            * 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.
717            *
718            * @param companyId the company ID
719            * @param name the name
720            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
721            * @throws SystemException if a system exception occurred
722            */
723            public static com.liferay.portal.model.PasswordPolicy fetchByC_N(
724                    long companyId, java.lang.String name)
725                    throws com.liferay.portal.kernel.exception.SystemException {
726                    return getPersistence().fetchByC_N(companyId, name);
727            }
728    
729            /**
730            * 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.
731            *
732            * @param companyId the company ID
733            * @param name the name
734            * @param retrieveFromCache whether to use the finder cache
735            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
736            * @throws SystemException if a system exception occurred
737            */
738            public static com.liferay.portal.model.PasswordPolicy fetchByC_N(
739                    long companyId, java.lang.String name, boolean retrieveFromCache)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence().fetchByC_N(companyId, name, retrieveFromCache);
742            }
743    
744            /**
745            * Removes the password policy where companyId = &#63; and name = &#63; from the database.
746            *
747            * @param companyId the company ID
748            * @param name the name
749            * @return the password policy that was removed
750            * @throws SystemException if a system exception occurred
751            */
752            public static com.liferay.portal.model.PasswordPolicy removeByC_N(
753                    long companyId, java.lang.String name)
754                    throws com.liferay.portal.NoSuchPasswordPolicyException,
755                            com.liferay.portal.kernel.exception.SystemException {
756                    return getPersistence().removeByC_N(companyId, name);
757            }
758    
759            /**
760            * Returns the number of password policies where companyId = &#63; and name = &#63;.
761            *
762            * @param companyId the company ID
763            * @param name the name
764            * @return the number of matching password policies
765            * @throws SystemException if a system exception occurred
766            */
767            public static int countByC_N(long companyId, java.lang.String name)
768                    throws com.liferay.portal.kernel.exception.SystemException {
769                    return getPersistence().countByC_N(companyId, name);
770            }
771    
772            /**
773            * Caches the password policy in the entity cache if it is enabled.
774            *
775            * @param passwordPolicy the password policy
776            */
777            public static void cacheResult(
778                    com.liferay.portal.model.PasswordPolicy passwordPolicy) {
779                    getPersistence().cacheResult(passwordPolicy);
780            }
781    
782            /**
783            * Caches the password policies in the entity cache if it is enabled.
784            *
785            * @param passwordPolicies the password policies
786            */
787            public static void cacheResult(
788                    java.util.List<com.liferay.portal.model.PasswordPolicy> passwordPolicies) {
789                    getPersistence().cacheResult(passwordPolicies);
790            }
791    
792            /**
793            * Creates a new password policy with the primary key. Does not add the password policy to the database.
794            *
795            * @param passwordPolicyId the primary key for the new password policy
796            * @return the new password policy
797            */
798            public static com.liferay.portal.model.PasswordPolicy create(
799                    long passwordPolicyId) {
800                    return getPersistence().create(passwordPolicyId);
801            }
802    
803            /**
804            * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners.
805            *
806            * @param passwordPolicyId the primary key of the password policy
807            * @return the password policy that was removed
808            * @throws com.liferay.portal.NoSuchPasswordPolicyException if a password policy with the primary key could not be found
809            * @throws SystemException if a system exception occurred
810            */
811            public static com.liferay.portal.model.PasswordPolicy remove(
812                    long passwordPolicyId)
813                    throws com.liferay.portal.NoSuchPasswordPolicyException,
814                            com.liferay.portal.kernel.exception.SystemException {
815                    return getPersistence().remove(passwordPolicyId);
816            }
817    
818            public static com.liferay.portal.model.PasswordPolicy updateImpl(
819                    com.liferay.portal.model.PasswordPolicy passwordPolicy)
820                    throws com.liferay.portal.kernel.exception.SystemException {
821                    return getPersistence().updateImpl(passwordPolicy);
822            }
823    
824            /**
825            * Returns the password policy with the primary key or throws a {@link com.liferay.portal.NoSuchPasswordPolicyException} if it could not be found.
826            *
827            * @param passwordPolicyId the primary key of the password policy
828            * @return the 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 findByPrimaryKey(
833                    long passwordPolicyId)
834                    throws com.liferay.portal.NoSuchPasswordPolicyException,
835                            com.liferay.portal.kernel.exception.SystemException {
836                    return getPersistence().findByPrimaryKey(passwordPolicyId);
837            }
838    
839            /**
840            * Returns the password policy with the primary key or returns <code>null</code> if it could not be found.
841            *
842            * @param passwordPolicyId the primary key of the password policy
843            * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found
844            * @throws SystemException if a system exception occurred
845            */
846            public static com.liferay.portal.model.PasswordPolicy fetchByPrimaryKey(
847                    long passwordPolicyId)
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    return getPersistence().fetchByPrimaryKey(passwordPolicyId);
850            }
851    
852            /**
853            * Returns all the password policies.
854            *
855            * @return the password policies
856            * @throws SystemException if a system exception occurred
857            */
858            public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll()
859                    throws com.liferay.portal.kernel.exception.SystemException {
860                    return getPersistence().findAll();
861            }
862    
863            /**
864            * Returns a range of all the password policies.
865            *
866            * <p>
867            * 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.
868            * </p>
869            *
870            * @param start the lower bound of the range of password policies
871            * @param end the upper bound of the range of password policies (not inclusive)
872            * @return the range of password policies
873            * @throws SystemException if a system exception occurred
874            */
875            public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll(
876                    int start, int end)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return getPersistence().findAll(start, end);
879            }
880    
881            /**
882            * Returns an ordered range of all the password policies.
883            *
884            * <p>
885            * 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.
886            * </p>
887            *
888            * @param start the lower bound of the range of password policies
889            * @param end the upper bound of the range of password policies (not inclusive)
890            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
891            * @return the ordered range of password policies
892            * @throws SystemException if a system exception occurred
893            */
894            public static java.util.List<com.liferay.portal.model.PasswordPolicy> findAll(
895                    int start, int end,
896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    return getPersistence().findAll(start, end, orderByComparator);
899            }
900    
901            /**
902            * Removes all the password policies from the database.
903            *
904            * @throws SystemException if a system exception occurred
905            */
906            public static void removeAll()
907                    throws com.liferay.portal.kernel.exception.SystemException {
908                    getPersistence().removeAll();
909            }
910    
911            /**
912            * Returns the number of password policies.
913            *
914            * @return the number of password policies
915            * @throws SystemException if a system exception occurred
916            */
917            public static int countAll()
918                    throws com.liferay.portal.kernel.exception.SystemException {
919                    return getPersistence().countAll();
920            }
921    
922            public static PasswordPolicyPersistence getPersistence() {
923                    if (_persistence == null) {
924                            _persistence = (PasswordPolicyPersistence)PortalBeanLocatorUtil.locate(PasswordPolicyPersistence.class.getName());
925    
926                            ReferenceRegistry.registerReference(PasswordPolicyUtil.class,
927                                    "_persistence");
928                    }
929    
930                    return _persistence;
931            }
932    
933            /**
934             * @deprecated As of 6.2.0
935             */
936            public void setPersistence(PasswordPolicyPersistence persistence) {
937            }
938    
939            private static PasswordPolicyPersistence _persistence;
940    }