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