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