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.portlet.journal.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.service.ServiceContext;
025    
026    import com.liferay.portlet.journal.model.JournalFolder;
027    
028    import java.util.List;
029    
030    /**
031     * The persistence utility for the journal folder service. This utility wraps {@link JournalFolderPersistenceImpl} 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.
032     *
033     * <p>
034     * Caching information and settings can be found in <code>portal.properties</code>
035     * </p>
036     *
037     * @author Brian Wing Shun Chan
038     * @see JournalFolderPersistence
039     * @see JournalFolderPersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class JournalFolderUtil {
044            /*
045             * NOTE FOR DEVELOPERS:
046             *
047             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
048             */
049    
050            /**
051             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
052             */
053            public static void clearCache() {
054                    getPersistence().clearCache();
055            }
056    
057            /**
058             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
059             */
060            public static void clearCache(JournalFolder journalFolder) {
061                    getPersistence().clearCache(journalFolder);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
068                    throws SystemException {
069                    return getPersistence().countWithDynamicQuery(dynamicQuery);
070            }
071    
072            /**
073             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
074             */
075            public static List<JournalFolder> findWithDynamicQuery(
076                    DynamicQuery dynamicQuery) throws SystemException {
077                    return getPersistence().findWithDynamicQuery(dynamicQuery);
078            }
079    
080            /**
081             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
082             */
083            public static List<JournalFolder> findWithDynamicQuery(
084                    DynamicQuery dynamicQuery, int start, int end)
085                    throws SystemException {
086                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
087            }
088    
089            /**
090             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
091             */
092            public static List<JournalFolder> findWithDynamicQuery(
093                    DynamicQuery dynamicQuery, int start, int end,
094                    OrderByComparator orderByComparator) throws SystemException {
095                    return getPersistence()
096                                       .findWithDynamicQuery(dynamicQuery, start, end,
097                            orderByComparator);
098            }
099    
100            /**
101             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
102             */
103            public static JournalFolder update(JournalFolder journalFolder)
104                    throws SystemException {
105                    return getPersistence().update(journalFolder);
106            }
107    
108            /**
109             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
110             */
111            public static JournalFolder update(JournalFolder journalFolder,
112                    ServiceContext serviceContext) throws SystemException {
113                    return getPersistence().update(journalFolder, serviceContext);
114            }
115    
116            /**
117            * Returns all the journal folders where uuid = &#63;.
118            *
119            * @param uuid the uuid
120            * @return the matching journal folders
121            * @throws SystemException if a system exception occurred
122            */
123            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid(
124                    java.lang.String uuid)
125                    throws com.liferay.portal.kernel.exception.SystemException {
126                    return getPersistence().findByUuid(uuid);
127            }
128    
129            /**
130            * Returns a range of all the journal folders where uuid = &#63;.
131            *
132            * <p>
133            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
134            * </p>
135            *
136            * @param uuid the uuid
137            * @param start the lower bound of the range of journal folders
138            * @param end the upper bound of the range of journal folders (not inclusive)
139            * @return the range of matching journal folders
140            * @throws SystemException if a system exception occurred
141            */
142            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid(
143                    java.lang.String uuid, int start, int end)
144                    throws com.liferay.portal.kernel.exception.SystemException {
145                    return getPersistence().findByUuid(uuid, start, end);
146            }
147    
148            /**
149            * Returns an ordered range of all the journal folders 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 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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 journal folders
157            * @param end the upper bound of the range of journal folders (not inclusive)
158            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
159            * @return the ordered range of matching journal folders
160            * @throws SystemException if a system exception occurred
161            */
162            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid(
163                    java.lang.String uuid, int start, int end,
164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
167            }
168    
169            /**
170            * Returns the first journal folder in the ordered set where uuid = &#63;.
171            *
172            * @param uuid the uuid
173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
174            * @return the first matching journal folder
175            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.journal.model.JournalFolder findByUuid_First(
179                    java.lang.String uuid,
180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.journal.NoSuchFolderException {
183                    return getPersistence().findByUuid_First(uuid, orderByComparator);
184            }
185    
186            /**
187            * Returns the first journal folder in the ordered set where uuid = &#63;.
188            *
189            * @param uuid the uuid
190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
191            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
192            * @throws SystemException if a system exception occurred
193            */
194            public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_First(
195                    java.lang.String uuid,
196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
199            }
200    
201            /**
202            * Returns the last journal folder in the ordered set where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the last matching journal folder
207            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
208            * @throws SystemException if a system exception occurred
209            */
210            public static com.liferay.portlet.journal.model.JournalFolder findByUuid_Last(
211                    java.lang.String uuid,
212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
213                    throws com.liferay.portal.kernel.exception.SystemException,
214                            com.liferay.portlet.journal.NoSuchFolderException {
215                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
216            }
217    
218            /**
219            * Returns the last journal folder in the ordered set where uuid = &#63;.
220            *
221            * @param uuid the uuid
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
224            * @throws SystemException if a system exception occurred
225            */
226            public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_Last(
227                    java.lang.String uuid,
228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
229                    throws com.liferay.portal.kernel.exception.SystemException {
230                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
231            }
232    
233            /**
234            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63;.
235            *
236            * @param folderId the primary key of the current journal folder
237            * @param uuid the uuid
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next journal folder
240            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
241            * @throws SystemException if a system exception occurred
242            */
243            public static com.liferay.portlet.journal.model.JournalFolder[] findByUuid_PrevAndNext(
244                    long folderId, java.lang.String uuid,
245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
246                    throws com.liferay.portal.kernel.exception.SystemException,
247                            com.liferay.portlet.journal.NoSuchFolderException {
248                    return getPersistence()
249                                       .findByUuid_PrevAndNext(folderId, uuid, orderByComparator);
250            }
251    
252            /**
253            * Removes all the journal folders where uuid = &#63; from the database.
254            *
255            * @param uuid the uuid
256            * @throws SystemException if a system exception occurred
257            */
258            public static void removeByUuid(java.lang.String uuid)
259                    throws com.liferay.portal.kernel.exception.SystemException {
260                    getPersistence().removeByUuid(uuid);
261            }
262    
263            /**
264            * Returns the number of journal folders where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @return the number of matching journal folders
268            * @throws SystemException if a system exception occurred
269            */
270            public static int countByUuid(java.lang.String uuid)
271                    throws com.liferay.portal.kernel.exception.SystemException {
272                    return getPersistence().countByUuid(uuid);
273            }
274    
275            /**
276            * Returns the journal folder where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found.
277            *
278            * @param uuid the uuid
279            * @param groupId the group ID
280            * @return the matching journal folder
281            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
282            * @throws SystemException if a system exception occurred
283            */
284            public static com.liferay.portlet.journal.model.JournalFolder findByUUID_G(
285                    java.lang.String uuid, long groupId)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.journal.NoSuchFolderException {
288                    return getPersistence().findByUUID_G(uuid, groupId);
289            }
290    
291            /**
292            * Returns the journal folder where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
293            *
294            * @param uuid the uuid
295            * @param groupId the group ID
296            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
297            * @throws SystemException if a system exception occurred
298            */
299            public static com.liferay.portlet.journal.model.JournalFolder fetchByUUID_G(
300                    java.lang.String uuid, long groupId)
301                    throws com.liferay.portal.kernel.exception.SystemException {
302                    return getPersistence().fetchByUUID_G(uuid, groupId);
303            }
304    
305            /**
306            * Returns the journal folder where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
307            *
308            * @param uuid the uuid
309            * @param groupId the group ID
310            * @param retrieveFromCache whether to use the finder cache
311            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
312            * @throws SystemException if a system exception occurred
313            */
314            public static com.liferay.portlet.journal.model.JournalFolder fetchByUUID_G(
315                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
316                    throws com.liferay.portal.kernel.exception.SystemException {
317                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
318            }
319    
320            /**
321            * Removes the journal folder where uuid = &#63; and groupId = &#63; from the database.
322            *
323            * @param uuid the uuid
324            * @param groupId the group ID
325            * @return the journal folder that was removed
326            * @throws SystemException if a system exception occurred
327            */
328            public static com.liferay.portlet.journal.model.JournalFolder removeByUUID_G(
329                    java.lang.String uuid, long groupId)
330                    throws com.liferay.portal.kernel.exception.SystemException,
331                            com.liferay.portlet.journal.NoSuchFolderException {
332                    return getPersistence().removeByUUID_G(uuid, groupId);
333            }
334    
335            /**
336            * Returns the number of journal folders where uuid = &#63; and groupId = &#63;.
337            *
338            * @param uuid the uuid
339            * @param groupId the group ID
340            * @return the number of matching journal folders
341            * @throws SystemException if a system exception occurred
342            */
343            public static int countByUUID_G(java.lang.String uuid, long groupId)
344                    throws com.liferay.portal.kernel.exception.SystemException {
345                    return getPersistence().countByUUID_G(uuid, groupId);
346            }
347    
348            /**
349            * Returns all the journal folders where uuid = &#63; and companyId = &#63;.
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @return the matching journal folders
354            * @throws SystemException if a system exception occurred
355            */
356            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C(
357                    java.lang.String uuid, long companyId)
358                    throws com.liferay.portal.kernel.exception.SystemException {
359                    return getPersistence().findByUuid_C(uuid, companyId);
360            }
361    
362            /**
363            * Returns a range of all the journal folders where uuid = &#63; and companyId = &#63;.
364            *
365            * <p>
366            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
367            * </p>
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param start the lower bound of the range of journal folders
372            * @param end the upper bound of the range of journal folders (not inclusive)
373            * @return the range of matching journal folders
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C(
377                    java.lang.String uuid, long companyId, int start, int end)
378                    throws com.liferay.portal.kernel.exception.SystemException {
379                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
380            }
381    
382            /**
383            * Returns an ordered range of all the journal folders where uuid = &#63; and companyId = &#63;.
384            *
385            * <p>
386            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
387            * </p>
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param start the lower bound of the range of journal folders
392            * @param end the upper bound of the range of journal folders (not inclusive)
393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
394            * @return the ordered range of matching journal folders
395            * @throws SystemException if a system exception occurred
396            */
397            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C(
398                    java.lang.String uuid, long companyId, int start, int end,
399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
400                    throws com.liferay.portal.kernel.exception.SystemException {
401                    return getPersistence()
402                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
403            }
404    
405            /**
406            * Returns the first journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the first matching journal folder
412            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
413            * @throws SystemException if a system exception occurred
414            */
415            public static com.liferay.portlet.journal.model.JournalFolder findByUuid_C_First(
416                    java.lang.String uuid, long companyId,
417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
418                    throws com.liferay.portal.kernel.exception.SystemException,
419                            com.liferay.portlet.journal.NoSuchFolderException {
420                    return getPersistence()
421                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
422            }
423    
424            /**
425            * Returns the first journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
426            *
427            * @param uuid the uuid
428            * @param companyId the company ID
429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
430            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
431            * @throws SystemException if a system exception occurred
432            */
433            public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_C_First(
434                    java.lang.String uuid, long companyId,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException {
437                    return getPersistence()
438                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
439            }
440    
441            /**
442            * Returns the last journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
443            *
444            * @param uuid the uuid
445            * @param companyId the company ID
446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
447            * @return the last matching journal folder
448            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
449            * @throws SystemException if a system exception occurred
450            */
451            public static com.liferay.portlet.journal.model.JournalFolder findByUuid_C_Last(
452                    java.lang.String uuid, long companyId,
453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.journal.NoSuchFolderException {
456                    return getPersistence()
457                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
458            }
459    
460            /**
461            * Returns the last journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
462            *
463            * @param uuid the uuid
464            * @param companyId the company ID
465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
466            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
467            * @throws SystemException if a system exception occurred
468            */
469            public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_C_Last(
470                    java.lang.String uuid, long companyId,
471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
472                    throws com.liferay.portal.kernel.exception.SystemException {
473                    return getPersistence()
474                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
475            }
476    
477            /**
478            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
479            *
480            * @param folderId the primary key of the current journal folder
481            * @param uuid the uuid
482            * @param companyId the company ID
483            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
484            * @return the previous, current, and next journal folder
485            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
486            * @throws SystemException if a system exception occurred
487            */
488            public static com.liferay.portlet.journal.model.JournalFolder[] findByUuid_C_PrevAndNext(
489                    long folderId, java.lang.String uuid, long companyId,
490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
491                    throws com.liferay.portal.kernel.exception.SystemException,
492                            com.liferay.portlet.journal.NoSuchFolderException {
493                    return getPersistence()
494                                       .findByUuid_C_PrevAndNext(folderId, uuid, companyId,
495                            orderByComparator);
496            }
497    
498            /**
499            * Removes all the journal folders where uuid = &#63; and companyId = &#63; from the database.
500            *
501            * @param uuid the uuid
502            * @param companyId the company ID
503            * @throws SystemException if a system exception occurred
504            */
505            public static void removeByUuid_C(java.lang.String uuid, long companyId)
506                    throws com.liferay.portal.kernel.exception.SystemException {
507                    getPersistence().removeByUuid_C(uuid, companyId);
508            }
509    
510            /**
511            * Returns the number of journal folders where uuid = &#63; and companyId = &#63;.
512            *
513            * @param uuid the uuid
514            * @param companyId the company ID
515            * @return the number of matching journal folders
516            * @throws SystemException if a system exception occurred
517            */
518            public static int countByUuid_C(java.lang.String uuid, long companyId)
519                    throws com.liferay.portal.kernel.exception.SystemException {
520                    return getPersistence().countByUuid_C(uuid, companyId);
521            }
522    
523            /**
524            * Returns all the journal folders where groupId = &#63;.
525            *
526            * @param groupId the group ID
527            * @return the matching journal folders
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId(
531                    long groupId)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().findByGroupId(groupId);
534            }
535    
536            /**
537            * Returns a range of all the journal folders where groupId = &#63;.
538            *
539            * <p>
540            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
541            * </p>
542            *
543            * @param groupId the group ID
544            * @param start the lower bound of the range of journal folders
545            * @param end the upper bound of the range of journal folders (not inclusive)
546            * @return the range of matching journal folders
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId(
550                    long groupId, int start, int end)
551                    throws com.liferay.portal.kernel.exception.SystemException {
552                    return getPersistence().findByGroupId(groupId, start, end);
553            }
554    
555            /**
556            * Returns an ordered range of all the journal folders where groupId = &#63;.
557            *
558            * <p>
559            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
560            * </p>
561            *
562            * @param groupId the group ID
563            * @param start the lower bound of the range of journal folders
564            * @param end the upper bound of the range of journal folders (not inclusive)
565            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
566            * @return the ordered range of matching journal folders
567            * @throws SystemException if a system exception occurred
568            */
569            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId(
570                    long groupId, int start, int end,
571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
572                    throws com.liferay.portal.kernel.exception.SystemException {
573                    return getPersistence()
574                                       .findByGroupId(groupId, start, end, orderByComparator);
575            }
576    
577            /**
578            * Returns the first journal folder in the ordered set where groupId = &#63;.
579            *
580            * @param groupId the group ID
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the first matching journal folder
583            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
584            * @throws SystemException if a system exception occurred
585            */
586            public static com.liferay.portlet.journal.model.JournalFolder findByGroupId_First(
587                    long groupId,
588                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
589                    throws com.liferay.portal.kernel.exception.SystemException,
590                            com.liferay.portlet.journal.NoSuchFolderException {
591                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
592            }
593    
594            /**
595            * Returns the first journal folder in the ordered set where groupId = &#63;.
596            *
597            * @param groupId the group ID
598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
599            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
600            * @throws SystemException if a system exception occurred
601            */
602            public static com.liferay.portlet.journal.model.JournalFolder fetchByGroupId_First(
603                    long groupId,
604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
605                    throws com.liferay.portal.kernel.exception.SystemException {
606                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last journal folder in the ordered set where groupId = &#63;.
611            *
612            * @param groupId the group ID
613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
614            * @return the last matching journal folder
615            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
616            * @throws SystemException if a system exception occurred
617            */
618            public static com.liferay.portlet.journal.model.JournalFolder findByGroupId_Last(
619                    long groupId,
620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
621                    throws com.liferay.portal.kernel.exception.SystemException,
622                            com.liferay.portlet.journal.NoSuchFolderException {
623                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
624            }
625    
626            /**
627            * Returns the last journal folder in the ordered set where groupId = &#63;.
628            *
629            * @param groupId the group ID
630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
631            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
632            * @throws SystemException if a system exception occurred
633            */
634            public static com.liferay.portlet.journal.model.JournalFolder fetchByGroupId_Last(
635                    long groupId,
636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
637                    throws com.liferay.portal.kernel.exception.SystemException {
638                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
639            }
640    
641            /**
642            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63;.
643            *
644            * @param folderId the primary key of the current journal folder
645            * @param groupId the group ID
646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
647            * @return the previous, current, and next journal folder
648            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
649            * @throws SystemException if a system exception occurred
650            */
651            public static com.liferay.portlet.journal.model.JournalFolder[] findByGroupId_PrevAndNext(
652                    long folderId, long groupId,
653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
654                    throws com.liferay.portal.kernel.exception.SystemException,
655                            com.liferay.portlet.journal.NoSuchFolderException {
656                    return getPersistence()
657                                       .findByGroupId_PrevAndNext(folderId, groupId,
658                            orderByComparator);
659            }
660    
661            /**
662            * Returns all the journal folders that the user has permission to view where groupId = &#63;.
663            *
664            * @param groupId the group ID
665            * @return the matching journal folders that the user has permission to view
666            * @throws SystemException if a system exception occurred
667            */
668            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId(
669                    long groupId)
670                    throws com.liferay.portal.kernel.exception.SystemException {
671                    return getPersistence().filterFindByGroupId(groupId);
672            }
673    
674            /**
675            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63;.
676            *
677            * <p>
678            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
679            * </p>
680            *
681            * @param groupId the group ID
682            * @param start the lower bound of the range of journal folders
683            * @param end the upper bound of the range of journal folders (not inclusive)
684            * @return the range of matching journal folders that the user has permission to view
685            * @throws SystemException if a system exception occurred
686            */
687            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId(
688                    long groupId, int start, int end)
689                    throws com.liferay.portal.kernel.exception.SystemException {
690                    return getPersistence().filterFindByGroupId(groupId, start, end);
691            }
692    
693            /**
694            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63;.
695            *
696            * <p>
697            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
698            * </p>
699            *
700            * @param groupId the group ID
701            * @param start the lower bound of the range of journal folders
702            * @param end the upper bound of the range of journal folders (not inclusive)
703            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
704            * @return the ordered range of matching journal folders that the user has permission to view
705            * @throws SystemException if a system exception occurred
706            */
707            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId(
708                    long groupId, int start, int end,
709                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
710                    throws com.liferay.portal.kernel.exception.SystemException {
711                    return getPersistence()
712                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
713            }
714    
715            /**
716            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63;.
717            *
718            * @param folderId the primary key of the current journal folder
719            * @param groupId the group ID
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the previous, current, and next journal folder
722            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
723            * @throws SystemException if a system exception occurred
724            */
725            public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByGroupId_PrevAndNext(
726                    long folderId, long groupId,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.kernel.exception.SystemException,
729                            com.liferay.portlet.journal.NoSuchFolderException {
730                    return getPersistence()
731                                       .filterFindByGroupId_PrevAndNext(folderId, groupId,
732                            orderByComparator);
733            }
734    
735            /**
736            * Removes all the journal folders where groupId = &#63; from the database.
737            *
738            * @param groupId the group ID
739            * @throws SystemException if a system exception occurred
740            */
741            public static void removeByGroupId(long groupId)
742                    throws com.liferay.portal.kernel.exception.SystemException {
743                    getPersistence().removeByGroupId(groupId);
744            }
745    
746            /**
747            * Returns the number of journal folders where groupId = &#63;.
748            *
749            * @param groupId the group ID
750            * @return the number of matching journal folders
751            * @throws SystemException if a system exception occurred
752            */
753            public static int countByGroupId(long groupId)
754                    throws com.liferay.portal.kernel.exception.SystemException {
755                    return getPersistence().countByGroupId(groupId);
756            }
757    
758            /**
759            * Returns the number of journal folders that the user has permission to view where groupId = &#63;.
760            *
761            * @param groupId the group ID
762            * @return the number of matching journal folders that the user has permission to view
763            * @throws SystemException if a system exception occurred
764            */
765            public static int filterCountByGroupId(long groupId)
766                    throws com.liferay.portal.kernel.exception.SystemException {
767                    return getPersistence().filterCountByGroupId(groupId);
768            }
769    
770            /**
771            * Returns all the journal folders where companyId = &#63;.
772            *
773            * @param companyId the company ID
774            * @return the matching journal folders
775            * @throws SystemException if a system exception occurred
776            */
777            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId(
778                    long companyId)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    return getPersistence().findByCompanyId(companyId);
781            }
782    
783            /**
784            * Returns a range of all the journal folders 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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 journal folders
792            * @param end the upper bound of the range of journal folders (not inclusive)
793            * @return the range of matching journal folders
794            * @throws SystemException if a system exception occurred
795            */
796            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId(
797                    long companyId, int start, int end)
798                    throws com.liferay.portal.kernel.exception.SystemException {
799                    return getPersistence().findByCompanyId(companyId, start, end);
800            }
801    
802            /**
803            * Returns an ordered range of all the journal folders 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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 journal folders
811            * @param end the upper bound of the range of journal folders (not inclusive)
812            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
813            * @return the ordered range of matching journal folders
814            * @throws SystemException if a system exception occurred
815            */
816            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId(
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                                       .findByCompanyId(companyId, start, end, orderByComparator);
822            }
823    
824            /**
825            * Returns the first journal folder in the ordered set where companyId = &#63;.
826            *
827            * @param companyId the company ID
828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
829            * @return the first matching journal folder
830            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
831            * @throws SystemException if a system exception occurred
832            */
833            public static com.liferay.portlet.journal.model.JournalFolder findByCompanyId_First(
834                    long companyId,
835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
836                    throws com.liferay.portal.kernel.exception.SystemException,
837                            com.liferay.portlet.journal.NoSuchFolderException {
838                    return getPersistence()
839                                       .findByCompanyId_First(companyId, orderByComparator);
840            }
841    
842            /**
843            * Returns the first journal folder in the ordered set where companyId = &#63;.
844            *
845            * @param companyId the company ID
846            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
847            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
848            * @throws SystemException if a system exception occurred
849            */
850            public static com.liferay.portlet.journal.model.JournalFolder fetchByCompanyId_First(
851                    long companyId,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence()
855                                       .fetchByCompanyId_First(companyId, orderByComparator);
856            }
857    
858            /**
859            * Returns the last journal folder in the ordered set where companyId = &#63;.
860            *
861            * @param companyId the company ID
862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863            * @return the last matching journal folder
864            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
865            * @throws SystemException if a system exception occurred
866            */
867            public static com.liferay.portlet.journal.model.JournalFolder findByCompanyId_Last(
868                    long companyId,
869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
870                    throws com.liferay.portal.kernel.exception.SystemException,
871                            com.liferay.portlet.journal.NoSuchFolderException {
872                    return getPersistence()
873                                       .findByCompanyId_Last(companyId, orderByComparator);
874            }
875    
876            /**
877            * Returns the last journal folder in the ordered set where companyId = &#63;.
878            *
879            * @param companyId the company ID
880            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
881            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
882            * @throws SystemException if a system exception occurred
883            */
884            public static com.liferay.portlet.journal.model.JournalFolder fetchByCompanyId_Last(
885                    long companyId,
886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
887                    throws com.liferay.portal.kernel.exception.SystemException {
888                    return getPersistence()
889                                       .fetchByCompanyId_Last(companyId, orderByComparator);
890            }
891    
892            /**
893            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63;.
894            *
895            * @param folderId the primary key of the current journal folder
896            * @param companyId the company ID
897            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
898            * @return the previous, current, and next journal folder
899            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
900            * @throws SystemException if a system exception occurred
901            */
902            public static com.liferay.portlet.journal.model.JournalFolder[] findByCompanyId_PrevAndNext(
903                    long folderId, long companyId,
904                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
905                    throws com.liferay.portal.kernel.exception.SystemException,
906                            com.liferay.portlet.journal.NoSuchFolderException {
907                    return getPersistence()
908                                       .findByCompanyId_PrevAndNext(folderId, companyId,
909                            orderByComparator);
910            }
911    
912            /**
913            * Removes all the journal folders where companyId = &#63; from the database.
914            *
915            * @param companyId the company ID
916            * @throws SystemException if a system exception occurred
917            */
918            public static void removeByCompanyId(long companyId)
919                    throws com.liferay.portal.kernel.exception.SystemException {
920                    getPersistence().removeByCompanyId(companyId);
921            }
922    
923            /**
924            * Returns the number of journal folders where companyId = &#63;.
925            *
926            * @param companyId the company ID
927            * @return the number of matching journal folders
928            * @throws SystemException if a system exception occurred
929            */
930            public static int countByCompanyId(long companyId)
931                    throws com.liferay.portal.kernel.exception.SystemException {
932                    return getPersistence().countByCompanyId(companyId);
933            }
934    
935            /**
936            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63;.
937            *
938            * @param groupId the group ID
939            * @param parentFolderId the parent folder ID
940            * @return the matching journal folders
941            * @throws SystemException if a system exception occurred
942            */
943            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P(
944                    long groupId, long parentFolderId)
945                    throws com.liferay.portal.kernel.exception.SystemException {
946                    return getPersistence().findByG_P(groupId, parentFolderId);
947            }
948    
949            /**
950            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
951            *
952            * <p>
953            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
954            * </p>
955            *
956            * @param groupId the group ID
957            * @param parentFolderId the parent folder ID
958            * @param start the lower bound of the range of journal folders
959            * @param end the upper bound of the range of journal folders (not inclusive)
960            * @return the range of matching journal folders
961            * @throws SystemException if a system exception occurred
962            */
963            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P(
964                    long groupId, long parentFolderId, int start, int end)
965                    throws com.liferay.portal.kernel.exception.SystemException {
966                    return getPersistence().findByG_P(groupId, parentFolderId, start, end);
967            }
968    
969            /**
970            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
971            *
972            * <p>
973            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
974            * </p>
975            *
976            * @param groupId the group ID
977            * @param parentFolderId the parent folder ID
978            * @param start the lower bound of the range of journal folders
979            * @param end the upper bound of the range of journal folders (not inclusive)
980            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
981            * @return the ordered range of matching journal folders
982            * @throws SystemException if a system exception occurred
983            */
984            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P(
985                    long groupId, long parentFolderId, int start, int end,
986                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
987                    throws com.liferay.portal.kernel.exception.SystemException {
988                    return getPersistence()
989                                       .findByG_P(groupId, parentFolderId, start, end,
990                            orderByComparator);
991            }
992    
993            /**
994            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
995            *
996            * @param groupId the group ID
997            * @param parentFolderId the parent folder ID
998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
999            * @return the first matching journal folder
1000            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1001            * @throws SystemException if a system exception occurred
1002            */
1003            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_First(
1004                    long groupId, long parentFolderId,
1005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1006                    throws com.liferay.portal.kernel.exception.SystemException,
1007                            com.liferay.portlet.journal.NoSuchFolderException {
1008                    return getPersistence()
1009                                       .findByG_P_First(groupId, parentFolderId, orderByComparator);
1010            }
1011    
1012            /**
1013            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1014            *
1015            * @param groupId the group ID
1016            * @param parentFolderId the parent folder ID
1017            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1018            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1019            * @throws SystemException if a system exception occurred
1020            */
1021            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_First(
1022                    long groupId, long parentFolderId,
1023                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1024                    throws com.liferay.portal.kernel.exception.SystemException {
1025                    return getPersistence()
1026                                       .fetchByG_P_First(groupId, parentFolderId, orderByComparator);
1027            }
1028    
1029            /**
1030            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1031            *
1032            * @param groupId the group ID
1033            * @param parentFolderId the parent folder ID
1034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1035            * @return the last matching journal folder
1036            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1037            * @throws SystemException if a system exception occurred
1038            */
1039            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_Last(
1040                    long groupId, long parentFolderId,
1041                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1042                    throws com.liferay.portal.kernel.exception.SystemException,
1043                            com.liferay.portlet.journal.NoSuchFolderException {
1044                    return getPersistence()
1045                                       .findByG_P_Last(groupId, parentFolderId, orderByComparator);
1046            }
1047    
1048            /**
1049            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1050            *
1051            * @param groupId the group ID
1052            * @param parentFolderId the parent folder ID
1053            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1054            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1055            * @throws SystemException if a system exception occurred
1056            */
1057            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_Last(
1058                    long groupId, long parentFolderId,
1059                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1060                    throws com.liferay.portal.kernel.exception.SystemException {
1061                    return getPersistence()
1062                                       .fetchByG_P_Last(groupId, parentFolderId, orderByComparator);
1063            }
1064    
1065            /**
1066            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1067            *
1068            * @param folderId the primary key of the current journal folder
1069            * @param groupId the group ID
1070            * @param parentFolderId the parent folder ID
1071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1072            * @return the previous, current, and next journal folder
1073            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
1074            * @throws SystemException if a system exception occurred
1075            */
1076            public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_PrevAndNext(
1077                    long folderId, long groupId, long parentFolderId,
1078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1079                    throws com.liferay.portal.kernel.exception.SystemException,
1080                            com.liferay.portlet.journal.NoSuchFolderException {
1081                    return getPersistence()
1082                                       .findByG_P_PrevAndNext(folderId, groupId, parentFolderId,
1083                            orderByComparator);
1084            }
1085    
1086            /**
1087            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1088            *
1089            * @param groupId the group ID
1090            * @param parentFolderId the parent folder ID
1091            * @return the matching journal folders that the user has permission to view
1092            * @throws SystemException if a system exception occurred
1093            */
1094            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P(
1095                    long groupId, long parentFolderId)
1096                    throws com.liferay.portal.kernel.exception.SystemException {
1097                    return getPersistence().filterFindByG_P(groupId, parentFolderId);
1098            }
1099    
1100            /**
1101            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1102            *
1103            * <p>
1104            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1105            * </p>
1106            *
1107            * @param groupId the group ID
1108            * @param parentFolderId the parent folder ID
1109            * @param start the lower bound of the range of journal folders
1110            * @param end the upper bound of the range of journal folders (not inclusive)
1111            * @return the range of matching journal folders that the user has permission to view
1112            * @throws SystemException if a system exception occurred
1113            */
1114            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P(
1115                    long groupId, long parentFolderId, int start, int end)
1116                    throws com.liferay.portal.kernel.exception.SystemException {
1117                    return getPersistence()
1118                                       .filterFindByG_P(groupId, parentFolderId, start, end);
1119            }
1120    
1121            /**
1122            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63;.
1123            *
1124            * <p>
1125            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1126            * </p>
1127            *
1128            * @param groupId the group ID
1129            * @param parentFolderId the parent folder ID
1130            * @param start the lower bound of the range of journal folders
1131            * @param end the upper bound of the range of journal folders (not inclusive)
1132            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1133            * @return the ordered range of matching journal folders that the user has permission to view
1134            * @throws SystemException if a system exception occurred
1135            */
1136            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P(
1137                    long groupId, long parentFolderId, int start, int end,
1138                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1139                    throws com.liferay.portal.kernel.exception.SystemException {
1140                    return getPersistence()
1141                                       .filterFindByG_P(groupId, parentFolderId, start, end,
1142                            orderByComparator);
1143            }
1144    
1145            /**
1146            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1147            *
1148            * @param folderId the primary key of the current journal folder
1149            * @param groupId the group ID
1150            * @param parentFolderId the parent folder ID
1151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1152            * @return the previous, current, and next journal folder
1153            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
1154            * @throws SystemException if a system exception occurred
1155            */
1156            public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_PrevAndNext(
1157                    long folderId, long groupId, long parentFolderId,
1158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1159                    throws com.liferay.portal.kernel.exception.SystemException,
1160                            com.liferay.portlet.journal.NoSuchFolderException {
1161                    return getPersistence()
1162                                       .filterFindByG_P_PrevAndNext(folderId, groupId,
1163                            parentFolderId, orderByComparator);
1164            }
1165    
1166            /**
1167            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; from the database.
1168            *
1169            * @param groupId the group ID
1170            * @param parentFolderId the parent folder ID
1171            * @throws SystemException if a system exception occurred
1172            */
1173            public static void removeByG_P(long groupId, long parentFolderId)
1174                    throws com.liferay.portal.kernel.exception.SystemException {
1175                    getPersistence().removeByG_P(groupId, parentFolderId);
1176            }
1177    
1178            /**
1179            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63;.
1180            *
1181            * @param groupId the group ID
1182            * @param parentFolderId the parent folder ID
1183            * @return the number of matching journal folders
1184            * @throws SystemException if a system exception occurred
1185            */
1186            public static int countByG_P(long groupId, long parentFolderId)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    return getPersistence().countByG_P(groupId, parentFolderId);
1189            }
1190    
1191            /**
1192            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1193            *
1194            * @param groupId the group ID
1195            * @param parentFolderId the parent folder ID
1196            * @return the number of matching journal folders that the user has permission to view
1197            * @throws SystemException if a system exception occurred
1198            */
1199            public static int filterCountByG_P(long groupId, long parentFolderId)
1200                    throws com.liferay.portal.kernel.exception.SystemException {
1201                    return getPersistence().filterCountByG_P(groupId, parentFolderId);
1202            }
1203    
1204            /**
1205            * Returns the journal folder where groupId = &#63; and name = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found.
1206            *
1207            * @param groupId the group ID
1208            * @param name the name
1209            * @return the matching journal folder
1210            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1211            * @throws SystemException if a system exception occurred
1212            */
1213            public static com.liferay.portlet.journal.model.JournalFolder findByG_N(
1214                    long groupId, java.lang.String name)
1215                    throws com.liferay.portal.kernel.exception.SystemException,
1216                            com.liferay.portlet.journal.NoSuchFolderException {
1217                    return getPersistence().findByG_N(groupId, name);
1218            }
1219    
1220            /**
1221            * Returns the journal folder where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1222            *
1223            * @param groupId the group ID
1224            * @param name the name
1225            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1226            * @throws SystemException if a system exception occurred
1227            */
1228            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_N(
1229                    long groupId, java.lang.String name)
1230                    throws com.liferay.portal.kernel.exception.SystemException {
1231                    return getPersistence().fetchByG_N(groupId, name);
1232            }
1233    
1234            /**
1235            * Returns the journal folder where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1236            *
1237            * @param groupId the group ID
1238            * @param name the name
1239            * @param retrieveFromCache whether to use the finder cache
1240            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1241            * @throws SystemException if a system exception occurred
1242            */
1243            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_N(
1244                    long groupId, java.lang.String name, boolean retrieveFromCache)
1245                    throws com.liferay.portal.kernel.exception.SystemException {
1246                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
1247            }
1248    
1249            /**
1250            * Removes the journal folder where groupId = &#63; and name = &#63; from the database.
1251            *
1252            * @param groupId the group ID
1253            * @param name the name
1254            * @return the journal folder that was removed
1255            * @throws SystemException if a system exception occurred
1256            */
1257            public static com.liferay.portlet.journal.model.JournalFolder removeByG_N(
1258                    long groupId, java.lang.String name)
1259                    throws com.liferay.portal.kernel.exception.SystemException,
1260                            com.liferay.portlet.journal.NoSuchFolderException {
1261                    return getPersistence().removeByG_N(groupId, name);
1262            }
1263    
1264            /**
1265            * Returns the number of journal folders where groupId = &#63; and name = &#63;.
1266            *
1267            * @param groupId the group ID
1268            * @param name the name
1269            * @return the number of matching journal folders
1270            * @throws SystemException if a system exception occurred
1271            */
1272            public static int countByG_N(long groupId, java.lang.String name)
1273                    throws com.liferay.portal.kernel.exception.SystemException {
1274                    return getPersistence().countByG_N(groupId, name);
1275            }
1276    
1277            /**
1278            * Returns all the journal folders where companyId = &#63; and status &ne; &#63;.
1279            *
1280            * @param companyId the company ID
1281            * @param status the status
1282            * @return the matching journal folders
1283            * @throws SystemException if a system exception occurred
1284            */
1285            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS(
1286                    long companyId, int status)
1287                    throws com.liferay.portal.kernel.exception.SystemException {
1288                    return getPersistence().findByC_NotS(companyId, status);
1289            }
1290    
1291            /**
1292            * Returns a range of all the journal folders where companyId = &#63; and status &ne; &#63;.
1293            *
1294            * <p>
1295            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1296            * </p>
1297            *
1298            * @param companyId the company ID
1299            * @param status the status
1300            * @param start the lower bound of the range of journal folders
1301            * @param end the upper bound of the range of journal folders (not inclusive)
1302            * @return the range of matching journal folders
1303            * @throws SystemException if a system exception occurred
1304            */
1305            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS(
1306                    long companyId, int status, int start, int end)
1307                    throws com.liferay.portal.kernel.exception.SystemException {
1308                    return getPersistence().findByC_NotS(companyId, status, start, end);
1309            }
1310    
1311            /**
1312            * Returns an ordered range of all the journal folders where companyId = &#63; and status &ne; &#63;.
1313            *
1314            * <p>
1315            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1316            * </p>
1317            *
1318            * @param companyId the company ID
1319            * @param status the status
1320            * @param start the lower bound of the range of journal folders
1321            * @param end the upper bound of the range of journal folders (not inclusive)
1322            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1323            * @return the ordered range of matching journal folders
1324            * @throws SystemException if a system exception occurred
1325            */
1326            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS(
1327                    long companyId, int status, int start, int end,
1328                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1329                    throws com.liferay.portal.kernel.exception.SystemException {
1330                    return getPersistence()
1331                                       .findByC_NotS(companyId, status, start, end,
1332                            orderByComparator);
1333            }
1334    
1335            /**
1336            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1337            *
1338            * @param companyId the company ID
1339            * @param status the status
1340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1341            * @return the first matching journal folder
1342            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1343            * @throws SystemException if a system exception occurred
1344            */
1345            public static com.liferay.portlet.journal.model.JournalFolder findByC_NotS_First(
1346                    long companyId, int status,
1347                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1348                    throws com.liferay.portal.kernel.exception.SystemException,
1349                            com.liferay.portlet.journal.NoSuchFolderException {
1350                    return getPersistence()
1351                                       .findByC_NotS_First(companyId, status, orderByComparator);
1352            }
1353    
1354            /**
1355            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1356            *
1357            * @param companyId the company ID
1358            * @param status the status
1359            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1360            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static com.liferay.portlet.journal.model.JournalFolder fetchByC_NotS_First(
1364                    long companyId, int status,
1365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1366                    throws com.liferay.portal.kernel.exception.SystemException {
1367                    return getPersistence()
1368                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1369            }
1370    
1371            /**
1372            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1373            *
1374            * @param companyId the company ID
1375            * @param status the status
1376            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1377            * @return the last matching journal folder
1378            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1379            * @throws SystemException if a system exception occurred
1380            */
1381            public static com.liferay.portlet.journal.model.JournalFolder findByC_NotS_Last(
1382                    long companyId, int status,
1383                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1384                    throws com.liferay.portal.kernel.exception.SystemException,
1385                            com.liferay.portlet.journal.NoSuchFolderException {
1386                    return getPersistence()
1387                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1388            }
1389    
1390            /**
1391            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1392            *
1393            * @param companyId the company ID
1394            * @param status the status
1395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1396            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1397            * @throws SystemException if a system exception occurred
1398            */
1399            public static com.liferay.portlet.journal.model.JournalFolder fetchByC_NotS_Last(
1400                    long companyId, int status,
1401                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1402                    throws com.liferay.portal.kernel.exception.SystemException {
1403                    return getPersistence()
1404                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1405            }
1406    
1407            /**
1408            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1409            *
1410            * @param folderId the primary key of the current journal folder
1411            * @param companyId the company ID
1412            * @param status the status
1413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1414            * @return the previous, current, and next journal folder
1415            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
1416            * @throws SystemException if a system exception occurred
1417            */
1418            public static com.liferay.portlet.journal.model.JournalFolder[] findByC_NotS_PrevAndNext(
1419                    long folderId, long companyId, int status,
1420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1421                    throws com.liferay.portal.kernel.exception.SystemException,
1422                            com.liferay.portlet.journal.NoSuchFolderException {
1423                    return getPersistence()
1424                                       .findByC_NotS_PrevAndNext(folderId, companyId, status,
1425                            orderByComparator);
1426            }
1427    
1428            /**
1429            * Removes all the journal folders where companyId = &#63; and status &ne; &#63; from the database.
1430            *
1431            * @param companyId the company ID
1432            * @param status the status
1433            * @throws SystemException if a system exception occurred
1434            */
1435            public static void removeByC_NotS(long companyId, int status)
1436                    throws com.liferay.portal.kernel.exception.SystemException {
1437                    getPersistence().removeByC_NotS(companyId, status);
1438            }
1439    
1440            /**
1441            * Returns the number of journal folders where companyId = &#63; and status &ne; &#63;.
1442            *
1443            * @param companyId the company ID
1444            * @param status the status
1445            * @return the number of matching journal folders
1446            * @throws SystemException if a system exception occurred
1447            */
1448            public static int countByC_NotS(long companyId, int status)
1449                    throws com.liferay.portal.kernel.exception.SystemException {
1450                    return getPersistence().countByC_NotS(companyId, status);
1451            }
1452    
1453            /**
1454            * Returns all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1455            *
1456            * @param folderId the folder ID
1457            * @param companyId the company ID
1458            * @param parentFolderId the parent folder ID
1459            * @param status the status
1460            * @return the matching journal folders
1461            * @throws SystemException if a system exception occurred
1462            */
1463            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByF_C_P_NotS(
1464                    long folderId, long companyId, long parentFolderId, int status)
1465                    throws com.liferay.portal.kernel.exception.SystemException {
1466                    return getPersistence()
1467                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId, status);
1468            }
1469    
1470            /**
1471            * Returns a range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1472            *
1473            * <p>
1474            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1475            * </p>
1476            *
1477            * @param folderId the folder ID
1478            * @param companyId the company ID
1479            * @param parentFolderId the parent folder ID
1480            * @param status the status
1481            * @param start the lower bound of the range of journal folders
1482            * @param end the upper bound of the range of journal folders (not inclusive)
1483            * @return the range of matching journal folders
1484            * @throws SystemException if a system exception occurred
1485            */
1486            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByF_C_P_NotS(
1487                    long folderId, long companyId, long parentFolderId, int status,
1488                    int start, int end)
1489                    throws com.liferay.portal.kernel.exception.SystemException {
1490                    return getPersistence()
1491                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1492                            status, start, end);
1493            }
1494    
1495            /**
1496            * Returns an ordered range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1497            *
1498            * <p>
1499            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1500            * </p>
1501            *
1502            * @param folderId the folder ID
1503            * @param companyId the company ID
1504            * @param parentFolderId the parent folder ID
1505            * @param status the status
1506            * @param start the lower bound of the range of journal folders
1507            * @param end the upper bound of the range of journal folders (not inclusive)
1508            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1509            * @return the ordered range of matching journal folders
1510            * @throws SystemException if a system exception occurred
1511            */
1512            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByF_C_P_NotS(
1513                    long folderId, long companyId, long parentFolderId, int status,
1514                    int start, int end,
1515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1516                    throws com.liferay.portal.kernel.exception.SystemException {
1517                    return getPersistence()
1518                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1519                            status, start, end, orderByComparator);
1520            }
1521    
1522            /**
1523            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1524            *
1525            * @param folderId the folder ID
1526            * @param companyId the company ID
1527            * @param parentFolderId the parent folder ID
1528            * @param status the status
1529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1530            * @return the first matching journal folder
1531            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1532            * @throws SystemException if a system exception occurred
1533            */
1534            public static com.liferay.portlet.journal.model.JournalFolder findByF_C_P_NotS_First(
1535                    long folderId, long companyId, long parentFolderId, int status,
1536                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1537                    throws com.liferay.portal.kernel.exception.SystemException,
1538                            com.liferay.portlet.journal.NoSuchFolderException {
1539                    return getPersistence()
1540                                       .findByF_C_P_NotS_First(folderId, companyId, parentFolderId,
1541                            status, orderByComparator);
1542            }
1543    
1544            /**
1545            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1546            *
1547            * @param folderId the folder ID
1548            * @param companyId the company ID
1549            * @param parentFolderId the parent folder ID
1550            * @param status the status
1551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1552            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1553            * @throws SystemException if a system exception occurred
1554            */
1555            public static com.liferay.portlet.journal.model.JournalFolder fetchByF_C_P_NotS_First(
1556                    long folderId, long companyId, long parentFolderId, int status,
1557                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1558                    throws com.liferay.portal.kernel.exception.SystemException {
1559                    return getPersistence()
1560                                       .fetchByF_C_P_NotS_First(folderId, companyId,
1561                            parentFolderId, status, orderByComparator);
1562            }
1563    
1564            /**
1565            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1566            *
1567            * @param folderId the folder ID
1568            * @param companyId the company ID
1569            * @param parentFolderId the parent folder ID
1570            * @param status the status
1571            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1572            * @return the last matching journal folder
1573            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1574            * @throws SystemException if a system exception occurred
1575            */
1576            public static com.liferay.portlet.journal.model.JournalFolder findByF_C_P_NotS_Last(
1577                    long folderId, long companyId, long parentFolderId, int status,
1578                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1579                    throws com.liferay.portal.kernel.exception.SystemException,
1580                            com.liferay.portlet.journal.NoSuchFolderException {
1581                    return getPersistence()
1582                                       .findByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
1583                            status, orderByComparator);
1584            }
1585    
1586            /**
1587            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1588            *
1589            * @param folderId the folder ID
1590            * @param companyId the company ID
1591            * @param parentFolderId the parent folder ID
1592            * @param status the status
1593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1594            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1595            * @throws SystemException if a system exception occurred
1596            */
1597            public static com.liferay.portlet.journal.model.JournalFolder fetchByF_C_P_NotS_Last(
1598                    long folderId, long companyId, long parentFolderId, int status,
1599                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1600                    throws com.liferay.portal.kernel.exception.SystemException {
1601                    return getPersistence()
1602                                       .fetchByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
1603                            status, orderByComparator);
1604            }
1605    
1606            /**
1607            * Removes all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1608            *
1609            * @param folderId the folder ID
1610            * @param companyId the company ID
1611            * @param parentFolderId the parent folder ID
1612            * @param status the status
1613            * @throws SystemException if a system exception occurred
1614            */
1615            public static void removeByF_C_P_NotS(long folderId, long companyId,
1616                    long parentFolderId, int status)
1617                    throws com.liferay.portal.kernel.exception.SystemException {
1618                    getPersistence()
1619                            .removeByF_C_P_NotS(folderId, companyId, parentFolderId, status);
1620            }
1621    
1622            /**
1623            * Returns the number of journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1624            *
1625            * @param folderId the folder ID
1626            * @param companyId the company ID
1627            * @param parentFolderId the parent folder ID
1628            * @param status the status
1629            * @return the number of matching journal folders
1630            * @throws SystemException if a system exception occurred
1631            */
1632            public static int countByF_C_P_NotS(long folderId, long companyId,
1633                    long parentFolderId, int status)
1634                    throws com.liferay.portal.kernel.exception.SystemException {
1635                    return getPersistence()
1636                                       .countByF_C_P_NotS(folderId, companyId, parentFolderId,
1637                            status);
1638            }
1639    
1640            /**
1641            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found.
1642            *
1643            * @param groupId the group ID
1644            * @param parentFolderId the parent folder ID
1645            * @param name the name
1646            * @return the matching journal folder
1647            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1648            * @throws SystemException if a system exception occurred
1649            */
1650            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_N(
1651                    long groupId, long parentFolderId, java.lang.String name)
1652                    throws com.liferay.portal.kernel.exception.SystemException,
1653                            com.liferay.portlet.journal.NoSuchFolderException {
1654                    return getPersistence().findByG_P_N(groupId, parentFolderId, name);
1655            }
1656    
1657            /**
1658            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1659            *
1660            * @param groupId the group ID
1661            * @param parentFolderId the parent folder ID
1662            * @param name the name
1663            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1664            * @throws SystemException if a system exception occurred
1665            */
1666            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N(
1667                    long groupId, long parentFolderId, java.lang.String name)
1668                    throws com.liferay.portal.kernel.exception.SystemException {
1669                    return getPersistence().fetchByG_P_N(groupId, parentFolderId, name);
1670            }
1671    
1672            /**
1673            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1674            *
1675            * @param groupId the group ID
1676            * @param parentFolderId the parent folder ID
1677            * @param name the name
1678            * @param retrieveFromCache whether to use the finder cache
1679            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1680            * @throws SystemException if a system exception occurred
1681            */
1682            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N(
1683                    long groupId, long parentFolderId, java.lang.String name,
1684                    boolean retrieveFromCache)
1685                    throws com.liferay.portal.kernel.exception.SystemException {
1686                    return getPersistence()
1687                                       .fetchByG_P_N(groupId, parentFolderId, name,
1688                            retrieveFromCache);
1689            }
1690    
1691            /**
1692            * Removes the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; from the database.
1693            *
1694            * @param groupId the group ID
1695            * @param parentFolderId the parent folder ID
1696            * @param name the name
1697            * @return the journal folder that was removed
1698            * @throws SystemException if a system exception occurred
1699            */
1700            public static com.liferay.portlet.journal.model.JournalFolder removeByG_P_N(
1701                    long groupId, long parentFolderId, java.lang.String name)
1702                    throws com.liferay.portal.kernel.exception.SystemException,
1703                            com.liferay.portlet.journal.NoSuchFolderException {
1704                    return getPersistence().removeByG_P_N(groupId, parentFolderId, name);
1705            }
1706    
1707            /**
1708            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and name = &#63;.
1709            *
1710            * @param groupId the group ID
1711            * @param parentFolderId the parent folder ID
1712            * @param name the name
1713            * @return the number of matching journal folders
1714            * @throws SystemException if a system exception occurred
1715            */
1716            public static int countByG_P_N(long groupId, long parentFolderId,
1717                    java.lang.String name)
1718                    throws com.liferay.portal.kernel.exception.SystemException {
1719                    return getPersistence().countByG_P_N(groupId, parentFolderId, name);
1720            }
1721    
1722            /**
1723            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1724            *
1725            * @param groupId the group ID
1726            * @param parentFolderId the parent folder ID
1727            * @param status the status
1728            * @return the matching journal folders
1729            * @throws SystemException if a system exception occurred
1730            */
1731            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S(
1732                    long groupId, long parentFolderId, int status)
1733                    throws com.liferay.portal.kernel.exception.SystemException {
1734                    return getPersistence().findByG_P_S(groupId, parentFolderId, status);
1735            }
1736    
1737            /**
1738            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1739            *
1740            * <p>
1741            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1742            * </p>
1743            *
1744            * @param groupId the group ID
1745            * @param parentFolderId the parent folder ID
1746            * @param status the status
1747            * @param start the lower bound of the range of journal folders
1748            * @param end the upper bound of the range of journal folders (not inclusive)
1749            * @return the range of matching journal folders
1750            * @throws SystemException if a system exception occurred
1751            */
1752            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S(
1753                    long groupId, long parentFolderId, int status, int start, int end)
1754                    throws com.liferay.portal.kernel.exception.SystemException {
1755                    return getPersistence()
1756                                       .findByG_P_S(groupId, parentFolderId, status, start, end);
1757            }
1758    
1759            /**
1760            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1761            *
1762            * <p>
1763            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1764            * </p>
1765            *
1766            * @param groupId the group ID
1767            * @param parentFolderId the parent folder ID
1768            * @param status the status
1769            * @param start the lower bound of the range of journal folders
1770            * @param end the upper bound of the range of journal folders (not inclusive)
1771            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1772            * @return the ordered range of matching journal folders
1773            * @throws SystemException if a system exception occurred
1774            */
1775            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S(
1776                    long groupId, long parentFolderId, int status, int start, int end,
1777                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1778                    throws com.liferay.portal.kernel.exception.SystemException {
1779                    return getPersistence()
1780                                       .findByG_P_S(groupId, parentFolderId, status, start, end,
1781                            orderByComparator);
1782            }
1783    
1784            /**
1785            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1786            *
1787            * @param groupId the group ID
1788            * @param parentFolderId the parent folder ID
1789            * @param status the status
1790            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1791            * @return the first matching journal folder
1792            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1793            * @throws SystemException if a system exception occurred
1794            */
1795            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_First(
1796                    long groupId, long parentFolderId, int status,
1797                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1798                    throws com.liferay.portal.kernel.exception.SystemException,
1799                            com.liferay.portlet.journal.NoSuchFolderException {
1800                    return getPersistence()
1801                                       .findByG_P_S_First(groupId, parentFolderId, status,
1802                            orderByComparator);
1803            }
1804    
1805            /**
1806            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1807            *
1808            * @param groupId the group ID
1809            * @param parentFolderId the parent folder ID
1810            * @param status the status
1811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1812            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1813            * @throws SystemException if a system exception occurred
1814            */
1815            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_First(
1816                    long groupId, long parentFolderId, int status,
1817                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1818                    throws com.liferay.portal.kernel.exception.SystemException {
1819                    return getPersistence()
1820                                       .fetchByG_P_S_First(groupId, parentFolderId, status,
1821                            orderByComparator);
1822            }
1823    
1824            /**
1825            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1826            *
1827            * @param groupId the group ID
1828            * @param parentFolderId the parent folder ID
1829            * @param status the status
1830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1831            * @return the last matching journal folder
1832            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
1833            * @throws SystemException if a system exception occurred
1834            */
1835            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_Last(
1836                    long groupId, long parentFolderId, int status,
1837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1838                    throws com.liferay.portal.kernel.exception.SystemException,
1839                            com.liferay.portlet.journal.NoSuchFolderException {
1840                    return getPersistence()
1841                                       .findByG_P_S_Last(groupId, parentFolderId, status,
1842                            orderByComparator);
1843            }
1844    
1845            /**
1846            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1847            *
1848            * @param groupId the group ID
1849            * @param parentFolderId the parent folder ID
1850            * @param status the status
1851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1852            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1853            * @throws SystemException if a system exception occurred
1854            */
1855            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_Last(
1856                    long groupId, long parentFolderId, int status,
1857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1858                    throws com.liferay.portal.kernel.exception.SystemException {
1859                    return getPersistence()
1860                                       .fetchByG_P_S_Last(groupId, parentFolderId, status,
1861                            orderByComparator);
1862            }
1863    
1864            /**
1865            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1866            *
1867            * @param folderId the primary key of the current journal folder
1868            * @param groupId the group ID
1869            * @param parentFolderId the parent folder ID
1870            * @param status the status
1871            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1872            * @return the previous, current, and next journal folder
1873            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
1874            * @throws SystemException if a system exception occurred
1875            */
1876            public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_S_PrevAndNext(
1877                    long folderId, long groupId, long parentFolderId, int status,
1878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1879                    throws com.liferay.portal.kernel.exception.SystemException,
1880                            com.liferay.portlet.journal.NoSuchFolderException {
1881                    return getPersistence()
1882                                       .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId,
1883                            status, orderByComparator);
1884            }
1885    
1886            /**
1887            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1888            *
1889            * @param groupId the group ID
1890            * @param parentFolderId the parent folder ID
1891            * @param status the status
1892            * @return the matching journal folders that the user has permission to view
1893            * @throws SystemException if a system exception occurred
1894            */
1895            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S(
1896                    long groupId, long parentFolderId, int status)
1897                    throws com.liferay.portal.kernel.exception.SystemException {
1898                    return getPersistence()
1899                                       .filterFindByG_P_S(groupId, parentFolderId, status);
1900            }
1901    
1902            /**
1903            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1904            *
1905            * <p>
1906            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1907            * </p>
1908            *
1909            * @param groupId the group ID
1910            * @param parentFolderId the parent folder ID
1911            * @param status the status
1912            * @param start the lower bound of the range of journal folders
1913            * @param end the upper bound of the range of journal folders (not inclusive)
1914            * @return the range of matching journal folders that the user has permission to view
1915            * @throws SystemException if a system exception occurred
1916            */
1917            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S(
1918                    long groupId, long parentFolderId, int status, int start, int end)
1919                    throws com.liferay.portal.kernel.exception.SystemException {
1920                    return getPersistence()
1921                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1922                            end);
1923            }
1924    
1925            /**
1926            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1927            *
1928            * <p>
1929            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
1930            * </p>
1931            *
1932            * @param groupId the group ID
1933            * @param parentFolderId the parent folder ID
1934            * @param status the status
1935            * @param start the lower bound of the range of journal folders
1936            * @param end the upper bound of the range of journal folders (not inclusive)
1937            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1938            * @return the ordered range of matching journal folders that the user has permission to view
1939            * @throws SystemException if a system exception occurred
1940            */
1941            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S(
1942                    long groupId, long parentFolderId, int status, int start, int end,
1943                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1944                    throws com.liferay.portal.kernel.exception.SystemException {
1945                    return getPersistence()
1946                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1947                            end, orderByComparator);
1948            }
1949    
1950            /**
1951            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1952            *
1953            * @param folderId the primary key of the current journal folder
1954            * @param groupId the group ID
1955            * @param parentFolderId the parent folder ID
1956            * @param status the status
1957            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1958            * @return the previous, current, and next journal folder
1959            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
1960            * @throws SystemException if a system exception occurred
1961            */
1962            public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_S_PrevAndNext(
1963                    long folderId, long groupId, long parentFolderId, int status,
1964                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1965                    throws com.liferay.portal.kernel.exception.SystemException,
1966                            com.liferay.portlet.journal.NoSuchFolderException {
1967                    return getPersistence()
1968                                       .filterFindByG_P_S_PrevAndNext(folderId, groupId,
1969                            parentFolderId, status, orderByComparator);
1970            }
1971    
1972            /**
1973            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63; from the database.
1974            *
1975            * @param groupId the group ID
1976            * @param parentFolderId the parent folder ID
1977            * @param status the status
1978            * @throws SystemException if a system exception occurred
1979            */
1980            public static void removeByG_P_S(long groupId, long parentFolderId,
1981                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1982                    getPersistence().removeByG_P_S(groupId, parentFolderId, status);
1983            }
1984    
1985            /**
1986            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1987            *
1988            * @param groupId the group ID
1989            * @param parentFolderId the parent folder ID
1990            * @param status the status
1991            * @return the number of matching journal folders
1992            * @throws SystemException if a system exception occurred
1993            */
1994            public static int countByG_P_S(long groupId, long parentFolderId, int status)
1995                    throws com.liferay.portal.kernel.exception.SystemException {
1996                    return getPersistence().countByG_P_S(groupId, parentFolderId, status);
1997            }
1998    
1999            /**
2000            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
2001            *
2002            * @param groupId the group ID
2003            * @param parentFolderId the parent folder ID
2004            * @param status the status
2005            * @return the number of matching journal folders that the user has permission to view
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static int filterCountByG_P_S(long groupId, long parentFolderId,
2009                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2010                    return getPersistence()
2011                                       .filterCountByG_P_S(groupId, parentFolderId, status);
2012            }
2013    
2014            /**
2015            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2016            *
2017            * @param groupId the group ID
2018            * @param parentFolderId the parent folder ID
2019            * @param status the status
2020            * @return the matching journal folders
2021            * @throws SystemException if a system exception occurred
2022            */
2023            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS(
2024                    long groupId, long parentFolderId, int status)
2025                    throws com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence().findByG_P_NotS(groupId, parentFolderId, status);
2027            }
2028    
2029            /**
2030            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2031            *
2032            * <p>
2033            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2034            * </p>
2035            *
2036            * @param groupId the group ID
2037            * @param parentFolderId the parent folder ID
2038            * @param status the status
2039            * @param start the lower bound of the range of journal folders
2040            * @param end the upper bound of the range of journal folders (not inclusive)
2041            * @return the range of matching journal folders
2042            * @throws SystemException if a system exception occurred
2043            */
2044            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS(
2045                    long groupId, long parentFolderId, int status, int start, int end)
2046                    throws com.liferay.portal.kernel.exception.SystemException {
2047                    return getPersistence()
2048                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end);
2049            }
2050    
2051            /**
2052            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2053            *
2054            * <p>
2055            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2056            * </p>
2057            *
2058            * @param groupId the group ID
2059            * @param parentFolderId the parent folder ID
2060            * @param status the status
2061            * @param start the lower bound of the range of journal folders
2062            * @param end the upper bound of the range of journal folders (not inclusive)
2063            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2064            * @return the ordered range of matching journal folders
2065            * @throws SystemException if a system exception occurred
2066            */
2067            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS(
2068                    long groupId, long parentFolderId, int status, int start, int end,
2069                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2070                    throws com.liferay.portal.kernel.exception.SystemException {
2071                    return getPersistence()
2072                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end,
2073                            orderByComparator);
2074            }
2075    
2076            /**
2077            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2078            *
2079            * @param groupId the group ID
2080            * @param parentFolderId the parent folder ID
2081            * @param status the status
2082            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2083            * @return the first matching journal folder
2084            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
2085            * @throws SystemException if a system exception occurred
2086            */
2087            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_First(
2088                    long groupId, long parentFolderId, int status,
2089                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2090                    throws com.liferay.portal.kernel.exception.SystemException,
2091                            com.liferay.portlet.journal.NoSuchFolderException {
2092                    return getPersistence()
2093                                       .findByG_P_NotS_First(groupId, parentFolderId, status,
2094                            orderByComparator);
2095            }
2096    
2097            /**
2098            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2099            *
2100            * @param groupId the group ID
2101            * @param parentFolderId the parent folder ID
2102            * @param status the status
2103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2104            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
2105            * @throws SystemException if a system exception occurred
2106            */
2107            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_First(
2108                    long groupId, long parentFolderId, int status,
2109                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2110                    throws com.liferay.portal.kernel.exception.SystemException {
2111                    return getPersistence()
2112                                       .fetchByG_P_NotS_First(groupId, parentFolderId, status,
2113                            orderByComparator);
2114            }
2115    
2116            /**
2117            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2118            *
2119            * @param groupId the group ID
2120            * @param parentFolderId the parent folder ID
2121            * @param status the status
2122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2123            * @return the last matching journal folder
2124            * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found
2125            * @throws SystemException if a system exception occurred
2126            */
2127            public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_Last(
2128                    long groupId, long parentFolderId, int status,
2129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2130                    throws com.liferay.portal.kernel.exception.SystemException,
2131                            com.liferay.portlet.journal.NoSuchFolderException {
2132                    return getPersistence()
2133                                       .findByG_P_NotS_Last(groupId, parentFolderId, status,
2134                            orderByComparator);
2135            }
2136    
2137            /**
2138            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2139            *
2140            * @param groupId the group ID
2141            * @param parentFolderId the parent folder ID
2142            * @param status the status
2143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2144            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
2145            * @throws SystemException if a system exception occurred
2146            */
2147            public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_Last(
2148                    long groupId, long parentFolderId, int status,
2149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2150                    throws com.liferay.portal.kernel.exception.SystemException {
2151                    return getPersistence()
2152                                       .fetchByG_P_NotS_Last(groupId, parentFolderId, status,
2153                            orderByComparator);
2154            }
2155    
2156            /**
2157            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2158            *
2159            * @param folderId the primary key of the current journal folder
2160            * @param groupId the group ID
2161            * @param parentFolderId the parent folder ID
2162            * @param status the status
2163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2164            * @return the previous, current, and next journal folder
2165            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
2166            * @throws SystemException if a system exception occurred
2167            */
2168            public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_NotS_PrevAndNext(
2169                    long folderId, long groupId, long parentFolderId, int status,
2170                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2171                    throws com.liferay.portal.kernel.exception.SystemException,
2172                            com.liferay.portlet.journal.NoSuchFolderException {
2173                    return getPersistence()
2174                                       .findByG_P_NotS_PrevAndNext(folderId, groupId,
2175                            parentFolderId, status, orderByComparator);
2176            }
2177    
2178            /**
2179            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2180            *
2181            * @param groupId the group ID
2182            * @param parentFolderId the parent folder ID
2183            * @param status the status
2184            * @return the matching journal folders that the user has permission to view
2185            * @throws SystemException if a system exception occurred
2186            */
2187            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS(
2188                    long groupId, long parentFolderId, int status)
2189                    throws com.liferay.portal.kernel.exception.SystemException {
2190                    return getPersistence()
2191                                       .filterFindByG_P_NotS(groupId, parentFolderId, status);
2192            }
2193    
2194            /**
2195            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2196            *
2197            * <p>
2198            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2199            * </p>
2200            *
2201            * @param groupId the group ID
2202            * @param parentFolderId the parent folder ID
2203            * @param status the status
2204            * @param start the lower bound of the range of journal folders
2205            * @param end the upper bound of the range of journal folders (not inclusive)
2206            * @return the range of matching journal folders that the user has permission to view
2207            * @throws SystemException if a system exception occurred
2208            */
2209            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS(
2210                    long groupId, long parentFolderId, int status, int start, int end)
2211                    throws com.liferay.portal.kernel.exception.SystemException {
2212                    return getPersistence()
2213                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
2214                            start, end);
2215            }
2216    
2217            /**
2218            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2219            *
2220            * <p>
2221            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2222            * </p>
2223            *
2224            * @param groupId the group ID
2225            * @param parentFolderId the parent folder ID
2226            * @param status the status
2227            * @param start the lower bound of the range of journal folders
2228            * @param end the upper bound of the range of journal folders (not inclusive)
2229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2230            * @return the ordered range of matching journal folders that the user has permission to view
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS(
2234                    long groupId, long parentFolderId, int status, int start, int end,
2235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2236                    throws com.liferay.portal.kernel.exception.SystemException {
2237                    return getPersistence()
2238                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
2239                            start, end, orderByComparator);
2240            }
2241    
2242            /**
2243            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2244            *
2245            * @param folderId the primary key of the current journal folder
2246            * @param groupId the group ID
2247            * @param parentFolderId the parent folder ID
2248            * @param status the status
2249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2250            * @return the previous, current, and next journal folder
2251            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
2252            * @throws SystemException if a system exception occurred
2253            */
2254            public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_NotS_PrevAndNext(
2255                    long folderId, long groupId, long parentFolderId, int status,
2256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2257                    throws com.liferay.portal.kernel.exception.SystemException,
2258                            com.liferay.portlet.journal.NoSuchFolderException {
2259                    return getPersistence()
2260                                       .filterFindByG_P_NotS_PrevAndNext(folderId, groupId,
2261                            parentFolderId, status, orderByComparator);
2262            }
2263    
2264            /**
2265            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
2266            *
2267            * @param groupId the group ID
2268            * @param parentFolderId the parent folder ID
2269            * @param status the status
2270            * @throws SystemException if a system exception occurred
2271            */
2272            public static void removeByG_P_NotS(long groupId, long parentFolderId,
2273                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2274                    getPersistence().removeByG_P_NotS(groupId, parentFolderId, status);
2275            }
2276    
2277            /**
2278            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2279            *
2280            * @param groupId the group ID
2281            * @param parentFolderId the parent folder ID
2282            * @param status the status
2283            * @return the number of matching journal folders
2284            * @throws SystemException if a system exception occurred
2285            */
2286            public static int countByG_P_NotS(long groupId, long parentFolderId,
2287                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2288                    return getPersistence().countByG_P_NotS(groupId, parentFolderId, status);
2289            }
2290    
2291            /**
2292            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2293            *
2294            * @param groupId the group ID
2295            * @param parentFolderId the parent folder ID
2296            * @param status the status
2297            * @return the number of matching journal folders that the user has permission to view
2298            * @throws SystemException if a system exception occurred
2299            */
2300            public static int filterCountByG_P_NotS(long groupId, long parentFolderId,
2301                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2302                    return getPersistence()
2303                                       .filterCountByG_P_NotS(groupId, parentFolderId, status);
2304            }
2305    
2306            /**
2307            * Caches the journal folder in the entity cache if it is enabled.
2308            *
2309            * @param journalFolder the journal folder
2310            */
2311            public static void cacheResult(
2312                    com.liferay.portlet.journal.model.JournalFolder journalFolder) {
2313                    getPersistence().cacheResult(journalFolder);
2314            }
2315    
2316            /**
2317            * Caches the journal folders in the entity cache if it is enabled.
2318            *
2319            * @param journalFolders the journal folders
2320            */
2321            public static void cacheResult(
2322                    java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders) {
2323                    getPersistence().cacheResult(journalFolders);
2324            }
2325    
2326            /**
2327            * Creates a new journal folder with the primary key. Does not add the journal folder to the database.
2328            *
2329            * @param folderId the primary key for the new journal folder
2330            * @return the new journal folder
2331            */
2332            public static com.liferay.portlet.journal.model.JournalFolder create(
2333                    long folderId) {
2334                    return getPersistence().create(folderId);
2335            }
2336    
2337            /**
2338            * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners.
2339            *
2340            * @param folderId the primary key of the journal folder
2341            * @return the journal folder that was removed
2342            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
2343            * @throws SystemException if a system exception occurred
2344            */
2345            public static com.liferay.portlet.journal.model.JournalFolder remove(
2346                    long folderId)
2347                    throws com.liferay.portal.kernel.exception.SystemException,
2348                            com.liferay.portlet.journal.NoSuchFolderException {
2349                    return getPersistence().remove(folderId);
2350            }
2351    
2352            public static com.liferay.portlet.journal.model.JournalFolder updateImpl(
2353                    com.liferay.portlet.journal.model.JournalFolder journalFolder)
2354                    throws com.liferay.portal.kernel.exception.SystemException {
2355                    return getPersistence().updateImpl(journalFolder);
2356            }
2357    
2358            /**
2359            * Returns the journal folder with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found.
2360            *
2361            * @param folderId the primary key of the journal folder
2362            * @return the journal folder
2363            * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found
2364            * @throws SystemException if a system exception occurred
2365            */
2366            public static com.liferay.portlet.journal.model.JournalFolder findByPrimaryKey(
2367                    long folderId)
2368                    throws com.liferay.portal.kernel.exception.SystemException,
2369                            com.liferay.portlet.journal.NoSuchFolderException {
2370                    return getPersistence().findByPrimaryKey(folderId);
2371            }
2372    
2373            /**
2374            * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found.
2375            *
2376            * @param folderId the primary key of the journal folder
2377            * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static com.liferay.portlet.journal.model.JournalFolder fetchByPrimaryKey(
2381                    long folderId)
2382                    throws com.liferay.portal.kernel.exception.SystemException {
2383                    return getPersistence().fetchByPrimaryKey(folderId);
2384            }
2385    
2386            /**
2387            * Returns all the journal folders.
2388            *
2389            * @return the journal folders
2390            * @throws SystemException if a system exception occurred
2391            */
2392            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll()
2393                    throws com.liferay.portal.kernel.exception.SystemException {
2394                    return getPersistence().findAll();
2395            }
2396    
2397            /**
2398            * Returns a range of all the journal folders.
2399            *
2400            * <p>
2401            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2402            * </p>
2403            *
2404            * @param start the lower bound of the range of journal folders
2405            * @param end the upper bound of the range of journal folders (not inclusive)
2406            * @return the range of journal folders
2407            * @throws SystemException if a system exception occurred
2408            */
2409            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll(
2410                    int start, int end)
2411                    throws com.liferay.portal.kernel.exception.SystemException {
2412                    return getPersistence().findAll(start, end);
2413            }
2414    
2415            /**
2416            * Returns an ordered range of all the journal folders.
2417            *
2418            * <p>
2419            * 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.portlet.journal.model.impl.JournalFolderModelImpl}. 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.
2420            * </p>
2421            *
2422            * @param start the lower bound of the range of journal folders
2423            * @param end the upper bound of the range of journal folders (not inclusive)
2424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2425            * @return the ordered range of journal folders
2426            * @throws SystemException if a system exception occurred
2427            */
2428            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll(
2429                    int start, int end,
2430                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2431                    throws com.liferay.portal.kernel.exception.SystemException {
2432                    return getPersistence().findAll(start, end, orderByComparator);
2433            }
2434    
2435            /**
2436            * Removes all the journal folders from the database.
2437            *
2438            * @throws SystemException if a system exception occurred
2439            */
2440            public static void removeAll()
2441                    throws com.liferay.portal.kernel.exception.SystemException {
2442                    getPersistence().removeAll();
2443            }
2444    
2445            /**
2446            * Returns the number of journal folders.
2447            *
2448            * @return the number of journal folders
2449            * @throws SystemException if a system exception occurred
2450            */
2451            public static int countAll()
2452                    throws com.liferay.portal.kernel.exception.SystemException {
2453                    return getPersistence().countAll();
2454            }
2455    
2456            public static JournalFolderPersistence getPersistence() {
2457                    if (_persistence == null) {
2458                            _persistence = (JournalFolderPersistence)PortalBeanLocatorUtil.locate(JournalFolderPersistence.class.getName());
2459    
2460                            ReferenceRegistry.registerReference(JournalFolderUtil.class,
2461                                    "_persistence");
2462                    }
2463    
2464                    return _persistence;
2465            }
2466    
2467            /**
2468             * @deprecated As of 6.2.0
2469             */
2470            public void setPersistence(JournalFolderPersistence persistence) {
2471            }
2472    
2473            private static JournalFolderPersistence _persistence;
2474    }