001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.model.PasswordPolicy;
020    
021    /**
022     * The persistence interface for the password policy service.
023     *
024     * <p>
025     * Caching information and settings can be found in <code>portal.properties</code>
026     * </p>
027     *
028     * @author Brian Wing Shun Chan
029     * @see com.liferay.portal.service.persistence.impl.PasswordPolicyPersistenceImpl
030     * @see PasswordPolicyUtil
031     * @generated
032     */
033    @ProviderType
034    public interface PasswordPolicyPersistence extends BasePersistence<PasswordPolicy> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link PasswordPolicyUtil} to access the password policy persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the password policies where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching password policies
046            */
047            public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the password policies where uuid = &#63;.
051            *
052            * <p>
053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
054            * </p>
055            *
056            * @param uuid the uuid
057            * @param start the lower bound of the range of password policies
058            * @param end the upper bound of the range of password policies (not inclusive)
059            * @return the range of matching password policies
060            */
061            public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid,
062                    int start, int end);
063    
064            /**
065            * Returns an ordered range of all the password policies where uuid = &#63;.
066            *
067            * <p>
068            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
069            * </p>
070            *
071            * @param uuid the uuid
072            * @param start the lower bound of the range of password policies
073            * @param end the upper bound of the range of password policies (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching password policies
076            */
077            public java.util.List<PasswordPolicy> findByUuid(java.lang.String uuid,
078                    int start, int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
080    
081            /**
082            * Returns the first password policy in the ordered set where uuid = &#63;.
083            *
084            * @param uuid the uuid
085            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
086            * @return the first matching password policy
087            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
088            */
089            public PasswordPolicy findByUuid_First(java.lang.String uuid,
090                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
091                    throws com.liferay.portal.NoSuchPasswordPolicyException;
092    
093            /**
094            * Returns the first password policy in the ordered set where uuid = &#63;.
095            *
096            * @param uuid the uuid
097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
098            * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found
099            */
100            public PasswordPolicy fetchByUuid_First(java.lang.String uuid,
101                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
102    
103            /**
104            * Returns the last password policy in the ordered set where uuid = &#63;.
105            *
106            * @param uuid the uuid
107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
108            * @return the last matching password policy
109            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
110            */
111            public PasswordPolicy findByUuid_Last(java.lang.String uuid,
112                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
113                    throws com.liferay.portal.NoSuchPasswordPolicyException;
114    
115            /**
116            * Returns the last password policy in the ordered set where uuid = &#63;.
117            *
118            * @param uuid the uuid
119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
120            * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found
121            */
122            public PasswordPolicy fetchByUuid_Last(java.lang.String uuid,
123                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
124    
125            /**
126            * Returns the password policies before and after the current password policy in the ordered set where uuid = &#63;.
127            *
128            * @param passwordPolicyId the primary key of the current password policy
129            * @param uuid the uuid
130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
131            * @return the previous, current, and next password policy
132            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
133            */
134            public PasswordPolicy[] findByUuid_PrevAndNext(long passwordPolicyId,
135                    java.lang.String uuid,
136                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
137                    throws com.liferay.portal.NoSuchPasswordPolicyException;
138    
139            /**
140            * Returns all the password policies that the user has permission to view where uuid = &#63;.
141            *
142            * @param uuid the uuid
143            * @return the matching password policies that the user has permission to view
144            */
145            public java.util.List<PasswordPolicy> filterFindByUuid(
146                    java.lang.String uuid);
147    
148            /**
149            * Returns a range of all the password policies that the user has permission to view where uuid = &#63;.
150            *
151            * <p>
152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
153            * </p>
154            *
155            * @param uuid the uuid
156            * @param start the lower bound of the range of password policies
157            * @param end the upper bound of the range of password policies (not inclusive)
158            * @return the range of matching password policies that the user has permission to view
159            */
160            public java.util.List<PasswordPolicy> filterFindByUuid(
161                    java.lang.String uuid, int start, int end);
162    
163            /**
164            * Returns an ordered range of all the password policies that the user has permissions to view where uuid = &#63;.
165            *
166            * <p>
167            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
168            * </p>
169            *
170            * @param uuid the uuid
171            * @param start the lower bound of the range of password policies
172            * @param end the upper bound of the range of password policies (not inclusive)
173            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
174            * @return the ordered range of matching password policies that the user has permission to view
175            */
176            public java.util.List<PasswordPolicy> filterFindByUuid(
177                    java.lang.String uuid, int start, int end,
178                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
179    
180            /**
181            * 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;.
182            *
183            * @param passwordPolicyId the primary key of the current password policy
184            * @param uuid the uuid
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the previous, current, and next password policy
187            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
188            */
189            public PasswordPolicy[] filterFindByUuid_PrevAndNext(
190                    long passwordPolicyId, java.lang.String uuid,
191                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
192                    throws com.liferay.portal.NoSuchPasswordPolicyException;
193    
194            /**
195            * Removes all the password policies where uuid = &#63; from the database.
196            *
197            * @param uuid the uuid
198            */
199            public void removeByUuid(java.lang.String uuid);
200    
201            /**
202            * Returns the number of password policies where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @return the number of matching password policies
206            */
207            public int countByUuid(java.lang.String uuid);
208    
209            /**
210            * Returns the number of password policies that the user has permission to view where uuid = &#63;.
211            *
212            * @param uuid the uuid
213            * @return the number of matching password policies that the user has permission to view
214            */
215            public int filterCountByUuid(java.lang.String uuid);
216    
217            /**
218            * Returns all the password policies where uuid = &#63; and companyId = &#63;.
219            *
220            * @param uuid the uuid
221            * @param companyId the company ID
222            * @return the matching password policies
223            */
224            public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid,
225                    long companyId);
226    
227            /**
228            * Returns a range of all the password policies where uuid = &#63; and companyId = &#63;.
229            *
230            * <p>
231            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
232            * </p>
233            *
234            * @param uuid the uuid
235            * @param companyId the company ID
236            * @param start the lower bound of the range of password policies
237            * @param end the upper bound of the range of password policies (not inclusive)
238            * @return the range of matching password policies
239            */
240            public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid,
241                    long companyId, int start, int end);
242    
243            /**
244            * Returns an ordered range of all the password policies where uuid = &#63; and companyId = &#63;.
245            *
246            * <p>
247            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
248            * </p>
249            *
250            * @param uuid the uuid
251            * @param companyId the company ID
252            * @param start the lower bound of the range of password policies
253            * @param end the upper bound of the range of password policies (not inclusive)
254            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
255            * @return the ordered range of matching password policies
256            */
257            public java.util.List<PasswordPolicy> findByUuid_C(java.lang.String uuid,
258                    long companyId, int start, int end,
259                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
260    
261            /**
262            * Returns the first password policy in the ordered set where uuid = &#63; and companyId = &#63;.
263            *
264            * @param uuid the uuid
265            * @param companyId the company ID
266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
267            * @return the first matching password policy
268            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
269            */
270            public PasswordPolicy findByUuid_C_First(java.lang.String uuid,
271                    long companyId,
272                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
273                    throws com.liferay.portal.NoSuchPasswordPolicyException;
274    
275            /**
276            * Returns the first password policy in the ordered set where uuid = &#63; and companyId = &#63;.
277            *
278            * @param uuid the uuid
279            * @param companyId the company ID
280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
281            * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found
282            */
283            public PasswordPolicy fetchByUuid_C_First(java.lang.String uuid,
284                    long companyId,
285                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
286    
287            /**
288            * Returns the last password policy in the ordered set where uuid = &#63; and companyId = &#63;.
289            *
290            * @param uuid the uuid
291            * @param companyId the company ID
292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
293            * @return the last matching password policy
294            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
295            */
296            public PasswordPolicy findByUuid_C_Last(java.lang.String uuid,
297                    long companyId,
298                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
299                    throws com.liferay.portal.NoSuchPasswordPolicyException;
300    
301            /**
302            * Returns the last password policy in the ordered set where uuid = &#63; and companyId = &#63;.
303            *
304            * @param uuid the uuid
305            * @param companyId the company ID
306            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
307            * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found
308            */
309            public PasswordPolicy fetchByUuid_C_Last(java.lang.String uuid,
310                    long companyId,
311                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
312    
313            /**
314            * Returns the password policies before and after the current password policy in the ordered set where uuid = &#63; and companyId = &#63;.
315            *
316            * @param passwordPolicyId the primary key of the current password policy
317            * @param uuid the uuid
318            * @param companyId the company ID
319            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
320            * @return the previous, current, and next password policy
321            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
322            */
323            public PasswordPolicy[] findByUuid_C_PrevAndNext(long passwordPolicyId,
324                    java.lang.String uuid, long companyId,
325                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
326                    throws com.liferay.portal.NoSuchPasswordPolicyException;
327    
328            /**
329            * Returns all the password policies that the user has permission to view where uuid = &#63; and companyId = &#63;.
330            *
331            * @param uuid the uuid
332            * @param companyId the company ID
333            * @return the matching password policies that the user has permission to view
334            */
335            public java.util.List<PasswordPolicy> filterFindByUuid_C(
336                    java.lang.String uuid, long companyId);
337    
338            /**
339            * Returns a range of all the password policies that the user has permission to view where uuid = &#63; and companyId = &#63;.
340            *
341            * <p>
342            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
343            * </p>
344            *
345            * @param uuid the uuid
346            * @param companyId the company ID
347            * @param start the lower bound of the range of password policies
348            * @param end the upper bound of the range of password policies (not inclusive)
349            * @return the range of matching password policies that the user has permission to view
350            */
351            public java.util.List<PasswordPolicy> filterFindByUuid_C(
352                    java.lang.String uuid, long companyId, int start, int end);
353    
354            /**
355            * Returns an ordered range of all the password policies that the user has permissions to view where uuid = &#63; and companyId = &#63;.
356            *
357            * <p>
358            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
359            * </p>
360            *
361            * @param uuid the uuid
362            * @param companyId the company ID
363            * @param start the lower bound of the range of password policies
364            * @param end the upper bound of the range of password policies (not inclusive)
365            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
366            * @return the ordered range of matching password policies that the user has permission to view
367            */
368            public java.util.List<PasswordPolicy> filterFindByUuid_C(
369                    java.lang.String uuid, long companyId, int start, int end,
370                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
371    
372            /**
373            * 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;.
374            *
375            * @param passwordPolicyId the primary key of the current password policy
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the previous, current, and next password policy
380            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
381            */
382            public PasswordPolicy[] filterFindByUuid_C_PrevAndNext(
383                    long passwordPolicyId, java.lang.String uuid, long companyId,
384                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
385                    throws com.liferay.portal.NoSuchPasswordPolicyException;
386    
387            /**
388            * Removes all the password policies where uuid = &#63; and companyId = &#63; from the database.
389            *
390            * @param uuid the uuid
391            * @param companyId the company ID
392            */
393            public void removeByUuid_C(java.lang.String uuid, long companyId);
394    
395            /**
396            * Returns the number of password policies where uuid = &#63; and companyId = &#63;.
397            *
398            * @param uuid the uuid
399            * @param companyId the company ID
400            * @return the number of matching password policies
401            */
402            public int countByUuid_C(java.lang.String uuid, long companyId);
403    
404            /**
405            * Returns the number of password policies that the user has permission to view where uuid = &#63; and companyId = &#63;.
406            *
407            * @param uuid the uuid
408            * @param companyId the company ID
409            * @return the number of matching password policies that the user has permission to view
410            */
411            public int filterCountByUuid_C(java.lang.String uuid, long companyId);
412    
413            /**
414            * Returns all the password policies where companyId = &#63;.
415            *
416            * @param companyId the company ID
417            * @return the matching password policies
418            */
419            public java.util.List<PasswordPolicy> findByCompanyId(long companyId);
420    
421            /**
422            * Returns a range of all the password policies where companyId = &#63;.
423            *
424            * <p>
425            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
426            * </p>
427            *
428            * @param companyId the company ID
429            * @param start the lower bound of the range of password policies
430            * @param end the upper bound of the range of password policies (not inclusive)
431            * @return the range of matching password policies
432            */
433            public java.util.List<PasswordPolicy> findByCompanyId(long companyId,
434                    int start, int end);
435    
436            /**
437            * Returns an ordered range of all the password policies where companyId = &#63;.
438            *
439            * <p>
440            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
441            * </p>
442            *
443            * @param companyId the company ID
444            * @param start the lower bound of the range of password policies
445            * @param end the upper bound of the range of password policies (not inclusive)
446            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
447            * @return the ordered range of matching password policies
448            */
449            public java.util.List<PasswordPolicy> findByCompanyId(long companyId,
450                    int start, int end,
451                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
452    
453            /**
454            * Returns the first password policy in the ordered set where companyId = &#63;.
455            *
456            * @param companyId the company ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the first matching password policy
459            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
460            */
461            public PasswordPolicy findByCompanyId_First(long companyId,
462                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
463                    throws com.liferay.portal.NoSuchPasswordPolicyException;
464    
465            /**
466            * Returns the first password policy in the ordered set where companyId = &#63;.
467            *
468            * @param companyId the company ID
469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
470            * @return the first matching password policy, or <code>null</code> if a matching password policy could not be found
471            */
472            public PasswordPolicy fetchByCompanyId_First(long companyId,
473                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
474    
475            /**
476            * Returns the last password policy in the ordered set where companyId = &#63;.
477            *
478            * @param companyId the company ID
479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
480            * @return the last matching password policy
481            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
482            */
483            public PasswordPolicy findByCompanyId_Last(long companyId,
484                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
485                    throws com.liferay.portal.NoSuchPasswordPolicyException;
486    
487            /**
488            * Returns the last password policy in the ordered set where companyId = &#63;.
489            *
490            * @param companyId the company ID
491            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
492            * @return the last matching password policy, or <code>null</code> if a matching password policy could not be found
493            */
494            public PasswordPolicy fetchByCompanyId_Last(long companyId,
495                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
496    
497            /**
498            * Returns the password policies before and after the current password policy in the ordered set where companyId = &#63;.
499            *
500            * @param passwordPolicyId the primary key of the current password policy
501            * @param companyId the company ID
502            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
503            * @return the previous, current, and next password policy
504            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
505            */
506            public PasswordPolicy[] findByCompanyId_PrevAndNext(long passwordPolicyId,
507                    long companyId,
508                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
509                    throws com.liferay.portal.NoSuchPasswordPolicyException;
510    
511            /**
512            * Returns all the password policies that the user has permission to view where companyId = &#63;.
513            *
514            * @param companyId the company ID
515            * @return the matching password policies that the user has permission to view
516            */
517            public java.util.List<PasswordPolicy> filterFindByCompanyId(long companyId);
518    
519            /**
520            * Returns a range of all the password policies that the user has permission to view where companyId = &#63;.
521            *
522            * <p>
523            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
524            * </p>
525            *
526            * @param companyId the company ID
527            * @param start the lower bound of the range of password policies
528            * @param end the upper bound of the range of password policies (not inclusive)
529            * @return the range of matching password policies that the user has permission to view
530            */
531            public java.util.List<PasswordPolicy> filterFindByCompanyId(
532                    long companyId, int start, int end);
533    
534            /**
535            * Returns an ordered range of all the password policies that the user has permissions to view where companyId = &#63;.
536            *
537            * <p>
538            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
539            * </p>
540            *
541            * @param companyId the company ID
542            * @param start the lower bound of the range of password policies
543            * @param end the upper bound of the range of password policies (not inclusive)
544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
545            * @return the ordered range of matching password policies that the user has permission to view
546            */
547            public java.util.List<PasswordPolicy> filterFindByCompanyId(
548                    long companyId, int start, int end,
549                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
550    
551            /**
552            * 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;.
553            *
554            * @param passwordPolicyId the primary key of the current password policy
555            * @param companyId the company ID
556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
557            * @return the previous, current, and next password policy
558            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
559            */
560            public PasswordPolicy[] filterFindByCompanyId_PrevAndNext(
561                    long passwordPolicyId, long companyId,
562                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator)
563                    throws com.liferay.portal.NoSuchPasswordPolicyException;
564    
565            /**
566            * Removes all the password policies where companyId = &#63; from the database.
567            *
568            * @param companyId the company ID
569            */
570            public void removeByCompanyId(long companyId);
571    
572            /**
573            * Returns the number of password policies where companyId = &#63;.
574            *
575            * @param companyId the company ID
576            * @return the number of matching password policies
577            */
578            public int countByCompanyId(long companyId);
579    
580            /**
581            * Returns the number of password policies that the user has permission to view where companyId = &#63;.
582            *
583            * @param companyId the company ID
584            * @return the number of matching password policies that the user has permission to view
585            */
586            public int filterCountByCompanyId(long companyId);
587    
588            /**
589            * Returns the password policy where companyId = &#63; and defaultPolicy = &#63; or throws a {@link NoSuchPasswordPolicyException} if it could not be found.
590            *
591            * @param companyId the company ID
592            * @param defaultPolicy the default policy
593            * @return the matching password policy
594            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
595            */
596            public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
597                    throws com.liferay.portal.NoSuchPasswordPolicyException;
598    
599            /**
600            * 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.
601            *
602            * @param companyId the company ID
603            * @param defaultPolicy the default policy
604            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
605            */
606            public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy);
607    
608            /**
609            * 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.
610            *
611            * @param companyId the company ID
612            * @param defaultPolicy the default policy
613            * @param retrieveFromCache whether to use the finder cache
614            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
615            */
616            public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy,
617                    boolean retrieveFromCache);
618    
619            /**
620            * Removes the password policy where companyId = &#63; and defaultPolicy = &#63; from the database.
621            *
622            * @param companyId the company ID
623            * @param defaultPolicy the default policy
624            * @return the password policy that was removed
625            */
626            public PasswordPolicy removeByC_DP(long companyId, boolean defaultPolicy)
627                    throws com.liferay.portal.NoSuchPasswordPolicyException;
628    
629            /**
630            * Returns the number of password policies where companyId = &#63; and defaultPolicy = &#63;.
631            *
632            * @param companyId the company ID
633            * @param defaultPolicy the default policy
634            * @return the number of matching password policies
635            */
636            public int countByC_DP(long companyId, boolean defaultPolicy);
637    
638            /**
639            * Returns the password policy where companyId = &#63; and name = &#63; or throws a {@link NoSuchPasswordPolicyException} if it could not be found.
640            *
641            * @param companyId the company ID
642            * @param name the name
643            * @return the matching password policy
644            * @throws NoSuchPasswordPolicyException if a matching password policy could not be found
645            */
646            public PasswordPolicy findByC_N(long companyId, java.lang.String name)
647                    throws com.liferay.portal.NoSuchPasswordPolicyException;
648    
649            /**
650            * 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.
651            *
652            * @param companyId the company ID
653            * @param name the name
654            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
655            */
656            public PasswordPolicy fetchByC_N(long companyId, java.lang.String name);
657    
658            /**
659            * 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.
660            *
661            * @param companyId the company ID
662            * @param name the name
663            * @param retrieveFromCache whether to use the finder cache
664            * @return the matching password policy, or <code>null</code> if a matching password policy could not be found
665            */
666            public PasswordPolicy fetchByC_N(long companyId, java.lang.String name,
667                    boolean retrieveFromCache);
668    
669            /**
670            * Removes the password policy where companyId = &#63; and name = &#63; from the database.
671            *
672            * @param companyId the company ID
673            * @param name the name
674            * @return the password policy that was removed
675            */
676            public PasswordPolicy removeByC_N(long companyId, java.lang.String name)
677                    throws com.liferay.portal.NoSuchPasswordPolicyException;
678    
679            /**
680            * Returns the number of password policies where companyId = &#63; and name = &#63;.
681            *
682            * @param companyId the company ID
683            * @param name the name
684            * @return the number of matching password policies
685            */
686            public int countByC_N(long companyId, java.lang.String name);
687    
688            /**
689            * Caches the password policy in the entity cache if it is enabled.
690            *
691            * @param passwordPolicy the password policy
692            */
693            public void cacheResult(PasswordPolicy passwordPolicy);
694    
695            /**
696            * Caches the password policies in the entity cache if it is enabled.
697            *
698            * @param passwordPolicies the password policies
699            */
700            public void cacheResult(java.util.List<PasswordPolicy> passwordPolicies);
701    
702            /**
703            * Creates a new password policy with the primary key. Does not add the password policy to the database.
704            *
705            * @param passwordPolicyId the primary key for the new password policy
706            * @return the new password policy
707            */
708            public PasswordPolicy create(long passwordPolicyId);
709    
710            /**
711            * Removes the password policy with the primary key from the database. Also notifies the appropriate model listeners.
712            *
713            * @param passwordPolicyId the primary key of the password policy
714            * @return the password policy that was removed
715            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
716            */
717            public PasswordPolicy remove(long passwordPolicyId)
718                    throws com.liferay.portal.NoSuchPasswordPolicyException;
719    
720            public PasswordPolicy updateImpl(PasswordPolicy passwordPolicy);
721    
722            /**
723            * Returns the password policy with the primary key or throws a {@link NoSuchPasswordPolicyException} if it could not be found.
724            *
725            * @param passwordPolicyId the primary key of the password policy
726            * @return the password policy
727            * @throws NoSuchPasswordPolicyException if a password policy with the primary key could not be found
728            */
729            public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
730                    throws com.liferay.portal.NoSuchPasswordPolicyException;
731    
732            /**
733            * Returns the password policy with the primary key or returns <code>null</code> if it could not be found.
734            *
735            * @param passwordPolicyId the primary key of the password policy
736            * @return the password policy, or <code>null</code> if a password policy with the primary key could not be found
737            */
738            public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId);
739    
740            @Override
741            public java.util.Map<java.io.Serializable, PasswordPolicy> fetchByPrimaryKeys(
742                    java.util.Set<java.io.Serializable> primaryKeys);
743    
744            /**
745            * Returns all the password policies.
746            *
747            * @return the password policies
748            */
749            public java.util.List<PasswordPolicy> findAll();
750    
751            /**
752            * Returns a range of all the password policies.
753            *
754            * <p>
755            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
756            * </p>
757            *
758            * @param start the lower bound of the range of password policies
759            * @param end the upper bound of the range of password policies (not inclusive)
760            * @return the range of password policies
761            */
762            public java.util.List<PasswordPolicy> findAll(int start, int end);
763    
764            /**
765            * Returns an ordered range of all the password policies.
766            *
767            * <p>
768            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PasswordPolicyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
769            * </p>
770            *
771            * @param start the lower bound of the range of password policies
772            * @param end the upper bound of the range of password policies (not inclusive)
773            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
774            * @return the ordered range of password policies
775            */
776            public java.util.List<PasswordPolicy> findAll(int start, int end,
777                    com.liferay.portal.kernel.util.OrderByComparator<PasswordPolicy> orderByComparator);
778    
779            /**
780            * Removes all the password policies from the database.
781            */
782            public void removeAll();
783    
784            /**
785            * Returns the number of password policies.
786            *
787            * @return the number of password policies
788            */
789            public int countAll();
790    }