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