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