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 static 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 companyId = &#63; and status &ne; &#63;.
1374            *
1375            * @param companyId the company ID
1376            * @param status the status
1377            * @return the matching bookmarks folders
1378            * @throws SystemException if a system exception occurred
1379            */
1380            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1381                    long companyId, int status)
1382                    throws com.liferay.portal.kernel.exception.SystemException {
1383                    return getPersistence().findByC_NotS(companyId, status);
1384            }
1385    
1386            /**
1387            * Returns a range of all the bookmarks folders where companyId = &#63; and status &ne; &#63;.
1388            *
1389            * <p>
1390            * 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.
1391            * </p>
1392            *
1393            * @param companyId the company ID
1394            * @param status the status
1395            * @param start the lower bound of the range of bookmarks folders
1396            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1397            * @return the range of matching bookmarks folders
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1401                    long companyId, int status, int start, int end)
1402                    throws com.liferay.portal.kernel.exception.SystemException {
1403                    return getPersistence().findByC_NotS(companyId, status, start, end);
1404            }
1405    
1406            /**
1407            * Returns an ordered range of all the bookmarks folders where companyId = &#63; and status &ne; &#63;.
1408            *
1409            * <p>
1410            * 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.
1411            * </p>
1412            *
1413            * @param companyId the company ID
1414            * @param status the status
1415            * @param start the lower bound of the range of bookmarks folders
1416            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1418            * @return the ordered range of matching bookmarks folders
1419            * @throws SystemException if a system exception occurred
1420            */
1421            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1422                    long companyId, int status, int start, int end,
1423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1424                    throws com.liferay.portal.kernel.exception.SystemException {
1425                    return getPersistence()
1426                                       .findByC_NotS(companyId, status, start, end,
1427                            orderByComparator);
1428            }
1429    
1430            /**
1431            * Returns the first bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1432            *
1433            * @param companyId the company ID
1434            * @param status the status
1435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1436            * @return the first matching bookmarks folder
1437            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1438            * @throws SystemException if a system exception occurred
1439            */
1440            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_First(
1441                    long companyId, int status,
1442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1443                    throws com.liferay.portal.kernel.exception.SystemException,
1444                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1445                    return getPersistence()
1446                                       .findByC_NotS_First(companyId, status, orderByComparator);
1447            }
1448    
1449            /**
1450            * Returns the first bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1451            *
1452            * @param companyId the company ID
1453            * @param status the status
1454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1455            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1456            * @throws SystemException if a system exception occurred
1457            */
1458            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_First(
1459                    long companyId, int status,
1460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1461                    throws com.liferay.portal.kernel.exception.SystemException {
1462                    return getPersistence()
1463                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1464            }
1465    
1466            /**
1467            * Returns the last bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1468            *
1469            * @param companyId the company ID
1470            * @param status the status
1471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1472            * @return the last matching bookmarks folder
1473            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1474            * @throws SystemException if a system exception occurred
1475            */
1476            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_Last(
1477                    long companyId, int status,
1478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1479                    throws com.liferay.portal.kernel.exception.SystemException,
1480                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1481                    return getPersistence()
1482                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1483            }
1484    
1485            /**
1486            * Returns the last bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1487            *
1488            * @param companyId the company ID
1489            * @param status the status
1490            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1491            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1492            * @throws SystemException if a system exception occurred
1493            */
1494            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_Last(
1495                    long companyId, int status,
1496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1497                    throws com.liferay.portal.kernel.exception.SystemException {
1498                    return getPersistence()
1499                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1500            }
1501    
1502            /**
1503            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1504            *
1505            * @param folderId the primary key of the current bookmarks folder
1506            * @param companyId the company ID
1507            * @param status the status
1508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1509            * @return the previous, current, and next bookmarks folder
1510            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1511            * @throws SystemException if a system exception occurred
1512            */
1513            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByC_NotS_PrevAndNext(
1514                    long folderId, long companyId, int status,
1515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1516                    throws com.liferay.portal.kernel.exception.SystemException,
1517                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1518                    return getPersistence()
1519                                       .findByC_NotS_PrevAndNext(folderId, companyId, status,
1520                            orderByComparator);
1521            }
1522    
1523            /**
1524            * Removes all the bookmarks folders where companyId = &#63; and status &ne; &#63; from the database.
1525            *
1526            * @param companyId the company ID
1527            * @param status the status
1528            * @throws SystemException if a system exception occurred
1529            */
1530            public static void removeByC_NotS(long companyId, int status)
1531                    throws com.liferay.portal.kernel.exception.SystemException {
1532                    getPersistence().removeByC_NotS(companyId, status);
1533            }
1534    
1535            /**
1536            * Returns the number of bookmarks folders where companyId = &#63; and status &ne; &#63;.
1537            *
1538            * @param companyId the company ID
1539            * @param status the status
1540            * @return the number of matching bookmarks folders
1541            * @throws SystemException if a system exception occurred
1542            */
1543            public static int countByC_NotS(long companyId, int status)
1544                    throws com.liferay.portal.kernel.exception.SystemException {
1545                    return getPersistence().countByC_NotS(companyId, status);
1546            }
1547    
1548            /**
1549            * Returns all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1550            *
1551            * @param groupId the group ID
1552            * @param parentFolderId the parent folder ID
1553            * @param status the status
1554            * @return the matching bookmarks folders
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1558                    long groupId, long parentFolderId, int status)
1559                    throws com.liferay.portal.kernel.exception.SystemException {
1560                    return getPersistence().findByG_P_S(groupId, parentFolderId, status);
1561            }
1562    
1563            /**
1564            * Returns a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1565            *
1566            * <p>
1567            * 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.
1568            * </p>
1569            *
1570            * @param groupId the group ID
1571            * @param parentFolderId the parent folder ID
1572            * @param status the status
1573            * @param start the lower bound of the range of bookmarks folders
1574            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1575            * @return the range of matching bookmarks folders
1576            * @throws SystemException if a system exception occurred
1577            */
1578            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1579                    long groupId, long parentFolderId, int status, int start, int end)
1580                    throws com.liferay.portal.kernel.exception.SystemException {
1581                    return getPersistence()
1582                                       .findByG_P_S(groupId, parentFolderId, status, start, end);
1583            }
1584    
1585            /**
1586            * Returns an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1587            *
1588            * <p>
1589            * 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.
1590            * </p>
1591            *
1592            * @param groupId the group ID
1593            * @param parentFolderId the parent folder ID
1594            * @param status the status
1595            * @param start the lower bound of the range of bookmarks folders
1596            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1597            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1598            * @return the ordered range of matching bookmarks folders
1599            * @throws SystemException if a system exception occurred
1600            */
1601            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1602                    long groupId, long parentFolderId, int status, int start, int end,
1603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1604                    throws com.liferay.portal.kernel.exception.SystemException {
1605                    return getPersistence()
1606                                       .findByG_P_S(groupId, parentFolderId, status, start, end,
1607                            orderByComparator);
1608            }
1609    
1610            /**
1611            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1612            *
1613            * @param groupId the group ID
1614            * @param parentFolderId the parent folder ID
1615            * @param status the status
1616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1617            * @return the first matching bookmarks folder
1618            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1619            * @throws SystemException if a system exception occurred
1620            */
1621            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_First(
1622                    long groupId, long parentFolderId, int status,
1623                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1624                    throws com.liferay.portal.kernel.exception.SystemException,
1625                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1626                    return getPersistence()
1627                                       .findByG_P_S_First(groupId, parentFolderId, status,
1628                            orderByComparator);
1629            }
1630    
1631            /**
1632            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1633            *
1634            * @param groupId the group ID
1635            * @param parentFolderId the parent folder ID
1636            * @param status the status
1637            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1638            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1639            * @throws SystemException if a system exception occurred
1640            */
1641            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_First(
1642                    long groupId, long parentFolderId, int status,
1643                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1644                    throws com.liferay.portal.kernel.exception.SystemException {
1645                    return getPersistence()
1646                                       .fetchByG_P_S_First(groupId, parentFolderId, status,
1647                            orderByComparator);
1648            }
1649    
1650            /**
1651            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1652            *
1653            * @param groupId the group ID
1654            * @param parentFolderId the parent folder ID
1655            * @param status the status
1656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1657            * @return the last matching bookmarks folder
1658            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1659            * @throws SystemException if a system exception occurred
1660            */
1661            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_Last(
1662                    long groupId, long parentFolderId, int status,
1663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1664                    throws com.liferay.portal.kernel.exception.SystemException,
1665                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1666                    return getPersistence()
1667                                       .findByG_P_S_Last(groupId, parentFolderId, status,
1668                            orderByComparator);
1669            }
1670    
1671            /**
1672            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1673            *
1674            * @param groupId the group ID
1675            * @param parentFolderId the parent folder ID
1676            * @param status the status
1677            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1678            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1679            * @throws SystemException if a system exception occurred
1680            */
1681            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_Last(
1682                    long groupId, long parentFolderId, int status,
1683                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1684                    throws com.liferay.portal.kernel.exception.SystemException {
1685                    return getPersistence()
1686                                       .fetchByG_P_S_Last(groupId, parentFolderId, status,
1687                            orderByComparator);
1688            }
1689    
1690            /**
1691            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1692            *
1693            * @param folderId the primary key of the current bookmarks folder
1694            * @param groupId the group ID
1695            * @param parentFolderId the parent folder ID
1696            * @param status the status
1697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1698            * @return the previous, current, and next bookmarks folder
1699            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1700            * @throws SystemException if a system exception occurred
1701            */
1702            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_S_PrevAndNext(
1703                    long folderId, long groupId, long parentFolderId, int status,
1704                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1705                    throws com.liferay.portal.kernel.exception.SystemException,
1706                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1707                    return getPersistence()
1708                                       .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId,
1709                            status, orderByComparator);
1710            }
1711    
1712            /**
1713            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1714            *
1715            * @param groupId the group ID
1716            * @param parentFolderId the parent folder ID
1717            * @param status the status
1718            * @return the matching bookmarks folders that the user has permission to view
1719            * @throws SystemException if a system exception occurred
1720            */
1721            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1722                    long groupId, long parentFolderId, int status)
1723                    throws com.liferay.portal.kernel.exception.SystemException {
1724                    return getPersistence()
1725                                       .filterFindByG_P_S(groupId, parentFolderId, status);
1726            }
1727    
1728            /**
1729            * Returns a range of all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1730            *
1731            * <p>
1732            * 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.
1733            * </p>
1734            *
1735            * @param groupId the group ID
1736            * @param parentFolderId the parent folder ID
1737            * @param status the status
1738            * @param start the lower bound of the range of bookmarks folders
1739            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1740            * @return the range of matching bookmarks folders that the user has permission to view
1741            * @throws SystemException if a system exception occurred
1742            */
1743            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1744                    long groupId, long parentFolderId, int status, int start, int end)
1745                    throws com.liferay.portal.kernel.exception.SystemException {
1746                    return getPersistence()
1747                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1748                            end);
1749            }
1750    
1751            /**
1752            * 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;.
1753            *
1754            * <p>
1755            * 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.
1756            * </p>
1757            *
1758            * @param groupId the group ID
1759            * @param parentFolderId the parent folder ID
1760            * @param status the status
1761            * @param start the lower bound of the range of bookmarks folders
1762            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1763            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1764            * @return the ordered range of matching bookmarks folders that the user has permission to view
1765            * @throws SystemException if a system exception occurred
1766            */
1767            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1768                    long groupId, long parentFolderId, int status, int start, int end,
1769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1770                    throws com.liferay.portal.kernel.exception.SystemException {
1771                    return getPersistence()
1772                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1773                            end, orderByComparator);
1774            }
1775    
1776            /**
1777            * 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;.
1778            *
1779            * @param folderId the primary key of the current bookmarks folder
1780            * @param groupId the group ID
1781            * @param parentFolderId the parent folder ID
1782            * @param status the status
1783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1784            * @return the previous, current, and next bookmarks folder
1785            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1786            * @throws SystemException if a system exception occurred
1787            */
1788            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_S_PrevAndNext(
1789                    long folderId, long groupId, long parentFolderId, int status,
1790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1791                    throws com.liferay.portal.kernel.exception.SystemException,
1792                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1793                    return getPersistence()
1794                                       .filterFindByG_P_S_PrevAndNext(folderId, groupId,
1795                            parentFolderId, status, orderByComparator);
1796            }
1797    
1798            /**
1799            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63; from the database.
1800            *
1801            * @param groupId the group ID
1802            * @param parentFolderId the parent folder ID
1803            * @param status the status
1804            * @throws SystemException if a system exception occurred
1805            */
1806            public static void removeByG_P_S(long groupId, long parentFolderId,
1807                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1808                    getPersistence().removeByG_P_S(groupId, parentFolderId, status);
1809            }
1810    
1811            /**
1812            * Returns the number of bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1813            *
1814            * @param groupId the group ID
1815            * @param parentFolderId the parent folder ID
1816            * @param status the status
1817            * @return the number of matching bookmarks folders
1818            * @throws SystemException if a system exception occurred
1819            */
1820            public static int countByG_P_S(long groupId, long parentFolderId, int status)
1821                    throws com.liferay.portal.kernel.exception.SystemException {
1822                    return getPersistence().countByG_P_S(groupId, parentFolderId, status);
1823            }
1824    
1825            /**
1826            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1827            *
1828            * @param groupId the group ID
1829            * @param parentFolderId the parent folder ID
1830            * @param status the status
1831            * @return the number of matching bookmarks folders that the user has permission to view
1832            * @throws SystemException if a system exception occurred
1833            */
1834            public static int filterCountByG_P_S(long groupId, long parentFolderId,
1835                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1836                    return getPersistence()
1837                                       .filterCountByG_P_S(groupId, parentFolderId, status);
1838            }
1839    
1840            /**
1841            * Returns all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1842            *
1843            * @param groupId the group ID
1844            * @param parentFolderId the parent folder ID
1845            * @param status the status
1846            * @return the matching bookmarks folders
1847            * @throws SystemException if a system exception occurred
1848            */
1849            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1850                    long groupId, long parentFolderId, int status)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence().findByG_P_NotS(groupId, parentFolderId, status);
1853            }
1854    
1855            /**
1856            * Returns a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1857            *
1858            * <p>
1859            * 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.
1860            * </p>
1861            *
1862            * @param groupId the group ID
1863            * @param parentFolderId the parent folder ID
1864            * @param status the status
1865            * @param start the lower bound of the range of bookmarks folders
1866            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1867            * @return the range of matching bookmarks folders
1868            * @throws SystemException if a system exception occurred
1869            */
1870            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1871                    long groupId, long parentFolderId, int status, int start, int end)
1872                    throws com.liferay.portal.kernel.exception.SystemException {
1873                    return getPersistence()
1874                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end);
1875            }
1876    
1877            /**
1878            * Returns an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1879            *
1880            * <p>
1881            * 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.
1882            * </p>
1883            *
1884            * @param groupId the group ID
1885            * @param parentFolderId the parent folder ID
1886            * @param status the status
1887            * @param start the lower bound of the range of bookmarks folders
1888            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1889            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1890            * @return the ordered range of matching bookmarks folders
1891            * @throws SystemException if a system exception occurred
1892            */
1893            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1894                    long groupId, long parentFolderId, int status, int start, int end,
1895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1896                    throws com.liferay.portal.kernel.exception.SystemException {
1897                    return getPersistence()
1898                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end,
1899                            orderByComparator);
1900            }
1901    
1902            /**
1903            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1904            *
1905            * @param groupId the group ID
1906            * @param parentFolderId the parent folder ID
1907            * @param status the status
1908            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1909            * @return the first matching bookmarks folder
1910            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1911            * @throws SystemException if a system exception occurred
1912            */
1913            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_First(
1914                    long groupId, long parentFolderId, int status,
1915                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1916                    throws com.liferay.portal.kernel.exception.SystemException,
1917                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1918                    return getPersistence()
1919                                       .findByG_P_NotS_First(groupId, parentFolderId, status,
1920                            orderByComparator);
1921            }
1922    
1923            /**
1924            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1925            *
1926            * @param groupId the group ID
1927            * @param parentFolderId the parent folder ID
1928            * @param status the status
1929            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1930            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_First(
1934                    long groupId, long parentFolderId, int status,
1935                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1936                    throws com.liferay.portal.kernel.exception.SystemException {
1937                    return getPersistence()
1938                                       .fetchByG_P_NotS_First(groupId, parentFolderId, status,
1939                            orderByComparator);
1940            }
1941    
1942            /**
1943            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1944            *
1945            * @param groupId the group ID
1946            * @param parentFolderId the parent folder ID
1947            * @param status the status
1948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1949            * @return the last matching bookmarks folder
1950            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1951            * @throws SystemException if a system exception occurred
1952            */
1953            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_Last(
1954                    long groupId, long parentFolderId, int status,
1955                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1956                    throws com.liferay.portal.kernel.exception.SystemException,
1957                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1958                    return getPersistence()
1959                                       .findByG_P_NotS_Last(groupId, parentFolderId, status,
1960                            orderByComparator);
1961            }
1962    
1963            /**
1964            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1965            *
1966            * @param groupId the group ID
1967            * @param parentFolderId the parent folder ID
1968            * @param status the status
1969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1970            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1971            * @throws SystemException if a system exception occurred
1972            */
1973            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_Last(
1974                    long groupId, long parentFolderId, int status,
1975                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1976                    throws com.liferay.portal.kernel.exception.SystemException {
1977                    return getPersistence()
1978                                       .fetchByG_P_NotS_Last(groupId, parentFolderId, status,
1979                            orderByComparator);
1980            }
1981    
1982            /**
1983            * 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;.
1984            *
1985            * @param folderId the primary key of the current bookmarks folder
1986            * @param groupId the group ID
1987            * @param parentFolderId the parent folder ID
1988            * @param status the status
1989            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1990            * @return the previous, current, and next bookmarks folder
1991            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1992            * @throws SystemException if a system exception occurred
1993            */
1994            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_NotS_PrevAndNext(
1995                    long folderId, long groupId, long parentFolderId, int status,
1996                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1997                    throws com.liferay.portal.kernel.exception.SystemException,
1998                            com.liferay.portlet.bookmarks.NoSuchFolderException {
1999                    return getPersistence()
2000                                       .findByG_P_NotS_PrevAndNext(folderId, groupId,
2001                            parentFolderId, status, orderByComparator);
2002            }
2003    
2004            /**
2005            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2006            *
2007            * @param groupId the group ID
2008            * @param parentFolderId the parent folder ID
2009            * @param status the status
2010            * @return the matching bookmarks folders that the user has permission to view
2011            * @throws SystemException if a system exception occurred
2012            */
2013            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
2014                    long groupId, long parentFolderId, int status)
2015                    throws com.liferay.portal.kernel.exception.SystemException {
2016                    return getPersistence()
2017                                       .filterFindByG_P_NotS(groupId, parentFolderId, status);
2018            }
2019    
2020            /**
2021            * 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;.
2022            *
2023            * <p>
2024            * 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.
2025            * </p>
2026            *
2027            * @param groupId the group ID
2028            * @param parentFolderId the parent folder ID
2029            * @param status the status
2030            * @param start the lower bound of the range of bookmarks folders
2031            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2032            * @return the range of matching bookmarks folders that the user has permission to view
2033            * @throws SystemException if a system exception occurred
2034            */
2035            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
2036                    long groupId, long parentFolderId, int status, int start, int end)
2037                    throws com.liferay.portal.kernel.exception.SystemException {
2038                    return getPersistence()
2039                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
2040                            start, end);
2041            }
2042    
2043            /**
2044            * 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;.
2045            *
2046            * <p>
2047            * 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.
2048            * </p>
2049            *
2050            * @param groupId the group ID
2051            * @param parentFolderId the parent folder ID
2052            * @param status the status
2053            * @param start the lower bound of the range of bookmarks folders
2054            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2055            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2056            * @return the ordered range of matching bookmarks folders that the user has permission to view
2057            * @throws SystemException if a system exception occurred
2058            */
2059            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
2060                    long groupId, long parentFolderId, int status, int start, int end,
2061                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2062                    throws com.liferay.portal.kernel.exception.SystemException {
2063                    return getPersistence()
2064                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
2065                            start, end, orderByComparator);
2066            }
2067    
2068            /**
2069            * 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;.
2070            *
2071            * @param folderId the primary key of the current bookmarks folder
2072            * @param groupId the group ID
2073            * @param parentFolderId the parent folder ID
2074            * @param status the status
2075            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2076            * @return the previous, current, and next bookmarks folder
2077            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
2078            * @throws SystemException if a system exception occurred
2079            */
2080            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_NotS_PrevAndNext(
2081                    long folderId, long groupId, long parentFolderId, int status,
2082                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2083                    throws com.liferay.portal.kernel.exception.SystemException,
2084                            com.liferay.portlet.bookmarks.NoSuchFolderException {
2085                    return getPersistence()
2086                                       .filterFindByG_P_NotS_PrevAndNext(folderId, groupId,
2087                            parentFolderId, status, orderByComparator);
2088            }
2089    
2090            /**
2091            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
2092            *
2093            * @param groupId the group ID
2094            * @param parentFolderId the parent folder ID
2095            * @param status the status
2096            * @throws SystemException if a system exception occurred
2097            */
2098            public static void removeByG_P_NotS(long groupId, long parentFolderId,
2099                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2100                    getPersistence().removeByG_P_NotS(groupId, parentFolderId, status);
2101            }
2102    
2103            /**
2104            * Returns the number of bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2105            *
2106            * @param groupId the group ID
2107            * @param parentFolderId the parent folder ID
2108            * @param status the status
2109            * @return the number of matching bookmarks folders
2110            * @throws SystemException if a system exception occurred
2111            */
2112            public static int countByG_P_NotS(long groupId, long parentFolderId,
2113                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2114                    return getPersistence().countByG_P_NotS(groupId, parentFolderId, status);
2115            }
2116    
2117            /**
2118            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2119            *
2120            * @param groupId the group ID
2121            * @param parentFolderId the parent folder ID
2122            * @param status the status
2123            * @return the number of matching bookmarks folders that the user has permission to view
2124            * @throws SystemException if a system exception occurred
2125            */
2126            public static int filterCountByG_P_NotS(long groupId, long parentFolderId,
2127                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2128                    return getPersistence()
2129                                       .filterCountByG_P_NotS(groupId, parentFolderId, status);
2130            }
2131    
2132            /**
2133            * Caches the bookmarks folder in the entity cache if it is enabled.
2134            *
2135            * @param bookmarksFolder the bookmarks folder
2136            */
2137            public static void cacheResult(
2138                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) {
2139                    getPersistence().cacheResult(bookmarksFolder);
2140            }
2141    
2142            /**
2143            * Caches the bookmarks folders in the entity cache if it is enabled.
2144            *
2145            * @param bookmarksFolders the bookmarks folders
2146            */
2147            public static void cacheResult(
2148                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) {
2149                    getPersistence().cacheResult(bookmarksFolders);
2150            }
2151    
2152            /**
2153            * Creates a new bookmarks folder with the primary key. Does not add the bookmarks folder to the database.
2154            *
2155            * @param folderId the primary key for the new bookmarks folder
2156            * @return the new bookmarks folder
2157            */
2158            public static com.liferay.portlet.bookmarks.model.BookmarksFolder create(
2159                    long folderId) {
2160                    return getPersistence().create(folderId);
2161            }
2162    
2163            /**
2164            * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners.
2165            *
2166            * @param folderId the primary key of the bookmarks folder
2167            * @return the bookmarks folder that was removed
2168            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
2169            * @throws SystemException if a system exception occurred
2170            */
2171            public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove(
2172                    long folderId)
2173                    throws com.liferay.portal.kernel.exception.SystemException,
2174                            com.liferay.portlet.bookmarks.NoSuchFolderException {
2175                    return getPersistence().remove(folderId);
2176            }
2177    
2178            public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl(
2179                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder)
2180                    throws com.liferay.portal.kernel.exception.SystemException {
2181                    return getPersistence().updateImpl(bookmarksFolder);
2182            }
2183    
2184            /**
2185            * Returns the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found.
2186            *
2187            * @param folderId the primary key of the bookmarks folder
2188            * @return the bookmarks folder
2189            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
2190            * @throws SystemException if a system exception occurred
2191            */
2192            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey(
2193                    long folderId)
2194                    throws com.liferay.portal.kernel.exception.SystemException,
2195                            com.liferay.portlet.bookmarks.NoSuchFolderException {
2196                    return getPersistence().findByPrimaryKey(folderId);
2197            }
2198    
2199            /**
2200            * Returns the bookmarks folder with the primary key or returns <code>null</code> if it could not be found.
2201            *
2202            * @param folderId the primary key of the bookmarks folder
2203            * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found
2204            * @throws SystemException if a system exception occurred
2205            */
2206            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey(
2207                    long folderId)
2208                    throws com.liferay.portal.kernel.exception.SystemException {
2209                    return getPersistence().fetchByPrimaryKey(folderId);
2210            }
2211    
2212            /**
2213            * Returns all the bookmarks folders.
2214            *
2215            * @return the bookmarks folders
2216            * @throws SystemException if a system exception occurred
2217            */
2218            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll()
2219                    throws com.liferay.portal.kernel.exception.SystemException {
2220                    return getPersistence().findAll();
2221            }
2222    
2223            /**
2224            * Returns a range of all the bookmarks folders.
2225            *
2226            * <p>
2227            * 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.
2228            * </p>
2229            *
2230            * @param start the lower bound of the range of bookmarks folders
2231            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2232            * @return the range of bookmarks folders
2233            * @throws SystemException if a system exception occurred
2234            */
2235            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
2236                    int start, int end)
2237                    throws com.liferay.portal.kernel.exception.SystemException {
2238                    return getPersistence().findAll(start, end);
2239            }
2240    
2241            /**
2242            * Returns an ordered range of all the bookmarks folders.
2243            *
2244            * <p>
2245            * 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.
2246            * </p>
2247            *
2248            * @param start the lower bound of the range of bookmarks folders
2249            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2250            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2251            * @return the ordered range of bookmarks folders
2252            * @throws SystemException if a system exception occurred
2253            */
2254            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
2255                    int start, int end,
2256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2257                    throws com.liferay.portal.kernel.exception.SystemException {
2258                    return getPersistence().findAll(start, end, orderByComparator);
2259            }
2260    
2261            /**
2262            * Removes all the bookmarks folders from the database.
2263            *
2264            * @throws SystemException if a system exception occurred
2265            */
2266            public static void removeAll()
2267                    throws com.liferay.portal.kernel.exception.SystemException {
2268                    getPersistence().removeAll();
2269            }
2270    
2271            /**
2272            * Returns the number of bookmarks folders.
2273            *
2274            * @return the number of bookmarks folders
2275            * @throws SystemException if a system exception occurred
2276            */
2277            public static int countAll()
2278                    throws com.liferay.portal.kernel.exception.SystemException {
2279                    return getPersistence().countAll();
2280            }
2281    
2282            public static BookmarksFolderPersistence getPersistence() {
2283                    if (_persistence == null) {
2284                            _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName());
2285    
2286                            ReferenceRegistry.registerReference(BookmarksFolderUtil.class,
2287                                    "_persistence");
2288                    }
2289    
2290                    return _persistence;
2291            }
2292    
2293            /**
2294             * @deprecated As of 6.2.0
2295             */
2296            public void setPersistence(BookmarksFolderPersistence persistence) {
2297            }
2298    
2299            private static BookmarksFolderPersistence _persistence;
2300    }