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.BookmarksEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the bookmarks entry service. This utility wraps {@link BookmarksEntryPersistenceImpl} 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 BookmarksEntryPersistence
037     * @see BookmarksEntryPersistenceImpl
038     * @generated
039     */
040    public class BookmarksEntryUtil {
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(BookmarksEntry bookmarksEntry) {
058                    getPersistence().clearCache(bookmarksEntry);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BookmarksEntry> 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<BookmarksEntry> 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<BookmarksEntry> 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 BookmarksEntry update(BookmarksEntry bookmarksEntry)
101                    throws SystemException {
102                    return getPersistence().update(bookmarksEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(bookmarksEntry, serviceContext);
111            }
112    
113            /**
114            * Returns all the bookmarks entries where resourceBlockId = &#63;.
115            *
116            * @param resourceBlockId the resource block ID
117            * @return the matching bookmarks entries
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
135            * @param end the upper bound of the range of bookmarks entries (not inclusive)
136            * @return the range of matching bookmarks entries
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
155            * @param end the upper bound of the range of bookmarks entries (not inclusive)
156            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
157            * @return the ordered range of matching bookmarks entries
158            * @throws SystemException if a system exception occurred
159            */
160            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entry 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 entry
175            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
183                    return getPersistence()
184                                       .findByResourceBlockId_First(resourceBlockId,
185                            orderByComparator);
186            }
187    
188            /**
189            * Returns the first bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
194            * @throws SystemException if a system exception occurred
195            */
196            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entry 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 entry
211            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
212            * @throws SystemException if a system exception occurred
213            */
214            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
219                    return getPersistence()
220                                       .findByResourceBlockId_Last(resourceBlockId,
221                            orderByComparator);
222            }
223    
224            /**
225            * Returns the last bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
230            * @throws SystemException if a system exception occurred
231            */
232            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entries before and after the current bookmarks entry in the ordered set where resourceBlockId = &#63;.
243            *
244            * @param entryId the primary key of the current bookmarks entry
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 entry
248            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry 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.BookmarksEntry[] findByResourceBlockId_PrevAndNext(
252                    long entryId, long resourceBlockId,
253                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
254                    throws com.liferay.portal.kernel.exception.SystemException,
255                            com.liferay.portlet.bookmarks.NoSuchEntryException {
256                    return getPersistence()
257                                       .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId,
258                            orderByComparator);
259            }
260    
261            /**
262            * Removes all the bookmarks entries 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 entries where resourceBlockId = &#63;.
274            *
275            * @param resourceBlockId the resource block ID
276            * @return the number of matching bookmarks entries
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 entries where uuid = &#63;.
286            *
287            * @param uuid the uuid
288            * @return the matching bookmarks entries
289            * @throws SystemException if a system exception occurred
290            */
291            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
306            * @param end the upper bound of the range of bookmarks entries (not inclusive)
307            * @return the range of matching bookmarks entries
308            * @throws SystemException if a system exception occurred
309            */
310            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
325            * @param end the upper bound of the range of bookmarks entries (not inclusive)
326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
327            * @return the ordered range of matching bookmarks entries
328            * @throws SystemException if a system exception occurred
329            */
330            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entry 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 entry
343            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
344            * @throws SystemException if a system exception occurred
345            */
346            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
351                    return getPersistence().findByUuid_First(uuid, orderByComparator);
352            }
353    
354            /**
355            * Returns the first bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
360            * @throws SystemException if a system exception occurred
361            */
362            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entry 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 entry
375            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
376            * @throws SystemException if a system exception occurred
377            */
378            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
383                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
384            }
385    
386            /**
387            * Returns the last bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
392            * @throws SystemException if a system exception occurred
393            */
394            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entries before and after the current bookmarks entry in the ordered set where uuid = &#63;.
403            *
404            * @param entryId the primary key of the current bookmarks entry
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 entry
408            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry 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.BookmarksEntry[] findByUuid_PrevAndNext(
412                    long entryId, 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.NoSuchEntryException {
416                    return getPersistence()
417                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
418            }
419    
420            /**
421            * Removes all the bookmarks entries 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 entries where uuid = &#63;.
433            *
434            * @param uuid the uuid
435            * @return the number of matching bookmarks entries
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 entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
445            *
446            * @param uuid the uuid
447            * @param groupId the group ID
448            * @return the matching bookmarks entry
449            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
450            * @throws SystemException if a system exception occurred
451            */
452            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G(
453                    java.lang.String uuid, long groupId)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.bookmarks.NoSuchEntryException {
456                    return getPersistence().findByUUID_G(uuid, groupId);
457            }
458    
459            /**
460            * Returns the bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
480            * @throws SystemException if a system exception occurred
481            */
482            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entry 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 entry that was removed
494            * @throws SystemException if a system exception occurred
495            */
496            public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G(
497                    java.lang.String uuid, long groupId)
498                    throws com.liferay.portal.kernel.exception.SystemException,
499                            com.liferay.portlet.bookmarks.NoSuchEntryException {
500                    return getPersistence().removeByUUID_G(uuid, groupId);
501            }
502    
503            /**
504            * Returns the number of bookmarks entries 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 entries
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 entries where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @return the matching bookmarks entries
522            * @throws SystemException if a system exception occurred
523            */
524            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
540            * @param end the upper bound of the range of bookmarks entries (not inclusive)
541            * @return the range of matching bookmarks entries
542            * @throws SystemException if a system exception occurred
543            */
544            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entries 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.BookmarksEntryModelImpl}. 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 entries
560            * @param end the upper bound of the range of bookmarks entries (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @return the ordered range of matching bookmarks entries
563            * @throws SystemException if a system exception occurred
564            */
565            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> 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 entry 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 entry
580            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
588                    return getPersistence()
589                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
590            }
591    
592            /**
593            * Returns the first bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
599            * @throws SystemException if a system exception occurred
600            */
601            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entry 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 entry
616            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
617            * @throws SystemException if a system exception occurred
618            */
619            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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.NoSuchEntryException {
624                    return getPersistence()
625                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
626            }
627    
628            /**
629            * Returns the last bookmarks entry 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 entry, or <code>null</code> if a matching bookmarks entry could not be found
635            * @throws SystemException if a system exception occurred
636            */
637            public static com.liferay.portlet.bookmarks.model.BookmarksEntry 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 entries before and after the current bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
647            *
648            * @param entryId the primary key of the current bookmarks entry
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 entry
653            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry 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.BookmarksEntry[] findByUuid_C_PrevAndNext(
657                    long entryId, 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.NoSuchEntryException {
661                    return getPersistence()
662                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
663                            orderByComparator);
664            }
665    
666            /**
667            * Removes all the bookmarks entries 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 entries 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 entries
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 entries where groupId = &#63; and folderId = &#63;.
693            *
694            * @param groupId the group ID
695            * @param folderId the folder ID
696            * @return the matching bookmarks entries
697            * @throws SystemException if a system exception occurred
698            */
699            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
700                    long groupId, long folderId)
701                    throws com.liferay.portal.kernel.exception.SystemException {
702                    return getPersistence().findByG_F(groupId, folderId);
703            }
704    
705            /**
706            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
707            *
708            * <p>
709            * 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.BookmarksEntryModelImpl}. 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.
710            * </p>
711            *
712            * @param groupId the group ID
713            * @param folderId the folder ID
714            * @param start the lower bound of the range of bookmarks entries
715            * @param end the upper bound of the range of bookmarks entries (not inclusive)
716            * @return the range of matching bookmarks entries
717            * @throws SystemException if a system exception occurred
718            */
719            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
720                    long groupId, long folderId, int start, int end)
721                    throws com.liferay.portal.kernel.exception.SystemException {
722                    return getPersistence().findByG_F(groupId, folderId, start, end);
723            }
724    
725            /**
726            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
727            *
728            * <p>
729            * 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.BookmarksEntryModelImpl}. 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.
730            * </p>
731            *
732            * @param groupId the group ID
733            * @param folderId the folder ID
734            * @param start the lower bound of the range of bookmarks entries
735            * @param end the upper bound of the range of bookmarks entries (not inclusive)
736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
737            * @return the ordered range of matching bookmarks entries
738            * @throws SystemException if a system exception occurred
739            */
740            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
741                    long groupId, long folderId, int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
743                    throws com.liferay.portal.kernel.exception.SystemException {
744                    return getPersistence()
745                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
746            }
747    
748            /**
749            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
750            *
751            * @param groupId the group ID
752            * @param folderId the folder ID
753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
754            * @return the first matching bookmarks entry
755            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
756            * @throws SystemException if a system exception occurred
757            */
758            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
759                    long groupId, long folderId,
760                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
761                    throws com.liferay.portal.kernel.exception.SystemException,
762                            com.liferay.portlet.bookmarks.NoSuchEntryException {
763                    return getPersistence()
764                                       .findByG_F_First(groupId, folderId, orderByComparator);
765            }
766    
767            /**
768            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
769            *
770            * @param groupId the group ID
771            * @param folderId the folder ID
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
774            * @throws SystemException if a system exception occurred
775            */
776            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First(
777                    long groupId, long folderId,
778                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    return getPersistence()
781                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
782            }
783    
784            /**
785            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
786            *
787            * @param groupId the group ID
788            * @param folderId the folder ID
789            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
790            * @return the last matching bookmarks entry
791            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
792            * @throws SystemException if a system exception occurred
793            */
794            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
795                    long groupId, long folderId,
796                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
797                    throws com.liferay.portal.kernel.exception.SystemException,
798                            com.liferay.portlet.bookmarks.NoSuchEntryException {
799                    return getPersistence()
800                                       .findByG_F_Last(groupId, folderId, orderByComparator);
801            }
802    
803            /**
804            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
805            *
806            * @param groupId the group ID
807            * @param folderId the folder ID
808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
809            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
810            * @throws SystemException if a system exception occurred
811            */
812            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last(
813                    long groupId, long folderId,
814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
815                    throws com.liferay.portal.kernel.exception.SystemException {
816                    return getPersistence()
817                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
818            }
819    
820            /**
821            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
822            *
823            * @param entryId the primary key of the current bookmarks entry
824            * @param groupId the group ID
825            * @param folderId the folder ID
826            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
827            * @return the previous, current, and next bookmarks entry
828            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
829            * @throws SystemException if a system exception occurred
830            */
831            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
832                    long entryId, long groupId, long folderId,
833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
834                    throws com.liferay.portal.kernel.exception.SystemException,
835                            com.liferay.portlet.bookmarks.NoSuchEntryException {
836                    return getPersistence()
837                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
838                            orderByComparator);
839            }
840    
841            /**
842            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
843            *
844            * @param groupId the group ID
845            * @param folderId the folder ID
846            * @return the matching bookmarks entries that the user has permission to view
847            * @throws SystemException if a system exception occurred
848            */
849            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
850                    long groupId, long folderId)
851                    throws com.liferay.portal.kernel.exception.SystemException {
852                    return getPersistence().filterFindByG_F(groupId, folderId);
853            }
854    
855            /**
856            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
857            *
858            * <p>
859            * 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.BookmarksEntryModelImpl}. 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.
860            * </p>
861            *
862            * @param groupId the group ID
863            * @param folderId the folder ID
864            * @param start the lower bound of the range of bookmarks entries
865            * @param end the upper bound of the range of bookmarks entries (not inclusive)
866            * @return the range of matching bookmarks entries that the user has permission to view
867            * @throws SystemException if a system exception occurred
868            */
869            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
870                    long groupId, long folderId, int start, int end)
871                    throws com.liferay.portal.kernel.exception.SystemException {
872                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
873            }
874    
875            /**
876            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
877            *
878            * <p>
879            * 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.BookmarksEntryModelImpl}. 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.
880            * </p>
881            *
882            * @param groupId the group ID
883            * @param folderId the folder ID
884            * @param start the lower bound of the range of bookmarks entries
885            * @param end the upper bound of the range of bookmarks entries (not inclusive)
886            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
887            * @return the ordered range of matching bookmarks entries that the user has permission to view
888            * @throws SystemException if a system exception occurred
889            */
890            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
891                    long groupId, long folderId, int start, int end,
892                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
893                    throws com.liferay.portal.kernel.exception.SystemException {
894                    return getPersistence()
895                                       .filterFindByG_F(groupId, folderId, start, end,
896                            orderByComparator);
897            }
898    
899            /**
900            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
901            *
902            * @param entryId the primary key of the current bookmarks entry
903            * @param groupId the group ID
904            * @param folderId the folder ID
905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
906            * @return the previous, current, and next bookmarks entry
907            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
908            * @throws SystemException if a system exception occurred
909            */
910            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
911                    long entryId, long groupId, long folderId,
912                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
913                    throws com.liferay.portal.kernel.exception.SystemException,
914                            com.liferay.portlet.bookmarks.NoSuchEntryException {
915                    return getPersistence()
916                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
917                            orderByComparator);
918            }
919    
920            /**
921            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
922            *
923            * @param groupId the group ID
924            * @param folderIds the folder IDs
925            * @return the matching bookmarks entries that the user has permission to view
926            * @throws SystemException if a system exception occurred
927            */
928            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
929                    long groupId, long[] folderIds)
930                    throws com.liferay.portal.kernel.exception.SystemException {
931                    return getPersistence().filterFindByG_F(groupId, folderIds);
932            }
933    
934            /**
935            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
936            *
937            * <p>
938            * 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.BookmarksEntryModelImpl}. 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.
939            * </p>
940            *
941            * @param groupId the group ID
942            * @param folderIds the folder IDs
943            * @param start the lower bound of the range of bookmarks entries
944            * @param end the upper bound of the range of bookmarks entries (not inclusive)
945            * @return the range of matching bookmarks entries that the user has permission to view
946            * @throws SystemException if a system exception occurred
947            */
948            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
949                    long groupId, long[] folderIds, int start, int end)
950                    throws com.liferay.portal.kernel.exception.SystemException {
951                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
952            }
953    
954            /**
955            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
956            *
957            * <p>
958            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
959            * </p>
960            *
961            * @param groupId the group ID
962            * @param folderIds the folder IDs
963            * @param start the lower bound of the range of bookmarks entries
964            * @param end the upper bound of the range of bookmarks entries (not inclusive)
965            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
966            * @return the ordered range of matching bookmarks entries that the user has permission to view
967            * @throws SystemException if a system exception occurred
968            */
969            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
970                    long groupId, long[] folderIds, int start, int end,
971                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
972                    throws com.liferay.portal.kernel.exception.SystemException {
973                    return getPersistence()
974                                       .filterFindByG_F(groupId, folderIds, start, end,
975                            orderByComparator);
976            }
977    
978            /**
979            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
980            *
981            * <p>
982            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
983            * </p>
984            *
985            * @param groupId the group ID
986            * @param folderIds the folder IDs
987            * @return the matching bookmarks entries
988            * @throws SystemException if a system exception occurred
989            */
990            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
991                    long groupId, long[] folderIds)
992                    throws com.liferay.portal.kernel.exception.SystemException {
993                    return getPersistence().findByG_F(groupId, folderIds);
994            }
995    
996            /**
997            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
998            *
999            * <p>
1000            * 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.BookmarksEntryModelImpl}. 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.
1001            * </p>
1002            *
1003            * @param groupId the group ID
1004            * @param folderIds the folder IDs
1005            * @param start the lower bound of the range of bookmarks entries
1006            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1007            * @return the range of matching bookmarks entries
1008            * @throws SystemException if a system exception occurred
1009            */
1010            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1011                    long groupId, long[] folderIds, int start, int end)
1012                    throws com.liferay.portal.kernel.exception.SystemException {
1013                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1014            }
1015    
1016            /**
1017            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1018            *
1019            * <p>
1020            * 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.BookmarksEntryModelImpl}. 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.
1021            * </p>
1022            *
1023            * @param groupId the group ID
1024            * @param folderIds the folder IDs
1025            * @param start the lower bound of the range of bookmarks entries
1026            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1027            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1028            * @return the ordered range of matching bookmarks entries
1029            * @throws SystemException if a system exception occurred
1030            */
1031            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1032                    long groupId, long[] folderIds, int start, int end,
1033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1034                    throws com.liferay.portal.kernel.exception.SystemException {
1035                    return getPersistence()
1036                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1037            }
1038    
1039            /**
1040            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1041            *
1042            * @param groupId the group ID
1043            * @param folderId the folder ID
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static void removeByG_F(long groupId, long folderId)
1047                    throws com.liferay.portal.kernel.exception.SystemException {
1048                    getPersistence().removeByG_F(groupId, folderId);
1049            }
1050    
1051            /**
1052            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63;.
1053            *
1054            * @param groupId the group ID
1055            * @param folderId the folder ID
1056            * @return the number of matching bookmarks entries
1057            * @throws SystemException if a system exception occurred
1058            */
1059            public static int countByG_F(long groupId, long folderId)
1060                    throws com.liferay.portal.kernel.exception.SystemException {
1061                    return getPersistence().countByG_F(groupId, folderId);
1062            }
1063    
1064            /**
1065            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63;.
1066            *
1067            * @param groupId the group ID
1068            * @param folderIds the folder IDs
1069            * @return the number of matching bookmarks entries
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static int countByG_F(long groupId, long[] folderIds)
1073                    throws com.liferay.portal.kernel.exception.SystemException {
1074                    return getPersistence().countByG_F(groupId, folderIds);
1075            }
1076    
1077            /**
1078            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1079            *
1080            * @param groupId the group ID
1081            * @param folderId the folder ID
1082            * @return the number of matching bookmarks entries that the user has permission to view
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static int filterCountByG_F(long groupId, long folderId)
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return getPersistence().filterCountByG_F(groupId, folderId);
1088            }
1089    
1090            /**
1091            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1092            *
1093            * @param groupId the group ID
1094            * @param folderIds the folder IDs
1095            * @return the number of matching bookmarks entries that the user has permission to view
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static int filterCountByG_F(long groupId, long[] folderIds)
1099                    throws com.liferay.portal.kernel.exception.SystemException {
1100                    return getPersistence().filterCountByG_F(groupId, folderIds);
1101            }
1102    
1103            /**
1104            * Returns all the bookmarks entries where groupId = &#63; and status = &#63;.
1105            *
1106            * @param groupId the group ID
1107            * @param status the status
1108            * @return the matching bookmarks entries
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1112                    long groupId, int status)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    return getPersistence().findByG_S(groupId, status);
1115            }
1116    
1117            /**
1118            * Returns a range of all the bookmarks entries where groupId = &#63; and status = &#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.BookmarksEntryModelImpl}. 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 status the status
1126            * @param start the lower bound of the range of bookmarks entries
1127            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1128            * @return the range of matching bookmarks entries
1129            * @throws SystemException if a system exception occurred
1130            */
1131            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1132                    long groupId, int status, int start, int end)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    return getPersistence().findByG_S(groupId, status, start, end);
1135            }
1136    
1137            /**
1138            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and status = &#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.BookmarksEntryModelImpl}. 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 status the status
1146            * @param start the lower bound of the range of bookmarks entries
1147            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1149            * @return the ordered range of matching bookmarks entries
1150            * @throws SystemException if a system exception occurred
1151            */
1152            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1153                    long groupId, int status, 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_S(groupId, status, start, end, orderByComparator);
1158            }
1159    
1160            /**
1161            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1162            *
1163            * @param groupId the group ID
1164            * @param status the status
1165            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1166            * @return the first matching bookmarks entry
1167            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1168            * @throws SystemException if a system exception occurred
1169            */
1170            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First(
1171                    long groupId, int status,
1172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1173                    throws com.liferay.portal.kernel.exception.SystemException,
1174                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1175                    return getPersistence()
1176                                       .findByG_S_First(groupId, status, orderByComparator);
1177            }
1178    
1179            /**
1180            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1181            *
1182            * @param groupId the group ID
1183            * @param status the status
1184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1185            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1186            * @throws SystemException if a system exception occurred
1187            */
1188            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First(
1189                    long groupId, int status,
1190                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence()
1193                                       .fetchByG_S_First(groupId, status, orderByComparator);
1194            }
1195    
1196            /**
1197            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1198            *
1199            * @param groupId the group ID
1200            * @param status the status
1201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1202            * @return the last matching bookmarks entry
1203            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1204            * @throws SystemException if a system exception occurred
1205            */
1206            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last(
1207                    long groupId, int status,
1208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1209                    throws com.liferay.portal.kernel.exception.SystemException,
1210                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1211                    return getPersistence()
1212                                       .findByG_S_Last(groupId, status, orderByComparator);
1213            }
1214    
1215            /**
1216            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1217            *
1218            * @param groupId the group ID
1219            * @param status the status
1220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1221            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1222            * @throws SystemException if a system exception occurred
1223            */
1224            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last(
1225                    long groupId, int status,
1226                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1227                    throws com.liferay.portal.kernel.exception.SystemException {
1228                    return getPersistence()
1229                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1230            }
1231    
1232            /**
1233            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1234            *
1235            * @param entryId the primary key of the current bookmarks entry
1236            * @param groupId the group ID
1237            * @param status the status
1238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1239            * @return the previous, current, and next bookmarks entry
1240            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1241            * @throws SystemException if a system exception occurred
1242            */
1243            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext(
1244                    long entryId, long groupId, int status,
1245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1246                    throws com.liferay.portal.kernel.exception.SystemException,
1247                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1248                    return getPersistence()
1249                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1250                            orderByComparator);
1251            }
1252    
1253            /**
1254            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1255            *
1256            * @param groupId the group ID
1257            * @param status the status
1258            * @return the matching bookmarks entries that the user has permission to view
1259            * @throws SystemException if a system exception occurred
1260            */
1261            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1262                    long groupId, int status)
1263                    throws com.liferay.portal.kernel.exception.SystemException {
1264                    return getPersistence().filterFindByG_S(groupId, status);
1265            }
1266    
1267            /**
1268            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1269            *
1270            * <p>
1271            * 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.BookmarksEntryModelImpl}. 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.
1272            * </p>
1273            *
1274            * @param groupId the group ID
1275            * @param status the status
1276            * @param start the lower bound of the range of bookmarks entries
1277            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1278            * @return the range of matching bookmarks entries that the user has permission to view
1279            * @throws SystemException if a system exception occurred
1280            */
1281            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1282                    long groupId, int status, int start, int end)
1283                    throws com.liferay.portal.kernel.exception.SystemException {
1284                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1285            }
1286    
1287            /**
1288            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status = &#63;.
1289            *
1290            * <p>
1291            * 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.BookmarksEntryModelImpl}. 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.
1292            * </p>
1293            *
1294            * @param groupId the group ID
1295            * @param status the status
1296            * @param start the lower bound of the range of bookmarks entries
1297            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1298            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1299            * @return the ordered range of matching bookmarks entries that the user has permission to view
1300            * @throws SystemException if a system exception occurred
1301            */
1302            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1303                    long groupId, int status, int start, int end,
1304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1305                    throws com.liferay.portal.kernel.exception.SystemException {
1306                    return getPersistence()
1307                                       .filterFindByG_S(groupId, status, start, end,
1308                            orderByComparator);
1309            }
1310    
1311            /**
1312            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1313            *
1314            * @param entryId the primary key of the current bookmarks entry
1315            * @param groupId the group ID
1316            * @param status the status
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the previous, current, and next bookmarks entry
1319            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1320            * @throws SystemException if a system exception occurred
1321            */
1322            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext(
1323                    long entryId, long groupId, int status,
1324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1325                    throws com.liferay.portal.kernel.exception.SystemException,
1326                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1327                    return getPersistence()
1328                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
1329                            orderByComparator);
1330            }
1331    
1332            /**
1333            * Removes all the bookmarks entries where groupId = &#63; and status = &#63; from the database.
1334            *
1335            * @param groupId the group ID
1336            * @param status the status
1337            * @throws SystemException if a system exception occurred
1338            */
1339            public static void removeByG_S(long groupId, int status)
1340                    throws com.liferay.portal.kernel.exception.SystemException {
1341                    getPersistence().removeByG_S(groupId, status);
1342            }
1343    
1344            /**
1345            * Returns the number of bookmarks entries where groupId = &#63; and status = &#63;.
1346            *
1347            * @param groupId the group ID
1348            * @param status the status
1349            * @return the number of matching bookmarks entries
1350            * @throws SystemException if a system exception occurred
1351            */
1352            public static int countByG_S(long groupId, int status)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence().countByG_S(groupId, status);
1355            }
1356    
1357            /**
1358            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1359            *
1360            * @param groupId the group ID
1361            * @param status the status
1362            * @return the number of matching bookmarks entries that the user has permission to view
1363            * @throws SystemException if a system exception occurred
1364            */
1365            public static int filterCountByG_S(long groupId, int status)
1366                    throws com.liferay.portal.kernel.exception.SystemException {
1367                    return getPersistence().filterCountByG_S(groupId, status);
1368            }
1369    
1370            /**
1371            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1372            *
1373            * @param groupId the group ID
1374            * @param userId the user ID
1375            * @param status the status
1376            * @return the matching bookmarks entries
1377            * @throws SystemException if a system exception occurred
1378            */
1379            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1380                    long groupId, long userId, int status)
1381                    throws com.liferay.portal.kernel.exception.SystemException {
1382                    return getPersistence().findByG_U_S(groupId, userId, status);
1383            }
1384    
1385            /**
1386            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1387            *
1388            * <p>
1389            * 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.BookmarksEntryModelImpl}. 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.
1390            * </p>
1391            *
1392            * @param groupId the group ID
1393            * @param userId the user ID
1394            * @param status the status
1395            * @param start the lower bound of the range of bookmarks entries
1396            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1397            * @return the range of matching bookmarks entries
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1401                    long groupId, long userId, int status, int start, int end)
1402                    throws com.liferay.portal.kernel.exception.SystemException {
1403                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
1404            }
1405    
1406            /**
1407            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#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.BookmarksEntryModelImpl}. 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 groupId the group ID
1414            * @param userId the user ID
1415            * @param status the status
1416            * @param start the lower bound of the range of bookmarks entries
1417            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1419            * @return the ordered range of matching bookmarks entries
1420            * @throws SystemException if a system exception occurred
1421            */
1422            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1423                    long groupId, long userId, int status, int start, int end,
1424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1425                    throws com.liferay.portal.kernel.exception.SystemException {
1426                    return getPersistence()
1427                                       .findByG_U_S(groupId, userId, status, start, end,
1428                            orderByComparator);
1429            }
1430    
1431            /**
1432            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1433            *
1434            * @param groupId the group ID
1435            * @param userId the user ID
1436            * @param status the status
1437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1438            * @return the first matching bookmarks entry
1439            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First(
1443                    long groupId, long userId, int status,
1444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1445                    throws com.liferay.portal.kernel.exception.SystemException,
1446                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1447                    return getPersistence()
1448                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
1449            }
1450    
1451            /**
1452            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1453            *
1454            * @param groupId the group ID
1455            * @param userId the user ID
1456            * @param status the status
1457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1458            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1459            * @throws SystemException if a system exception occurred
1460            */
1461            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First(
1462                    long groupId, long userId, int status,
1463                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1464                    throws com.liferay.portal.kernel.exception.SystemException {
1465                    return getPersistence()
1466                                       .fetchByG_U_S_First(groupId, userId, status,
1467                            orderByComparator);
1468            }
1469    
1470            /**
1471            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1472            *
1473            * @param groupId the group ID
1474            * @param userId the user ID
1475            * @param status the status
1476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1477            * @return the last matching bookmarks entry
1478            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1479            * @throws SystemException if a system exception occurred
1480            */
1481            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last(
1482                    long groupId, long userId, int status,
1483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1484                    throws com.liferay.portal.kernel.exception.SystemException,
1485                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1486                    return getPersistence()
1487                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
1488            }
1489    
1490            /**
1491            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1492            *
1493            * @param groupId the group ID
1494            * @param userId the user ID
1495            * @param status the status
1496            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1497            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1498            * @throws SystemException if a system exception occurred
1499            */
1500            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last(
1501                    long groupId, long userId, int status,
1502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1503                    throws com.liferay.portal.kernel.exception.SystemException {
1504                    return getPersistence()
1505                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
1506            }
1507    
1508            /**
1509            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1510            *
1511            * @param entryId the primary key of the current bookmarks entry
1512            * @param groupId the group ID
1513            * @param userId the user ID
1514            * @param status the status
1515            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1516            * @return the previous, current, and next bookmarks entry
1517            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1518            * @throws SystemException if a system exception occurred
1519            */
1520            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext(
1521                    long entryId, long groupId, long userId, int status,
1522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1523                    throws com.liferay.portal.kernel.exception.SystemException,
1524                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1525                    return getPersistence()
1526                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
1527                            orderByComparator);
1528            }
1529    
1530            /**
1531            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1532            *
1533            * @param groupId the group ID
1534            * @param userId the user ID
1535            * @param status the status
1536            * @return the matching bookmarks entries that the user has permission to view
1537            * @throws SystemException if a system exception occurred
1538            */
1539            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1540                    long groupId, long userId, int status)
1541                    throws com.liferay.portal.kernel.exception.SystemException {
1542                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
1543            }
1544    
1545            /**
1546            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1547            *
1548            * <p>
1549            * 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.BookmarksEntryModelImpl}. 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.
1550            * </p>
1551            *
1552            * @param groupId the group ID
1553            * @param userId the user ID
1554            * @param status the status
1555            * @param start the lower bound of the range of bookmarks entries
1556            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1557            * @return the range of matching bookmarks entries that the user has permission to view
1558            * @throws SystemException if a system exception occurred
1559            */
1560            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1561                    long groupId, long userId, int status, int start, int end)
1562                    throws com.liferay.portal.kernel.exception.SystemException {
1563                    return getPersistence()
1564                                       .filterFindByG_U_S(groupId, userId, status, start, end);
1565            }
1566    
1567            /**
1568            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status = &#63;.
1569            *
1570            * <p>
1571            * 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.BookmarksEntryModelImpl}. 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.
1572            * </p>
1573            *
1574            * @param groupId the group ID
1575            * @param userId the user ID
1576            * @param status the status
1577            * @param start the lower bound of the range of bookmarks entries
1578            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1579            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1580            * @return the ordered range of matching bookmarks entries that the user has permission to view
1581            * @throws SystemException if a system exception occurred
1582            */
1583            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1584                    long groupId, long userId, int status, int start, int end,
1585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1586                    throws com.liferay.portal.kernel.exception.SystemException {
1587                    return getPersistence()
1588                                       .filterFindByG_U_S(groupId, userId, status, start, end,
1589                            orderByComparator);
1590            }
1591    
1592            /**
1593            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1594            *
1595            * @param entryId the primary key of the current bookmarks entry
1596            * @param groupId the group ID
1597            * @param userId the user ID
1598            * @param status the status
1599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1600            * @return the previous, current, and next bookmarks entry
1601            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1602            * @throws SystemException if a system exception occurred
1603            */
1604            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext(
1605                    long entryId, long groupId, long userId, int status,
1606                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1607                    throws com.liferay.portal.kernel.exception.SystemException,
1608                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1609                    return getPersistence()
1610                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
1611                            status, orderByComparator);
1612            }
1613    
1614            /**
1615            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
1616            *
1617            * @param groupId the group ID
1618            * @param userId the user ID
1619            * @param status the status
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static void removeByG_U_S(long groupId, long userId, int status)
1623                    throws com.liferay.portal.kernel.exception.SystemException {
1624                    getPersistence().removeByG_U_S(groupId, userId, status);
1625            }
1626    
1627            /**
1628            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1629            *
1630            * @param groupId the group ID
1631            * @param userId the user ID
1632            * @param status the status
1633            * @return the number of matching bookmarks entries
1634            * @throws SystemException if a system exception occurred
1635            */
1636            public static int countByG_U_S(long groupId, long userId, int status)
1637                    throws com.liferay.portal.kernel.exception.SystemException {
1638                    return getPersistence().countByG_U_S(groupId, userId, status);
1639            }
1640    
1641            /**
1642            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1643            *
1644            * @param groupId the group ID
1645            * @param userId the user ID
1646            * @param status the status
1647            * @return the number of matching bookmarks entries that the user has permission to view
1648            * @throws SystemException if a system exception occurred
1649            */
1650            public static int filterCountByG_U_S(long groupId, long userId, int status)
1651                    throws com.liferay.portal.kernel.exception.SystemException {
1652                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
1653            }
1654    
1655            /**
1656            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1657            *
1658            * @param groupId the group ID
1659            * @param folderId the folder ID
1660            * @param status the status
1661            * @return the matching bookmarks entries
1662            * @throws SystemException if a system exception occurred
1663            */
1664            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1665                    long groupId, long folderId, int status)
1666                    throws com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence().findByG_F_S(groupId, folderId, status);
1668            }
1669    
1670            /**
1671            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1672            *
1673            * <p>
1674            * 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.BookmarksEntryModelImpl}. 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.
1675            * </p>
1676            *
1677            * @param groupId the group ID
1678            * @param folderId the folder ID
1679            * @param status the status
1680            * @param start the lower bound of the range of bookmarks entries
1681            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1682            * @return the range of matching bookmarks entries
1683            * @throws SystemException if a system exception occurred
1684            */
1685            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1686                    long groupId, long folderId, int status, int start, int end)
1687                    throws com.liferay.portal.kernel.exception.SystemException {
1688                    return getPersistence()
1689                                       .findByG_F_S(groupId, folderId, status, start, end);
1690            }
1691    
1692            /**
1693            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1694            *
1695            * <p>
1696            * 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.BookmarksEntryModelImpl}. 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.
1697            * </p>
1698            *
1699            * @param groupId the group ID
1700            * @param folderId the folder ID
1701            * @param status the status
1702            * @param start the lower bound of the range of bookmarks entries
1703            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1704            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1705            * @return the ordered range of matching bookmarks entries
1706            * @throws SystemException if a system exception occurred
1707            */
1708            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1709                    long groupId, long folderId, int status, int start, int end,
1710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1711                    throws com.liferay.portal.kernel.exception.SystemException {
1712                    return getPersistence()
1713                                       .findByG_F_S(groupId, folderId, status, start, end,
1714                            orderByComparator);
1715            }
1716    
1717            /**
1718            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1719            *
1720            * @param groupId the group ID
1721            * @param folderId the folder ID
1722            * @param status the status
1723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1724            * @return the first matching bookmarks entry
1725            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1726            * @throws SystemException if a system exception occurred
1727            */
1728            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First(
1729                    long groupId, long folderId, int status,
1730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1731                    throws com.liferay.portal.kernel.exception.SystemException,
1732                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1733                    return getPersistence()
1734                                       .findByG_F_S_First(groupId, folderId, status,
1735                            orderByComparator);
1736            }
1737    
1738            /**
1739            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1740            *
1741            * @param groupId the group ID
1742            * @param folderId the folder ID
1743            * @param status the status
1744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1745            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First(
1749                    long groupId, long folderId, int status,
1750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1751                    throws com.liferay.portal.kernel.exception.SystemException {
1752                    return getPersistence()
1753                                       .fetchByG_F_S_First(groupId, folderId, status,
1754                            orderByComparator);
1755            }
1756    
1757            /**
1758            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1759            *
1760            * @param groupId the group ID
1761            * @param folderId the folder ID
1762            * @param status the status
1763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1764            * @return the last matching bookmarks entry
1765            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last(
1769                    long groupId, long folderId, int status,
1770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1771                    throws com.liferay.portal.kernel.exception.SystemException,
1772                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1773                    return getPersistence()
1774                                       .findByG_F_S_Last(groupId, folderId, status,
1775                            orderByComparator);
1776            }
1777    
1778            /**
1779            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1780            *
1781            * @param groupId the group ID
1782            * @param folderId the folder ID
1783            * @param status the status
1784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1785            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1786            * @throws SystemException if a system exception occurred
1787            */
1788            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last(
1789                    long groupId, long folderId, int status,
1790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1791                    throws com.liferay.portal.kernel.exception.SystemException {
1792                    return getPersistence()
1793                                       .fetchByG_F_S_Last(groupId, folderId, status,
1794                            orderByComparator);
1795            }
1796    
1797            /**
1798            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1799            *
1800            * @param entryId the primary key of the current bookmarks entry
1801            * @param groupId the group ID
1802            * @param folderId the folder ID
1803            * @param status the status
1804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1805            * @return the previous, current, and next bookmarks entry
1806            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1807            * @throws SystemException if a system exception occurred
1808            */
1809            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext(
1810                    long entryId, long groupId, long folderId, int status,
1811                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1812                    throws com.liferay.portal.kernel.exception.SystemException,
1813                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1814                    return getPersistence()
1815                                       .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status,
1816                            orderByComparator);
1817            }
1818    
1819            /**
1820            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1821            *
1822            * @param groupId the group ID
1823            * @param folderId the folder ID
1824            * @param status the status
1825            * @return the matching bookmarks entries that the user has permission to view
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1829                    long groupId, long folderId, int status)
1830                    throws com.liferay.portal.kernel.exception.SystemException {
1831                    return getPersistence().filterFindByG_F_S(groupId, folderId, status);
1832            }
1833    
1834            /**
1835            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1836            *
1837            * <p>
1838            * 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.BookmarksEntryModelImpl}. 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.
1839            * </p>
1840            *
1841            * @param groupId the group ID
1842            * @param folderId the folder ID
1843            * @param status the status
1844            * @param start the lower bound of the range of bookmarks entries
1845            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1846            * @return the range of matching bookmarks entries that the user has permission to view
1847            * @throws SystemException if a system exception occurred
1848            */
1849            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1850                    long groupId, long folderId, int status, int start, int end)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence()
1853                                       .filterFindByG_F_S(groupId, folderId, status, start, end);
1854            }
1855    
1856            /**
1857            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1858            *
1859            * <p>
1860            * 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.BookmarksEntryModelImpl}. 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.
1861            * </p>
1862            *
1863            * @param groupId the group ID
1864            * @param folderId the folder ID
1865            * @param status the status
1866            * @param start the lower bound of the range of bookmarks entries
1867            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1868            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1869            * @return the ordered range of matching bookmarks entries that the user has permission to view
1870            * @throws SystemException if a system exception occurred
1871            */
1872            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1873                    long groupId, long folderId, int status, int start, int end,
1874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1875                    throws com.liferay.portal.kernel.exception.SystemException {
1876                    return getPersistence()
1877                                       .filterFindByG_F_S(groupId, folderId, status, start, end,
1878                            orderByComparator);
1879            }
1880    
1881            /**
1882            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1883            *
1884            * @param entryId the primary key of the current bookmarks entry
1885            * @param groupId the group ID
1886            * @param folderId the folder ID
1887            * @param status the status
1888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1889            * @return the previous, current, and next bookmarks entry
1890            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1891            * @throws SystemException if a system exception occurred
1892            */
1893            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext(
1894                    long entryId, long groupId, long folderId, int status,
1895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1896                    throws com.liferay.portal.kernel.exception.SystemException,
1897                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1898                    return getPersistence()
1899                                       .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId,
1900                            status, orderByComparator);
1901            }
1902    
1903            /**
1904            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1905            *
1906            * @param groupId the group ID
1907            * @param folderIds the folder IDs
1908            * @param status the status
1909            * @return the matching bookmarks entries that the user has permission to view
1910            * @throws SystemException if a system exception occurred
1911            */
1912            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1913                    long groupId, long[] folderIds, int status)
1914                    throws com.liferay.portal.kernel.exception.SystemException {
1915                    return getPersistence().filterFindByG_F_S(groupId, folderIds, status);
1916            }
1917    
1918            /**
1919            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1920            *
1921            * <p>
1922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1923            * </p>
1924            *
1925            * @param groupId the group ID
1926            * @param folderIds the folder IDs
1927            * @param status the status
1928            * @param start the lower bound of the range of bookmarks entries
1929            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1930            * @return the range of matching bookmarks entries that the user has permission to view
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1934                    long groupId, long[] folderIds, int status, int start, int end)
1935                    throws com.liferay.portal.kernel.exception.SystemException {
1936                    return getPersistence()
1937                                       .filterFindByG_F_S(groupId, folderIds, status, start, end);
1938            }
1939    
1940            /**
1941            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1942            *
1943            * <p>
1944            * 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.BookmarksEntryModelImpl}. 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.
1945            * </p>
1946            *
1947            * @param groupId the group ID
1948            * @param folderIds the folder IDs
1949            * @param status the status
1950            * @param start the lower bound of the range of bookmarks entries
1951            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1953            * @return the ordered range of matching bookmarks entries that the user has permission to view
1954            * @throws SystemException if a system exception occurred
1955            */
1956            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1957                    long groupId, long[] folderIds, int status, int start, int end,
1958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1959                    throws com.liferay.portal.kernel.exception.SystemException {
1960                    return getPersistence()
1961                                       .filterFindByG_F_S(groupId, folderIds, status, start, end,
1962                            orderByComparator);
1963            }
1964    
1965            /**
1966            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
1967            *
1968            * <p>
1969            * 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.BookmarksEntryModelImpl}. 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.
1970            * </p>
1971            *
1972            * @param groupId the group ID
1973            * @param folderIds the folder IDs
1974            * @param status the status
1975            * @return the matching bookmarks entries
1976            * @throws SystemException if a system exception occurred
1977            */
1978            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1979                    long groupId, long[] folderIds, int status)
1980                    throws com.liferay.portal.kernel.exception.SystemException {
1981                    return getPersistence().findByG_F_S(groupId, folderIds, status);
1982            }
1983    
1984            /**
1985            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
1986            *
1987            * <p>
1988            * 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.BookmarksEntryModelImpl}. 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.
1989            * </p>
1990            *
1991            * @param groupId the group ID
1992            * @param folderIds the folder IDs
1993            * @param status the status
1994            * @param start the lower bound of the range of bookmarks entries
1995            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1996            * @return the range of matching bookmarks entries
1997            * @throws SystemException if a system exception occurred
1998            */
1999            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2000                    long groupId, long[] folderIds, int status, int start, int end)
2001                    throws com.liferay.portal.kernel.exception.SystemException {
2002                    return getPersistence()
2003                                       .findByG_F_S(groupId, folderIds, status, start, end);
2004            }
2005    
2006            /**
2007            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2008            *
2009            * <p>
2010            * 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.BookmarksEntryModelImpl}. 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.
2011            * </p>
2012            *
2013            * @param groupId the group ID
2014            * @param folderIds the folder IDs
2015            * @param status the status
2016            * @param start the lower bound of the range of bookmarks entries
2017            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2018            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2019            * @return the ordered range of matching bookmarks entries
2020            * @throws SystemException if a system exception occurred
2021            */
2022            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2023                    long groupId, long[] folderIds, int status, int start, int end,
2024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2025                    throws com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence()
2027                                       .findByG_F_S(groupId, folderIds, status, start, end,
2028                            orderByComparator);
2029            }
2030    
2031            /**
2032            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
2033            *
2034            * @param groupId the group ID
2035            * @param folderId the folder ID
2036            * @param status the status
2037            * @throws SystemException if a system exception occurred
2038            */
2039            public static void removeByG_F_S(long groupId, long folderId, int status)
2040                    throws com.liferay.portal.kernel.exception.SystemException {
2041                    getPersistence().removeByG_F_S(groupId, folderId, status);
2042            }
2043    
2044            /**
2045            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2046            *
2047            * @param groupId the group ID
2048            * @param folderId the folder ID
2049            * @param status the status
2050            * @return the number of matching bookmarks entries
2051            * @throws SystemException if a system exception occurred
2052            */
2053            public static int countByG_F_S(long groupId, long folderId, int status)
2054                    throws com.liferay.portal.kernel.exception.SystemException {
2055                    return getPersistence().countByG_F_S(groupId, folderId, status);
2056            }
2057    
2058            /**
2059            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2060            *
2061            * @param groupId the group ID
2062            * @param folderIds the folder IDs
2063            * @param status the status
2064            * @return the number of matching bookmarks entries
2065            * @throws SystemException if a system exception occurred
2066            */
2067            public static int countByG_F_S(long groupId, long[] folderIds, int status)
2068                    throws com.liferay.portal.kernel.exception.SystemException {
2069                    return getPersistence().countByG_F_S(groupId, folderIds, status);
2070            }
2071    
2072            /**
2073            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2074            *
2075            * @param groupId the group ID
2076            * @param folderId the folder ID
2077            * @param status the status
2078            * @return the number of matching bookmarks entries that the user has permission to view
2079            * @throws SystemException if a system exception occurred
2080            */
2081            public static int filterCountByG_F_S(long groupId, long folderId, int status)
2082                    throws com.liferay.portal.kernel.exception.SystemException {
2083                    return getPersistence().filterCountByG_F_S(groupId, folderId, status);
2084            }
2085    
2086            /**
2087            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2088            *
2089            * @param groupId the group ID
2090            * @param folderIds the folder IDs
2091            * @param status the status
2092            * @return the number of matching bookmarks entries that the user has permission to view
2093            * @throws SystemException if a system exception occurred
2094            */
2095            public static int filterCountByG_F_S(long groupId, long[] folderIds,
2096                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2097                    return getPersistence().filterCountByG_F_S(groupId, folderIds, status);
2098            }
2099    
2100            /**
2101            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2102            *
2103            * @param groupId the group ID
2104            * @param userId the user ID
2105            * @param folderId the folder ID
2106            * @param status the status
2107            * @return the matching bookmarks entries
2108            * @throws SystemException if a system exception occurred
2109            */
2110            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2111                    long groupId, long userId, long folderId, int status)
2112                    throws com.liferay.portal.kernel.exception.SystemException {
2113                    return getPersistence().findByG_U_F_S(groupId, userId, folderId, status);
2114            }
2115    
2116            /**
2117            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2118            *
2119            * <p>
2120            * 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.BookmarksEntryModelImpl}. 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.
2121            * </p>
2122            *
2123            * @param groupId the group ID
2124            * @param userId the user ID
2125            * @param folderId the folder ID
2126            * @param status the status
2127            * @param start the lower bound of the range of bookmarks entries
2128            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2129            * @return the range of matching bookmarks entries
2130            * @throws SystemException if a system exception occurred
2131            */
2132            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2133                    long groupId, long userId, long folderId, int status, int start, int end)
2134                    throws com.liferay.portal.kernel.exception.SystemException {
2135                    return getPersistence()
2136                                       .findByG_U_F_S(groupId, userId, folderId, status, start, end);
2137            }
2138    
2139            /**
2140            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2141            *
2142            * <p>
2143            * 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.BookmarksEntryModelImpl}. 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.
2144            * </p>
2145            *
2146            * @param groupId the group ID
2147            * @param userId the user ID
2148            * @param folderId the folder ID
2149            * @param status the status
2150            * @param start the lower bound of the range of bookmarks entries
2151            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2152            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2153            * @return the ordered range of matching bookmarks entries
2154            * @throws SystemException if a system exception occurred
2155            */
2156            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2157                    long groupId, long userId, long folderId, int status, int start,
2158                    int end,
2159                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2160                    throws com.liferay.portal.kernel.exception.SystemException {
2161                    return getPersistence()
2162                                       .findByG_U_F_S(groupId, userId, folderId, status, start,
2163                            end, orderByComparator);
2164            }
2165    
2166            /**
2167            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2168            *
2169            * @param groupId the group ID
2170            * @param userId the user ID
2171            * @param folderId the folder ID
2172            * @param status the status
2173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2174            * @return the first matching bookmarks entry
2175            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2176            * @throws SystemException if a system exception occurred
2177            */
2178            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First(
2179                    long groupId, long userId, long folderId, int status,
2180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2181                    throws com.liferay.portal.kernel.exception.SystemException,
2182                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2183                    return getPersistence()
2184                                       .findByG_U_F_S_First(groupId, userId, folderId, status,
2185                            orderByComparator);
2186            }
2187    
2188            /**
2189            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2190            *
2191            * @param groupId the group ID
2192            * @param userId the user ID
2193            * @param folderId the folder ID
2194            * @param status the status
2195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2196            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2197            * @throws SystemException if a system exception occurred
2198            */
2199            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First(
2200                    long groupId, long userId, long folderId, int status,
2201                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2202                    throws com.liferay.portal.kernel.exception.SystemException {
2203                    return getPersistence()
2204                                       .fetchByG_U_F_S_First(groupId, userId, folderId, status,
2205                            orderByComparator);
2206            }
2207    
2208            /**
2209            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2210            *
2211            * @param groupId the group ID
2212            * @param userId the user ID
2213            * @param folderId the folder ID
2214            * @param status the status
2215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2216            * @return the last matching bookmarks entry
2217            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2218            * @throws SystemException if a system exception occurred
2219            */
2220            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last(
2221                    long groupId, long userId, long folderId, int status,
2222                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2223                    throws com.liferay.portal.kernel.exception.SystemException,
2224                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2225                    return getPersistence()
2226                                       .findByG_U_F_S_Last(groupId, userId, folderId, status,
2227                            orderByComparator);
2228            }
2229    
2230            /**
2231            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2232            *
2233            * @param groupId the group ID
2234            * @param userId the user ID
2235            * @param folderId the folder ID
2236            * @param status the status
2237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2238            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2239            * @throws SystemException if a system exception occurred
2240            */
2241            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last(
2242                    long groupId, long userId, long folderId, int status,
2243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2244                    throws com.liferay.portal.kernel.exception.SystemException {
2245                    return getPersistence()
2246                                       .fetchByG_U_F_S_Last(groupId, userId, folderId, status,
2247                            orderByComparator);
2248            }
2249    
2250            /**
2251            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2252            *
2253            * @param entryId the primary key of the current bookmarks entry
2254            * @param groupId the group ID
2255            * @param userId the user ID
2256            * @param folderId the folder ID
2257            * @param status the status
2258            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2259            * @return the previous, current, and next bookmarks entry
2260            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2261            * @throws SystemException if a system exception occurred
2262            */
2263            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext(
2264                    long entryId, long groupId, long userId, long folderId, int status,
2265                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2266                    throws com.liferay.portal.kernel.exception.SystemException,
2267                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2268                    return getPersistence()
2269                                       .findByG_U_F_S_PrevAndNext(entryId, groupId, userId,
2270                            folderId, status, orderByComparator);
2271            }
2272    
2273            /**
2274            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2275            *
2276            * @param groupId the group ID
2277            * @param userId the user ID
2278            * @param folderId the folder ID
2279            * @param status the status
2280            * @return the matching bookmarks entries that the user has permission to view
2281            * @throws SystemException if a system exception occurred
2282            */
2283            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2284                    long groupId, long userId, long folderId, int status)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence()
2287                                       .filterFindByG_U_F_S(groupId, userId, folderId, status);
2288            }
2289    
2290            /**
2291            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2292            *
2293            * <p>
2294            * 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.BookmarksEntryModelImpl}. 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.
2295            * </p>
2296            *
2297            * @param groupId the group ID
2298            * @param userId the user ID
2299            * @param folderId the folder ID
2300            * @param status the status
2301            * @param start the lower bound of the range of bookmarks entries
2302            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2303            * @return the range of matching bookmarks entries that the user has permission to view
2304            * @throws SystemException if a system exception occurred
2305            */
2306            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2307                    long groupId, long userId, long folderId, int status, int start, int end)
2308                    throws com.liferay.portal.kernel.exception.SystemException {
2309                    return getPersistence()
2310                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
2311                            start, end);
2312            }
2313    
2314            /**
2315            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2316            *
2317            * <p>
2318            * 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.BookmarksEntryModelImpl}. 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.
2319            * </p>
2320            *
2321            * @param groupId the group ID
2322            * @param userId the user ID
2323            * @param folderId the folder ID
2324            * @param status the status
2325            * @param start the lower bound of the range of bookmarks entries
2326            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2327            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2328            * @return the ordered range of matching bookmarks entries that the user has permission to view
2329            * @throws SystemException if a system exception occurred
2330            */
2331            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2332                    long groupId, long userId, long folderId, int status, int start,
2333                    int end,
2334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2335                    throws com.liferay.portal.kernel.exception.SystemException {
2336                    return getPersistence()
2337                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
2338                            start, end, orderByComparator);
2339            }
2340    
2341            /**
2342            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2343            *
2344            * @param entryId the primary key of the current bookmarks entry
2345            * @param groupId the group ID
2346            * @param userId the user ID
2347            * @param folderId the folder ID
2348            * @param status the status
2349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2350            * @return the previous, current, and next bookmarks entry
2351            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2352            * @throws SystemException if a system exception occurred
2353            */
2354            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext(
2355                    long entryId, long groupId, long userId, long folderId, int status,
2356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2357                    throws com.liferay.portal.kernel.exception.SystemException,
2358                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2359                    return getPersistence()
2360                                       .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId,
2361                            folderId, status, orderByComparator);
2362            }
2363    
2364            /**
2365            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2366            *
2367            * @param groupId the group ID
2368            * @param userId the user ID
2369            * @param folderIds the folder IDs
2370            * @param status the status
2371            * @return the matching bookmarks entries that the user has permission to view
2372            * @throws SystemException if a system exception occurred
2373            */
2374            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2375                    long groupId, long userId, long[] folderIds, int status)
2376                    throws com.liferay.portal.kernel.exception.SystemException {
2377                    return getPersistence()
2378                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status);
2379            }
2380    
2381            /**
2382            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2383            *
2384            * <p>
2385            * 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.BookmarksEntryModelImpl}. 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.
2386            * </p>
2387            *
2388            * @param groupId the group ID
2389            * @param userId the user ID
2390            * @param folderIds the folder IDs
2391            * @param status the status
2392            * @param start the lower bound of the range of bookmarks entries
2393            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2394            * @return the range of matching bookmarks entries that the user has permission to view
2395            * @throws SystemException if a system exception occurred
2396            */
2397            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2398                    long groupId, long userId, long[] folderIds, int status, int start,
2399                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence()
2401                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
2402                            start, end);
2403            }
2404    
2405            /**
2406            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2407            *
2408            * <p>
2409            * 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.BookmarksEntryModelImpl}. 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.
2410            * </p>
2411            *
2412            * @param groupId the group ID
2413            * @param userId the user ID
2414            * @param folderIds the folder IDs
2415            * @param status the status
2416            * @param start the lower bound of the range of bookmarks entries
2417            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2419            * @return the ordered range of matching bookmarks entries that the user has permission to view
2420            * @throws SystemException if a system exception occurred
2421            */
2422            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2423                    long groupId, long userId, long[] folderIds, int status, int start,
2424                    int end,
2425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2426                    throws com.liferay.portal.kernel.exception.SystemException {
2427                    return getPersistence()
2428                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
2429                            start, end, orderByComparator);
2430            }
2431    
2432            /**
2433            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2434            *
2435            * <p>
2436            * 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.BookmarksEntryModelImpl}. 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.
2437            * </p>
2438            *
2439            * @param groupId the group ID
2440            * @param userId the user ID
2441            * @param folderIds the folder IDs
2442            * @param status the status
2443            * @return the matching bookmarks entries
2444            * @throws SystemException if a system exception occurred
2445            */
2446            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2447                    long groupId, long userId, long[] folderIds, int status)
2448                    throws com.liferay.portal.kernel.exception.SystemException {
2449                    return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status);
2450            }
2451    
2452            /**
2453            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2454            *
2455            * <p>
2456            * 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.BookmarksEntryModelImpl}. 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.
2457            * </p>
2458            *
2459            * @param groupId the group ID
2460            * @param userId the user ID
2461            * @param folderIds the folder IDs
2462            * @param status the status
2463            * @param start the lower bound of the range of bookmarks entries
2464            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2465            * @return the range of matching bookmarks entries
2466            * @throws SystemException if a system exception occurred
2467            */
2468            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2469                    long groupId, long userId, long[] folderIds, int status, int start,
2470                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2471                    return getPersistence()
2472                                       .findByG_U_F_S(groupId, userId, folderIds, status, start, end);
2473            }
2474    
2475            /**
2476            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2477            *
2478            * <p>
2479            * 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.BookmarksEntryModelImpl}. 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.
2480            * </p>
2481            *
2482            * @param groupId the group ID
2483            * @param userId the user ID
2484            * @param folderIds the folder IDs
2485            * @param status the status
2486            * @param start the lower bound of the range of bookmarks entries
2487            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2488            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2489            * @return the ordered range of matching bookmarks entries
2490            * @throws SystemException if a system exception occurred
2491            */
2492            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2493                    long groupId, long userId, long[] folderIds, int status, int start,
2494                    int end,
2495                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2496                    throws com.liferay.portal.kernel.exception.SystemException {
2497                    return getPersistence()
2498                                       .findByG_U_F_S(groupId, userId, folderIds, status, start,
2499                            end, orderByComparator);
2500            }
2501    
2502            /**
2503            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63; from the database.
2504            *
2505            * @param groupId the group ID
2506            * @param userId the user ID
2507            * @param folderId the folder ID
2508            * @param status the status
2509            * @throws SystemException if a system exception occurred
2510            */
2511            public static void removeByG_U_F_S(long groupId, long userId,
2512                    long folderId, int status)
2513                    throws com.liferay.portal.kernel.exception.SystemException {
2514                    getPersistence().removeByG_U_F_S(groupId, userId, folderId, status);
2515            }
2516    
2517            /**
2518            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2519            *
2520            * @param groupId the group ID
2521            * @param userId the user ID
2522            * @param folderId the folder ID
2523            * @param status the status
2524            * @return the number of matching bookmarks entries
2525            * @throws SystemException if a system exception occurred
2526            */
2527            public static int countByG_U_F_S(long groupId, long userId, long folderId,
2528                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence().countByG_U_F_S(groupId, userId, folderId, status);
2530            }
2531    
2532            /**
2533            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2534            *
2535            * @param groupId the group ID
2536            * @param userId the user ID
2537            * @param folderIds the folder IDs
2538            * @param status the status
2539            * @return the number of matching bookmarks entries
2540            * @throws SystemException if a system exception occurred
2541            */
2542            public static int countByG_U_F_S(long groupId, long userId,
2543                    long[] folderIds, int status)
2544                    throws com.liferay.portal.kernel.exception.SystemException {
2545                    return getPersistence()
2546                                       .countByG_U_F_S(groupId, userId, folderIds, status);
2547            }
2548    
2549            /**
2550            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2551            *
2552            * @param groupId the group ID
2553            * @param userId the user ID
2554            * @param folderId the folder ID
2555            * @param status the status
2556            * @return the number of matching bookmarks entries that the user has permission to view
2557            * @throws SystemException if a system exception occurred
2558            */
2559            public static int filterCountByG_U_F_S(long groupId, long userId,
2560                    long folderId, int status)
2561                    throws com.liferay.portal.kernel.exception.SystemException {
2562                    return getPersistence()
2563                                       .filterCountByG_U_F_S(groupId, userId, folderId, status);
2564            }
2565    
2566            /**
2567            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2568            *
2569            * @param groupId the group ID
2570            * @param userId the user ID
2571            * @param folderIds the folder IDs
2572            * @param status the status
2573            * @return the number of matching bookmarks entries that the user has permission to view
2574            * @throws SystemException if a system exception occurred
2575            */
2576            public static int filterCountByG_U_F_S(long groupId, long userId,
2577                    long[] folderIds, int status)
2578                    throws com.liferay.portal.kernel.exception.SystemException {
2579                    return getPersistence()
2580                                       .filterCountByG_U_F_S(groupId, userId, folderIds, status);
2581            }
2582    
2583            /**
2584            * Caches the bookmarks entry in the entity cache if it is enabled.
2585            *
2586            * @param bookmarksEntry the bookmarks entry
2587            */
2588            public static void cacheResult(
2589                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
2590                    getPersistence().cacheResult(bookmarksEntry);
2591            }
2592    
2593            /**
2594            * Caches the bookmarks entries in the entity cache if it is enabled.
2595            *
2596            * @param bookmarksEntries the bookmarks entries
2597            */
2598            public static void cacheResult(
2599                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
2600                    getPersistence().cacheResult(bookmarksEntries);
2601            }
2602    
2603            /**
2604            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
2605            *
2606            * @param entryId the primary key for the new bookmarks entry
2607            * @return the new bookmarks entry
2608            */
2609            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
2610                    long entryId) {
2611                    return getPersistence().create(entryId);
2612            }
2613    
2614            /**
2615            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
2616            *
2617            * @param entryId the primary key of the bookmarks entry
2618            * @return the bookmarks entry that was removed
2619            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2620            * @throws SystemException if a system exception occurred
2621            */
2622            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
2623                    long entryId)
2624                    throws com.liferay.portal.kernel.exception.SystemException,
2625                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2626                    return getPersistence().remove(entryId);
2627            }
2628    
2629            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
2630                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    return getPersistence().updateImpl(bookmarksEntry);
2633            }
2634    
2635            /**
2636            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
2637            *
2638            * @param entryId the primary key of the bookmarks entry
2639            * @return the bookmarks entry
2640            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2641            * @throws SystemException if a system exception occurred
2642            */
2643            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
2644                    long entryId)
2645                    throws com.liferay.portal.kernel.exception.SystemException,
2646                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2647                    return getPersistence().findByPrimaryKey(entryId);
2648            }
2649    
2650            /**
2651            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
2652            *
2653            * @param entryId the primary key of the bookmarks entry
2654            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
2655            * @throws SystemException if a system exception occurred
2656            */
2657            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
2658                    long entryId)
2659                    throws com.liferay.portal.kernel.exception.SystemException {
2660                    return getPersistence().fetchByPrimaryKey(entryId);
2661            }
2662    
2663            /**
2664            * Returns all the bookmarks entries.
2665            *
2666            * @return the bookmarks entries
2667            * @throws SystemException if a system exception occurred
2668            */
2669            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
2670                    throws com.liferay.portal.kernel.exception.SystemException {
2671                    return getPersistence().findAll();
2672            }
2673    
2674            /**
2675            * Returns a range of all the bookmarks entries.
2676            *
2677            * <p>
2678            * 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.BookmarksEntryModelImpl}. 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.
2679            * </p>
2680            *
2681            * @param start the lower bound of the range of bookmarks entries
2682            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2683            * @return the range of bookmarks entries
2684            * @throws SystemException if a system exception occurred
2685            */
2686            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
2687                    int start, int end)
2688                    throws com.liferay.portal.kernel.exception.SystemException {
2689                    return getPersistence().findAll(start, end);
2690            }
2691    
2692            /**
2693            * Returns an ordered range of all the bookmarks entries.
2694            *
2695            * <p>
2696            * 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.BookmarksEntryModelImpl}. 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.
2697            * </p>
2698            *
2699            * @param start the lower bound of the range of bookmarks entries
2700            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2702            * @return the ordered range of bookmarks entries
2703            * @throws SystemException if a system exception occurred
2704            */
2705            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
2706                    int start, int end,
2707                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2708                    throws com.liferay.portal.kernel.exception.SystemException {
2709                    return getPersistence().findAll(start, end, orderByComparator);
2710            }
2711    
2712            /**
2713            * Removes all the bookmarks entries from the database.
2714            *
2715            * @throws SystemException if a system exception occurred
2716            */
2717            public static void removeAll()
2718                    throws com.liferay.portal.kernel.exception.SystemException {
2719                    getPersistence().removeAll();
2720            }
2721    
2722            /**
2723            * Returns the number of bookmarks entries.
2724            *
2725            * @return the number of bookmarks entries
2726            * @throws SystemException if a system exception occurred
2727            */
2728            public static int countAll()
2729                    throws com.liferay.portal.kernel.exception.SystemException {
2730                    return getPersistence().countAll();
2731            }
2732    
2733            public static BookmarksEntryPersistence getPersistence() {
2734                    if (_persistence == null) {
2735                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
2736    
2737                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
2738                                    "_persistence");
2739                    }
2740    
2741                    return _persistence;
2742            }
2743    
2744            /**
2745             * @deprecated As of 6.2.0
2746             */
2747            public void setPersistence(BookmarksEntryPersistence persistence) {
2748            }
2749    
2750            private static BookmarksEntryPersistence _persistence;
2751    }