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 static long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<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 companyId = &#63;.
693            *
694            * @param companyId the company ID
695            * @return the matching bookmarks entries
696            * @throws SystemException if a system exception occurred
697            */
698            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
699                    long companyId)
700                    throws com.liferay.portal.kernel.exception.SystemException {
701                    return getPersistence().findByCompanyId(companyId);
702            }
703    
704            /**
705            * Returns a range of all the bookmarks entries where companyId = &#63;.
706            *
707            * <p>
708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.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.
709            * </p>
710            *
711            * @param companyId the company ID
712            * @param start the lower bound of the range of bookmarks entries
713            * @param end the upper bound of the range of bookmarks entries (not inclusive)
714            * @return the range of matching bookmarks entries
715            * @throws SystemException if a system exception occurred
716            */
717            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
718                    long companyId, int start, int end)
719                    throws com.liferay.portal.kernel.exception.SystemException {
720                    return getPersistence().findByCompanyId(companyId, start, end);
721            }
722    
723            /**
724            * Returns an ordered range of all the bookmarks entries where companyId = &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.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.
728            * </p>
729            *
730            * @param companyId the company ID
731            * @param start the lower bound of the range of bookmarks entries
732            * @param end the upper bound of the range of bookmarks entries (not inclusive)
733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
734            * @return the ordered range of matching bookmarks entries
735            * @throws SystemException if a system exception occurred
736            */
737            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
738                    long companyId, int start, int end,
739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence()
742                                       .findByCompanyId(companyId, start, end, orderByComparator);
743            }
744    
745            /**
746            * Returns the first bookmarks entry in the ordered set where companyId = &#63;.
747            *
748            * @param companyId the company ID
749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
750            * @return the first matching bookmarks entry
751            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_First(
755                    long companyId,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.bookmarks.NoSuchEntryException {
759                    return getPersistence()
760                                       .findByCompanyId_First(companyId, orderByComparator);
761            }
762    
763            /**
764            * Returns the first bookmarks entry in the ordered set where companyId = &#63;.
765            *
766            * @param companyId the company ID
767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
768            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
769            * @throws SystemException if a system exception occurred
770            */
771            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_First(
772                    long companyId,
773                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
774                    throws com.liferay.portal.kernel.exception.SystemException {
775                    return getPersistence()
776                                       .fetchByCompanyId_First(companyId, orderByComparator);
777            }
778    
779            /**
780            * Returns the last bookmarks entry in the ordered set where companyId = &#63;.
781            *
782            * @param companyId the company ID
783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
784            * @return the last matching bookmarks entry
785            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
786            * @throws SystemException if a system exception occurred
787            */
788            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_Last(
789                    long companyId,
790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
791                    throws com.liferay.portal.kernel.exception.SystemException,
792                            com.liferay.portlet.bookmarks.NoSuchEntryException {
793                    return getPersistence()
794                                       .findByCompanyId_Last(companyId, orderByComparator);
795            }
796    
797            /**
798            * Returns the last bookmarks entry in the ordered set where companyId = &#63;.
799            *
800            * @param companyId the company ID
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
803            * @throws SystemException if a system exception occurred
804            */
805            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_Last(
806                    long companyId,
807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
808                    throws com.liferay.portal.kernel.exception.SystemException {
809                    return getPersistence()
810                                       .fetchByCompanyId_Last(companyId, orderByComparator);
811            }
812    
813            /**
814            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = &#63;.
815            *
816            * @param entryId the primary key of the current bookmarks entry
817            * @param companyId the company ID
818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
819            * @return the previous, current, and next bookmarks entry
820            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
821            * @throws SystemException if a system exception occurred
822            */
823            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByCompanyId_PrevAndNext(
824                    long entryId, long companyId,
825                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
826                    throws com.liferay.portal.kernel.exception.SystemException,
827                            com.liferay.portlet.bookmarks.NoSuchEntryException {
828                    return getPersistence()
829                                       .findByCompanyId_PrevAndNext(entryId, companyId,
830                            orderByComparator);
831            }
832    
833            /**
834            * Removes all the bookmarks entries where companyId = &#63; from the database.
835            *
836            * @param companyId the company ID
837            * @throws SystemException if a system exception occurred
838            */
839            public static void removeByCompanyId(long companyId)
840                    throws com.liferay.portal.kernel.exception.SystemException {
841                    getPersistence().removeByCompanyId(companyId);
842            }
843    
844            /**
845            * Returns the number of bookmarks entries where companyId = &#63;.
846            *
847            * @param companyId the company ID
848            * @return the number of matching bookmarks entries
849            * @throws SystemException if a system exception occurred
850            */
851            public static int countByCompanyId(long companyId)
852                    throws com.liferay.portal.kernel.exception.SystemException {
853                    return getPersistence().countByCompanyId(companyId);
854            }
855    
856            /**
857            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63;.
858            *
859            * @param groupId the group ID
860            * @param folderId the folder ID
861            * @return the matching bookmarks entries
862            * @throws SystemException if a system exception occurred
863            */
864            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
865                    long groupId, long folderId)
866                    throws com.liferay.portal.kernel.exception.SystemException {
867                    return getPersistence().findByG_F(groupId, folderId);
868            }
869    
870            /**
871            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
872            *
873            * <p>
874            * 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.
875            * </p>
876            *
877            * @param groupId the group ID
878            * @param folderId the folder ID
879            * @param start the lower bound of the range of bookmarks entries
880            * @param end the upper bound of the range of bookmarks entries (not inclusive)
881            * @return the range of matching bookmarks entries
882            * @throws SystemException if a system exception occurred
883            */
884            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
885                    long groupId, long folderId, int start, int end)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence().findByG_F(groupId, folderId, start, end);
888            }
889    
890            /**
891            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
892            *
893            * <p>
894            * 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.
895            * </p>
896            *
897            * @param groupId the group ID
898            * @param folderId the folder ID
899            * @param start the lower bound of the range of bookmarks entries
900            * @param end the upper bound of the range of bookmarks entries (not inclusive)
901            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
902            * @return the ordered range of matching bookmarks entries
903            * @throws SystemException if a system exception occurred
904            */
905            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
906                    long groupId, long folderId, int start, int end,
907                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
908                    throws com.liferay.portal.kernel.exception.SystemException {
909                    return getPersistence()
910                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
911            }
912    
913            /**
914            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
915            *
916            * @param groupId the group ID
917            * @param folderId the folder ID
918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
919            * @return the first matching bookmarks entry
920            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
921            * @throws SystemException if a system exception occurred
922            */
923            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
924                    long groupId, long folderId,
925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
926                    throws com.liferay.portal.kernel.exception.SystemException,
927                            com.liferay.portlet.bookmarks.NoSuchEntryException {
928                    return getPersistence()
929                                       .findByG_F_First(groupId, folderId, orderByComparator);
930            }
931    
932            /**
933            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
934            *
935            * @param groupId the group ID
936            * @param folderId the folder ID
937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
938            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
939            * @throws SystemException if a system exception occurred
940            */
941            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First(
942                    long groupId, long folderId,
943                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
944                    throws com.liferay.portal.kernel.exception.SystemException {
945                    return getPersistence()
946                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
947            }
948    
949            /**
950            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
951            *
952            * @param groupId the group ID
953            * @param folderId the folder ID
954            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
955            * @return the last matching bookmarks entry
956            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
957            * @throws SystemException if a system exception occurred
958            */
959            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
960                    long groupId, long folderId,
961                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
962                    throws com.liferay.portal.kernel.exception.SystemException,
963                            com.liferay.portlet.bookmarks.NoSuchEntryException {
964                    return getPersistence()
965                                       .findByG_F_Last(groupId, folderId, orderByComparator);
966            }
967    
968            /**
969            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
970            *
971            * @param groupId the group ID
972            * @param folderId the folder ID
973            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
974            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
975            * @throws SystemException if a system exception occurred
976            */
977            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last(
978                    long groupId, long folderId,
979                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
980                    throws com.liferay.portal.kernel.exception.SystemException {
981                    return getPersistence()
982                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
983            }
984    
985            /**
986            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
987            *
988            * @param entryId the primary key of the current bookmarks entry
989            * @param groupId the group ID
990            * @param folderId the folder ID
991            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
992            * @return the previous, current, and next bookmarks entry
993            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
994            * @throws SystemException if a system exception occurred
995            */
996            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
997                    long entryId, long groupId, long folderId,
998                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
999                    throws com.liferay.portal.kernel.exception.SystemException,
1000                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1001                    return getPersistence()
1002                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
1003                            orderByComparator);
1004            }
1005    
1006            /**
1007            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1008            *
1009            * @param groupId the group ID
1010            * @param folderId the folder ID
1011            * @return the matching bookmarks entries that the user has permission to view
1012            * @throws SystemException if a system exception occurred
1013            */
1014            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1015                    long groupId, long folderId)
1016                    throws com.liferay.portal.kernel.exception.SystemException {
1017                    return getPersistence().filterFindByG_F(groupId, folderId);
1018            }
1019    
1020            /**
1021            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1022            *
1023            * <p>
1024            * 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.
1025            * </p>
1026            *
1027            * @param groupId the group ID
1028            * @param folderId the folder ID
1029            * @param start the lower bound of the range of bookmarks entries
1030            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1031            * @return the range of matching bookmarks entries that the user has permission to view
1032            * @throws SystemException if a system exception occurred
1033            */
1034            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1035                    long groupId, long folderId, int start, int end)
1036                    throws com.liferay.portal.kernel.exception.SystemException {
1037                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
1038            }
1039    
1040            /**
1041            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
1042            *
1043            * <p>
1044            * 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.
1045            * </p>
1046            *
1047            * @param groupId the group ID
1048            * @param folderId the folder ID
1049            * @param start the lower bound of the range of bookmarks entries
1050            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1051            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1052            * @return the ordered range of matching bookmarks entries that the user has permission to view
1053            * @throws SystemException if a system exception occurred
1054            */
1055            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1056                    long groupId, long folderId, int start, int end,
1057                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    return getPersistence()
1060                                       .filterFindByG_F(groupId, folderId, start, end,
1061                            orderByComparator);
1062            }
1063    
1064            /**
1065            * 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;.
1066            *
1067            * @param entryId the primary key of the current bookmarks entry
1068            * @param groupId the group ID
1069            * @param folderId the folder ID
1070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1071            * @return the previous, current, and next bookmarks entry
1072            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
1076                    long entryId, long groupId, long folderId,
1077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1078                    throws com.liferay.portal.kernel.exception.SystemException,
1079                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1080                    return getPersistence()
1081                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
1082                            orderByComparator);
1083            }
1084    
1085            /**
1086            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1087            *
1088            * @param groupId the group ID
1089            * @param folderIds the folder IDs
1090            * @return the matching bookmarks entries that the user has permission to view
1091            * @throws SystemException if a system exception occurred
1092            */
1093            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1094                    long groupId, long[] folderIds)
1095                    throws com.liferay.portal.kernel.exception.SystemException {
1096                    return getPersistence().filterFindByG_F(groupId, folderIds);
1097            }
1098    
1099            /**
1100            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1101            *
1102            * <p>
1103            * 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.
1104            * </p>
1105            *
1106            * @param groupId the group ID
1107            * @param folderIds the folder IDs
1108            * @param start the lower bound of the range of bookmarks entries
1109            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1110            * @return the range of matching bookmarks entries that the user has permission to view
1111            * @throws SystemException if a system exception occurred
1112            */
1113            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1114                    long groupId, long[] folderIds, int start, int end)
1115                    throws com.liferay.portal.kernel.exception.SystemException {
1116                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
1117            }
1118    
1119            /**
1120            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1121            *
1122            * <p>
1123            * 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.
1124            * </p>
1125            *
1126            * @param groupId the group ID
1127            * @param folderIds the folder IDs
1128            * @param start the lower bound of the range of bookmarks entries
1129            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1130            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1131            * @return the ordered range of matching bookmarks entries that the user has permission to view
1132            * @throws SystemException if a system exception occurred
1133            */
1134            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1135                    long groupId, long[] folderIds, int start, int end,
1136                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1137                    throws com.liferay.portal.kernel.exception.SystemException {
1138                    return getPersistence()
1139                                       .filterFindByG_F(groupId, folderIds, start, end,
1140                            orderByComparator);
1141            }
1142    
1143            /**
1144            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1145            *
1146            * <p>
1147            * 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.
1148            * </p>
1149            *
1150            * @param groupId the group ID
1151            * @param folderIds the folder IDs
1152            * @return the matching bookmarks entries
1153            * @throws SystemException if a system exception occurred
1154            */
1155            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1156                    long groupId, long[] folderIds)
1157                    throws com.liferay.portal.kernel.exception.SystemException {
1158                    return getPersistence().findByG_F(groupId, folderIds);
1159            }
1160    
1161            /**
1162            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1163            *
1164            * <p>
1165            * 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.
1166            * </p>
1167            *
1168            * @param groupId the group ID
1169            * @param folderIds the folder IDs
1170            * @param start the lower bound of the range of bookmarks entries
1171            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1172            * @return the range of matching bookmarks entries
1173            * @throws SystemException if a system exception occurred
1174            */
1175            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1176                    long groupId, long[] folderIds, int start, int end)
1177                    throws com.liferay.portal.kernel.exception.SystemException {
1178                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1179            }
1180    
1181            /**
1182            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1183            *
1184            * <p>
1185            * 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.
1186            * </p>
1187            *
1188            * @param groupId the group ID
1189            * @param folderIds the folder IDs
1190            * @param start the lower bound of the range of bookmarks entries
1191            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1192            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1193            * @return the ordered range of matching bookmarks entries
1194            * @throws SystemException if a system exception occurred
1195            */
1196            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1197                    long groupId, long[] folderIds, int start, int end,
1198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1199                    throws com.liferay.portal.kernel.exception.SystemException {
1200                    return getPersistence()
1201                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1202            }
1203    
1204            /**
1205            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1206            *
1207            * @param groupId the group ID
1208            * @param folderId the folder ID
1209            * @throws SystemException if a system exception occurred
1210            */
1211            public static void removeByG_F(long groupId, long folderId)
1212                    throws com.liferay.portal.kernel.exception.SystemException {
1213                    getPersistence().removeByG_F(groupId, folderId);
1214            }
1215    
1216            /**
1217            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63;.
1218            *
1219            * @param groupId the group ID
1220            * @param folderId the folder ID
1221            * @return the number of matching bookmarks entries
1222            * @throws SystemException if a system exception occurred
1223            */
1224            public static int countByG_F(long groupId, long folderId)
1225                    throws com.liferay.portal.kernel.exception.SystemException {
1226                    return getPersistence().countByG_F(groupId, folderId);
1227            }
1228    
1229            /**
1230            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63;.
1231            *
1232            * @param groupId the group ID
1233            * @param folderIds the folder IDs
1234            * @return the number of matching bookmarks entries
1235            * @throws SystemException if a system exception occurred
1236            */
1237            public static int countByG_F(long groupId, long[] folderIds)
1238                    throws com.liferay.portal.kernel.exception.SystemException {
1239                    return getPersistence().countByG_F(groupId, folderIds);
1240            }
1241    
1242            /**
1243            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1244            *
1245            * @param groupId the group ID
1246            * @param folderId the folder ID
1247            * @return the number of matching bookmarks entries that the user has permission to view
1248            * @throws SystemException if a system exception occurred
1249            */
1250            public static int filterCountByG_F(long groupId, long folderId)
1251                    throws com.liferay.portal.kernel.exception.SystemException {
1252                    return getPersistence().filterCountByG_F(groupId, folderId);
1253            }
1254    
1255            /**
1256            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1257            *
1258            * @param groupId the group ID
1259            * @param folderIds the folder IDs
1260            * @return the number of matching bookmarks entries that the user has permission to view
1261            * @throws SystemException if a system exception occurred
1262            */
1263            public static int filterCountByG_F(long groupId, long[] folderIds)
1264                    throws com.liferay.portal.kernel.exception.SystemException {
1265                    return getPersistence().filterCountByG_F(groupId, folderIds);
1266            }
1267    
1268            /**
1269            * Returns all the bookmarks entries where groupId = &#63; and status = &#63;.
1270            *
1271            * @param groupId the group ID
1272            * @param status the status
1273            * @return the matching bookmarks entries
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1277                    long groupId, int status)
1278                    throws com.liferay.portal.kernel.exception.SystemException {
1279                    return getPersistence().findByG_S(groupId, status);
1280            }
1281    
1282            /**
1283            * Returns a range of all the bookmarks entries where groupId = &#63; and status = &#63;.
1284            *
1285            * <p>
1286            * 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.
1287            * </p>
1288            *
1289            * @param groupId the group ID
1290            * @param status the status
1291            * @param start the lower bound of the range of bookmarks entries
1292            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1293            * @return the range of matching bookmarks entries
1294            * @throws SystemException if a system exception occurred
1295            */
1296            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1297                    long groupId, int status, int start, int end)
1298                    throws com.liferay.portal.kernel.exception.SystemException {
1299                    return getPersistence().findByG_S(groupId, status, start, end);
1300            }
1301    
1302            /**
1303            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and status = &#63;.
1304            *
1305            * <p>
1306            * 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.
1307            * </p>
1308            *
1309            * @param groupId the group ID
1310            * @param status the status
1311            * @param start the lower bound of the range of bookmarks entries
1312            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1313            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1314            * @return the ordered range of matching bookmarks entries
1315            * @throws SystemException if a system exception occurred
1316            */
1317            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1318                    long groupId, int status, int start, int end,
1319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1320                    throws com.liferay.portal.kernel.exception.SystemException {
1321                    return getPersistence()
1322                                       .findByG_S(groupId, status, start, end, orderByComparator);
1323            }
1324    
1325            /**
1326            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1327            *
1328            * @param groupId the group ID
1329            * @param status the status
1330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1331            * @return the first matching bookmarks entry
1332            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1333            * @throws SystemException if a system exception occurred
1334            */
1335            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First(
1336                    long groupId, int status,
1337                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1338                    throws com.liferay.portal.kernel.exception.SystemException,
1339                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1340                    return getPersistence()
1341                                       .findByG_S_First(groupId, status, orderByComparator);
1342            }
1343    
1344            /**
1345            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1346            *
1347            * @param groupId the group ID
1348            * @param status the status
1349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1350            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1351            * @throws SystemException if a system exception occurred
1352            */
1353            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First(
1354                    long groupId, int status,
1355                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1356                    throws com.liferay.portal.kernel.exception.SystemException {
1357                    return getPersistence()
1358                                       .fetchByG_S_First(groupId, status, orderByComparator);
1359            }
1360    
1361            /**
1362            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1363            *
1364            * @param groupId the group ID
1365            * @param status the status
1366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1367            * @return the last matching bookmarks entry
1368            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1369            * @throws SystemException if a system exception occurred
1370            */
1371            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last(
1372                    long groupId, int status,
1373                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1374                    throws com.liferay.portal.kernel.exception.SystemException,
1375                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1376                    return getPersistence()
1377                                       .findByG_S_Last(groupId, status, orderByComparator);
1378            }
1379    
1380            /**
1381            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1382            *
1383            * @param groupId the group ID
1384            * @param status the status
1385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1386            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1387            * @throws SystemException if a system exception occurred
1388            */
1389            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last(
1390                    long groupId, int status,
1391                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1392                    throws com.liferay.portal.kernel.exception.SystemException {
1393                    return getPersistence()
1394                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1395            }
1396    
1397            /**
1398            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1399            *
1400            * @param entryId the primary key of the current bookmarks entry
1401            * @param groupId the group ID
1402            * @param status the status
1403            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1404            * @return the previous, current, and next bookmarks entry
1405            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1406            * @throws SystemException if a system exception occurred
1407            */
1408            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext(
1409                    long entryId, long groupId, int status,
1410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1411                    throws com.liferay.portal.kernel.exception.SystemException,
1412                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1413                    return getPersistence()
1414                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1415                            orderByComparator);
1416            }
1417    
1418            /**
1419            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1420            *
1421            * @param groupId the group ID
1422            * @param status the status
1423            * @return the matching bookmarks entries that the user has permission to view
1424            * @throws SystemException if a system exception occurred
1425            */
1426            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1427                    long groupId, int status)
1428                    throws com.liferay.portal.kernel.exception.SystemException {
1429                    return getPersistence().filterFindByG_S(groupId, status);
1430            }
1431    
1432            /**
1433            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1434            *
1435            * <p>
1436            * 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.
1437            * </p>
1438            *
1439            * @param groupId the group ID
1440            * @param status the status
1441            * @param start the lower bound of the range of bookmarks entries
1442            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1443            * @return the range of matching bookmarks entries that the user has permission to view
1444            * @throws SystemException if a system exception occurred
1445            */
1446            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1447                    long groupId, int status, int start, int end)
1448                    throws com.liferay.portal.kernel.exception.SystemException {
1449                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1450            }
1451    
1452            /**
1453            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status = &#63;.
1454            *
1455            * <p>
1456            * 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.
1457            * </p>
1458            *
1459            * @param groupId the group ID
1460            * @param status the status
1461            * @param start the lower bound of the range of bookmarks entries
1462            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1463            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1464            * @return the ordered range of matching bookmarks entries that the user has permission to view
1465            * @throws SystemException if a system exception occurred
1466            */
1467            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1468                    long groupId, int status, int start, int end,
1469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1470                    throws com.liferay.portal.kernel.exception.SystemException {
1471                    return getPersistence()
1472                                       .filterFindByG_S(groupId, status, start, end,
1473                            orderByComparator);
1474            }
1475    
1476            /**
1477            * 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;.
1478            *
1479            * @param entryId the primary key of the current bookmarks entry
1480            * @param groupId the group ID
1481            * @param status the status
1482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1483            * @return the previous, current, and next bookmarks entry
1484            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1485            * @throws SystemException if a system exception occurred
1486            */
1487            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext(
1488                    long entryId, long groupId, int status,
1489                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1490                    throws com.liferay.portal.kernel.exception.SystemException,
1491                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1492                    return getPersistence()
1493                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
1494                            orderByComparator);
1495            }
1496    
1497            /**
1498            * Removes all the bookmarks entries where groupId = &#63; and status = &#63; from the database.
1499            *
1500            * @param groupId the group ID
1501            * @param status the status
1502            * @throws SystemException if a system exception occurred
1503            */
1504            public static void removeByG_S(long groupId, int status)
1505                    throws com.liferay.portal.kernel.exception.SystemException {
1506                    getPersistence().removeByG_S(groupId, status);
1507            }
1508    
1509            /**
1510            * Returns the number of bookmarks entries where groupId = &#63; and status = &#63;.
1511            *
1512            * @param groupId the group ID
1513            * @param status the status
1514            * @return the number of matching bookmarks entries
1515            * @throws SystemException if a system exception occurred
1516            */
1517            public static int countByG_S(long groupId, int status)
1518                    throws com.liferay.portal.kernel.exception.SystemException {
1519                    return getPersistence().countByG_S(groupId, status);
1520            }
1521    
1522            /**
1523            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1524            *
1525            * @param groupId the group ID
1526            * @param status the status
1527            * @return the number of matching bookmarks entries that the user has permission to view
1528            * @throws SystemException if a system exception occurred
1529            */
1530            public static int filterCountByG_S(long groupId, int status)
1531                    throws com.liferay.portal.kernel.exception.SystemException {
1532                    return getPersistence().filterCountByG_S(groupId, status);
1533            }
1534    
1535            /**
1536            * Returns all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1537            *
1538            * @param companyId the company ID
1539            * @param status the status
1540            * @return the matching bookmarks entries
1541            * @throws SystemException if a system exception occurred
1542            */
1543            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1544                    long companyId, int status)
1545                    throws com.liferay.portal.kernel.exception.SystemException {
1546                    return getPersistence().findByC_NotS(companyId, status);
1547            }
1548    
1549            /**
1550            * Returns a range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1551            *
1552            * <p>
1553            * 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.
1554            * </p>
1555            *
1556            * @param companyId the company ID
1557            * @param status the status
1558            * @param start the lower bound of the range of bookmarks entries
1559            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1560            * @return the range of matching bookmarks entries
1561            * @throws SystemException if a system exception occurred
1562            */
1563            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1564                    long companyId, int status, int start, int end)
1565                    throws com.liferay.portal.kernel.exception.SystemException {
1566                    return getPersistence().findByC_NotS(companyId, status, start, end);
1567            }
1568    
1569            /**
1570            * Returns an ordered range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1571            *
1572            * <p>
1573            * 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.
1574            * </p>
1575            *
1576            * @param companyId the company ID
1577            * @param status the status
1578            * @param start the lower bound of the range of bookmarks entries
1579            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1580            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1581            * @return the ordered range of matching bookmarks entries
1582            * @throws SystemException if a system exception occurred
1583            */
1584            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1585                    long companyId, int status, int start, int end,
1586                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1587                    throws com.liferay.portal.kernel.exception.SystemException {
1588                    return getPersistence()
1589                                       .findByC_NotS(companyId, status, start, end,
1590                            orderByComparator);
1591            }
1592    
1593            /**
1594            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1595            *
1596            * @param companyId the company ID
1597            * @param status the status
1598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1599            * @return the first matching bookmarks entry
1600            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1601            * @throws SystemException if a system exception occurred
1602            */
1603            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First(
1604                    long companyId, int status,
1605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1606                    throws com.liferay.portal.kernel.exception.SystemException,
1607                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1608                    return getPersistence()
1609                                       .findByC_NotS_First(companyId, status, orderByComparator);
1610            }
1611    
1612            /**
1613            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1614            *
1615            * @param companyId the company ID
1616            * @param status the status
1617            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1618            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1619            * @throws SystemException if a system exception occurred
1620            */
1621            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First(
1622                    long companyId, int status,
1623                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1624                    throws com.liferay.portal.kernel.exception.SystemException {
1625                    return getPersistence()
1626                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1627            }
1628    
1629            /**
1630            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1631            *
1632            * @param companyId the company ID
1633            * @param status the status
1634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1635            * @return the last matching bookmarks entry
1636            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1637            * @throws SystemException if a system exception occurred
1638            */
1639            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last(
1640                    long companyId, int status,
1641                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1642                    throws com.liferay.portal.kernel.exception.SystemException,
1643                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1644                    return getPersistence()
1645                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1646            }
1647    
1648            /**
1649            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1650            *
1651            * @param companyId the company ID
1652            * @param status the status
1653            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1654            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1655            * @throws SystemException if a system exception occurred
1656            */
1657            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last(
1658                    long companyId, int status,
1659                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1660                    throws com.liferay.portal.kernel.exception.SystemException {
1661                    return getPersistence()
1662                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1663            }
1664    
1665            /**
1666            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1667            *
1668            * @param entryId the primary key of the current bookmarks entry
1669            * @param companyId the company ID
1670            * @param status the status
1671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1672            * @return the previous, current, and next bookmarks entry
1673            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1674            * @throws SystemException if a system exception occurred
1675            */
1676            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext(
1677                    long entryId, long companyId, int status,
1678                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1679                    throws com.liferay.portal.kernel.exception.SystemException,
1680                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1681                    return getPersistence()
1682                                       .findByC_NotS_PrevAndNext(entryId, companyId, status,
1683                            orderByComparator);
1684            }
1685    
1686            /**
1687            * Removes all the bookmarks entries where companyId = &#63; and status &ne; &#63; from the database.
1688            *
1689            * @param companyId the company ID
1690            * @param status the status
1691            * @throws SystemException if a system exception occurred
1692            */
1693            public static void removeByC_NotS(long companyId, int status)
1694                    throws com.liferay.portal.kernel.exception.SystemException {
1695                    getPersistence().removeByC_NotS(companyId, status);
1696            }
1697    
1698            /**
1699            * Returns the number of bookmarks entries where companyId = &#63; and status &ne; &#63;.
1700            *
1701            * @param companyId the company ID
1702            * @param status the status
1703            * @return the number of matching bookmarks entries
1704            * @throws SystemException if a system exception occurred
1705            */
1706            public static int countByC_NotS(long companyId, int status)
1707                    throws com.liferay.portal.kernel.exception.SystemException {
1708                    return getPersistence().countByC_NotS(companyId, status);
1709            }
1710    
1711            /**
1712            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1713            *
1714            * @param groupId the group ID
1715            * @param userId the user ID
1716            * @param status the status
1717            * @return the matching bookmarks entries
1718            * @throws SystemException if a system exception occurred
1719            */
1720            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1721                    long groupId, long userId, int status)
1722                    throws com.liferay.portal.kernel.exception.SystemException {
1723                    return getPersistence().findByG_U_S(groupId, userId, status);
1724            }
1725    
1726            /**
1727            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1728            *
1729            * <p>
1730            * 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.
1731            * </p>
1732            *
1733            * @param groupId the group ID
1734            * @param userId the user ID
1735            * @param status the status
1736            * @param start the lower bound of the range of bookmarks entries
1737            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1738            * @return the range of matching bookmarks entries
1739            * @throws SystemException if a system exception occurred
1740            */
1741            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1742                    long groupId, long userId, int status, int start, int end)
1743                    throws com.liferay.portal.kernel.exception.SystemException {
1744                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
1745            }
1746    
1747            /**
1748            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1749            *
1750            * <p>
1751            * 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.
1752            * </p>
1753            *
1754            * @param groupId the group ID
1755            * @param userId the user ID
1756            * @param status the status
1757            * @param start the lower bound of the range of bookmarks entries
1758            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1759            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1760            * @return the ordered range of matching bookmarks entries
1761            * @throws SystemException if a system exception occurred
1762            */
1763            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1764                    long groupId, long userId, int status, int start, int end,
1765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1766                    throws com.liferay.portal.kernel.exception.SystemException {
1767                    return getPersistence()
1768                                       .findByG_U_S(groupId, userId, status, start, end,
1769                            orderByComparator);
1770            }
1771    
1772            /**
1773            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1774            *
1775            * @param groupId the group ID
1776            * @param userId the user ID
1777            * @param status the status
1778            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1779            * @return the first matching bookmarks entry
1780            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1781            * @throws SystemException if a system exception occurred
1782            */
1783            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First(
1784                    long groupId, long userId, int status,
1785                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1786                    throws com.liferay.portal.kernel.exception.SystemException,
1787                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1788                    return getPersistence()
1789                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
1790            }
1791    
1792            /**
1793            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1794            *
1795            * @param groupId the group ID
1796            * @param userId the user ID
1797            * @param status the status
1798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1799            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1800            * @throws SystemException if a system exception occurred
1801            */
1802            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First(
1803                    long groupId, long userId, int status,
1804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1805                    throws com.liferay.portal.kernel.exception.SystemException {
1806                    return getPersistence()
1807                                       .fetchByG_U_S_First(groupId, userId, status,
1808                            orderByComparator);
1809            }
1810    
1811            /**
1812            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1813            *
1814            * @param groupId the group ID
1815            * @param userId the user ID
1816            * @param status the status
1817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1818            * @return the last matching bookmarks entry
1819            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1820            * @throws SystemException if a system exception occurred
1821            */
1822            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last(
1823                    long groupId, long userId, int status,
1824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1825                    throws com.liferay.portal.kernel.exception.SystemException,
1826                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1827                    return getPersistence()
1828                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
1829            }
1830    
1831            /**
1832            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1833            *
1834            * @param groupId the group ID
1835            * @param userId the user ID
1836            * @param status the status
1837            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1838            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1839            * @throws SystemException if a system exception occurred
1840            */
1841            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last(
1842                    long groupId, long userId, int status,
1843                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1844                    throws com.liferay.portal.kernel.exception.SystemException {
1845                    return getPersistence()
1846                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
1847            }
1848    
1849            /**
1850            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1851            *
1852            * @param entryId the primary key of the current bookmarks entry
1853            * @param groupId the group ID
1854            * @param userId the user ID
1855            * @param status the status
1856            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1857            * @return the previous, current, and next bookmarks entry
1858            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1859            * @throws SystemException if a system exception occurred
1860            */
1861            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext(
1862                    long entryId, long groupId, long userId, int status,
1863                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1864                    throws com.liferay.portal.kernel.exception.SystemException,
1865                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1866                    return getPersistence()
1867                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
1868                            orderByComparator);
1869            }
1870    
1871            /**
1872            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1873            *
1874            * @param groupId the group ID
1875            * @param userId the user ID
1876            * @param status the status
1877            * @return the matching bookmarks entries that the user has permission to view
1878            * @throws SystemException if a system exception occurred
1879            */
1880            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1881                    long groupId, long userId, int status)
1882                    throws com.liferay.portal.kernel.exception.SystemException {
1883                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
1884            }
1885    
1886            /**
1887            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1888            *
1889            * <p>
1890            * 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.
1891            * </p>
1892            *
1893            * @param groupId the group ID
1894            * @param userId the user ID
1895            * @param status the status
1896            * @param start the lower bound of the range of bookmarks entries
1897            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1898            * @return the range of matching bookmarks entries that the user has permission to view
1899            * @throws SystemException if a system exception occurred
1900            */
1901            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1902                    long groupId, long userId, int status, int start, int end)
1903                    throws com.liferay.portal.kernel.exception.SystemException {
1904                    return getPersistence()
1905                                       .filterFindByG_U_S(groupId, userId, status, start, end);
1906            }
1907    
1908            /**
1909            * 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;.
1910            *
1911            * <p>
1912            * 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.
1913            * </p>
1914            *
1915            * @param groupId the group ID
1916            * @param userId the user ID
1917            * @param status the status
1918            * @param start the lower bound of the range of bookmarks entries
1919            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1920            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1921            * @return the ordered range of matching bookmarks entries that the user has permission to view
1922            * @throws SystemException if a system exception occurred
1923            */
1924            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1925                    long groupId, long userId, int status, int start, int end,
1926                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1927                    throws com.liferay.portal.kernel.exception.SystemException {
1928                    return getPersistence()
1929                                       .filterFindByG_U_S(groupId, userId, status, start, end,
1930                            orderByComparator);
1931            }
1932    
1933            /**
1934            * 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;.
1935            *
1936            * @param entryId the primary key of the current bookmarks entry
1937            * @param groupId the group ID
1938            * @param userId the user ID
1939            * @param status the status
1940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1941            * @return the previous, current, and next bookmarks entry
1942            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1943            * @throws SystemException if a system exception occurred
1944            */
1945            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext(
1946                    long entryId, long groupId, long userId, int status,
1947                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1948                    throws com.liferay.portal.kernel.exception.SystemException,
1949                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1950                    return getPersistence()
1951                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
1952                            status, orderByComparator);
1953            }
1954    
1955            /**
1956            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
1957            *
1958            * @param groupId the group ID
1959            * @param userId the user ID
1960            * @param status the status
1961            * @throws SystemException if a system exception occurred
1962            */
1963            public static void removeByG_U_S(long groupId, long userId, int status)
1964                    throws com.liferay.portal.kernel.exception.SystemException {
1965                    getPersistence().removeByG_U_S(groupId, userId, status);
1966            }
1967    
1968            /**
1969            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1970            *
1971            * @param groupId the group ID
1972            * @param userId the user ID
1973            * @param status the status
1974            * @return the number of matching bookmarks entries
1975            * @throws SystemException if a system exception occurred
1976            */
1977            public static int countByG_U_S(long groupId, long userId, int status)
1978                    throws com.liferay.portal.kernel.exception.SystemException {
1979                    return getPersistence().countByG_U_S(groupId, userId, status);
1980            }
1981    
1982            /**
1983            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1984            *
1985            * @param groupId the group ID
1986            * @param userId the user ID
1987            * @param status the status
1988            * @return the number of matching bookmarks entries that the user has permission to view
1989            * @throws SystemException if a system exception occurred
1990            */
1991            public static int filterCountByG_U_S(long groupId, long userId, int status)
1992                    throws com.liferay.portal.kernel.exception.SystemException {
1993                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
1994            }
1995    
1996            /**
1997            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1998            *
1999            * @param groupId the group ID
2000            * @param folderId the folder ID
2001            * @param status the status
2002            * @return the matching bookmarks entries
2003            * @throws SystemException if a system exception occurred
2004            */
2005            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2006                    long groupId, long folderId, int status)
2007                    throws com.liferay.portal.kernel.exception.SystemException {
2008                    return getPersistence().findByG_F_S(groupId, folderId, status);
2009            }
2010    
2011            /**
2012            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2013            *
2014            * <p>
2015            * 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.
2016            * </p>
2017            *
2018            * @param groupId the group ID
2019            * @param folderId the folder ID
2020            * @param status the status
2021            * @param start the lower bound of the range of bookmarks entries
2022            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2023            * @return the range of matching bookmarks entries
2024            * @throws SystemException if a system exception occurred
2025            */
2026            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2027                    long groupId, long folderId, int status, int start, int end)
2028                    throws com.liferay.portal.kernel.exception.SystemException {
2029                    return getPersistence()
2030                                       .findByG_F_S(groupId, folderId, status, start, end);
2031            }
2032    
2033            /**
2034            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2035            *
2036            * <p>
2037            * 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.
2038            * </p>
2039            *
2040            * @param groupId the group ID
2041            * @param folderId the folder ID
2042            * @param status the status
2043            * @param start the lower bound of the range of bookmarks entries
2044            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2045            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2046            * @return the ordered range of matching bookmarks entries
2047            * @throws SystemException if a system exception occurred
2048            */
2049            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2050                    long groupId, long folderId, int status, int start, int end,
2051                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2052                    throws com.liferay.portal.kernel.exception.SystemException {
2053                    return getPersistence()
2054                                       .findByG_F_S(groupId, folderId, status, start, end,
2055                            orderByComparator);
2056            }
2057    
2058            /**
2059            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2060            *
2061            * @param groupId the group ID
2062            * @param folderId the folder ID
2063            * @param status the status
2064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2065            * @return the first matching bookmarks entry
2066            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2067            * @throws SystemException if a system exception occurred
2068            */
2069            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First(
2070                    long groupId, long folderId, int status,
2071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2072                    throws com.liferay.portal.kernel.exception.SystemException,
2073                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2074                    return getPersistence()
2075                                       .findByG_F_S_First(groupId, folderId, status,
2076                            orderByComparator);
2077            }
2078    
2079            /**
2080            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2081            *
2082            * @param groupId the group ID
2083            * @param folderId the folder ID
2084            * @param status the status
2085            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2086            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2087            * @throws SystemException if a system exception occurred
2088            */
2089            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First(
2090                    long groupId, long folderId, int status,
2091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2092                    throws com.liferay.portal.kernel.exception.SystemException {
2093                    return getPersistence()
2094                                       .fetchByG_F_S_First(groupId, folderId, status,
2095                            orderByComparator);
2096            }
2097    
2098            /**
2099            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2100            *
2101            * @param groupId the group ID
2102            * @param folderId the folder ID
2103            * @param status the status
2104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2105            * @return the last matching bookmarks entry
2106            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2107            * @throws SystemException if a system exception occurred
2108            */
2109            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last(
2110                    long groupId, long folderId, int status,
2111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2112                    throws com.liferay.portal.kernel.exception.SystemException,
2113                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2114                    return getPersistence()
2115                                       .findByG_F_S_Last(groupId, folderId, status,
2116                            orderByComparator);
2117            }
2118    
2119            /**
2120            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2121            *
2122            * @param groupId the group ID
2123            * @param folderId the folder ID
2124            * @param status the status
2125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2126            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2127            * @throws SystemException if a system exception occurred
2128            */
2129            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last(
2130                    long groupId, long folderId, int status,
2131                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2132                    throws com.liferay.portal.kernel.exception.SystemException {
2133                    return getPersistence()
2134                                       .fetchByG_F_S_Last(groupId, folderId, status,
2135                            orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2140            *
2141            * @param entryId the primary key of the current bookmarks entry
2142            * @param groupId the group ID
2143            * @param folderId the folder ID
2144            * @param status the status
2145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2146            * @return the previous, current, and next bookmarks entry
2147            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2148            * @throws SystemException if a system exception occurred
2149            */
2150            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext(
2151                    long entryId, long groupId, long folderId, int status,
2152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2153                    throws com.liferay.portal.kernel.exception.SystemException,
2154                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2155                    return getPersistence()
2156                                       .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status,
2157                            orderByComparator);
2158            }
2159    
2160            /**
2161            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2162            *
2163            * @param groupId the group ID
2164            * @param folderId the folder ID
2165            * @param status the status
2166            * @return the matching bookmarks entries that the user has permission to view
2167            * @throws SystemException if a system exception occurred
2168            */
2169            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2170                    long groupId, long folderId, int status)
2171                    throws com.liferay.portal.kernel.exception.SystemException {
2172                    return getPersistence().filterFindByG_F_S(groupId, folderId, status);
2173            }
2174    
2175            /**
2176            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2177            *
2178            * <p>
2179            * 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.
2180            * </p>
2181            *
2182            * @param groupId the group ID
2183            * @param folderId the folder ID
2184            * @param status the status
2185            * @param start the lower bound of the range of bookmarks entries
2186            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2187            * @return the range of matching bookmarks entries that the user has permission to view
2188            * @throws SystemException if a system exception occurred
2189            */
2190            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2191                    long groupId, long folderId, int status, int start, int end)
2192                    throws com.liferay.portal.kernel.exception.SystemException {
2193                    return getPersistence()
2194                                       .filterFindByG_F_S(groupId, folderId, status, start, end);
2195            }
2196    
2197            /**
2198            * 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;.
2199            *
2200            * <p>
2201            * 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.
2202            * </p>
2203            *
2204            * @param groupId the group ID
2205            * @param folderId the folder ID
2206            * @param status the status
2207            * @param start the lower bound of the range of bookmarks entries
2208            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2210            * @return the ordered range of matching bookmarks entries that the user has permission to view
2211            * @throws SystemException if a system exception occurred
2212            */
2213            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2214                    long groupId, long folderId, int status, int start, int end,
2215                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2216                    throws com.liferay.portal.kernel.exception.SystemException {
2217                    return getPersistence()
2218                                       .filterFindByG_F_S(groupId, folderId, status, start, end,
2219                            orderByComparator);
2220            }
2221    
2222            /**
2223            * 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;.
2224            *
2225            * @param entryId the primary key of the current bookmarks entry
2226            * @param groupId the group ID
2227            * @param folderId the folder ID
2228            * @param status the status
2229            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2230            * @return the previous, current, and next bookmarks entry
2231            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2232            * @throws SystemException if a system exception occurred
2233            */
2234            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext(
2235                    long entryId, long groupId, long folderId, int status,
2236                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2237                    throws com.liferay.portal.kernel.exception.SystemException,
2238                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2239                    return getPersistence()
2240                                       .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId,
2241                            status, orderByComparator);
2242            }
2243    
2244            /**
2245            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2246            *
2247            * @param groupId the group ID
2248            * @param folderIds the folder IDs
2249            * @param status the status
2250            * @return the matching bookmarks entries that the user has permission to view
2251            * @throws SystemException if a system exception occurred
2252            */
2253            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2254                    long groupId, long[] folderIds, int status)
2255                    throws com.liferay.portal.kernel.exception.SystemException {
2256                    return getPersistence().filterFindByG_F_S(groupId, folderIds, status);
2257            }
2258    
2259            /**
2260            * 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;.
2261            *
2262            * <p>
2263            * 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.
2264            * </p>
2265            *
2266            * @param groupId the group ID
2267            * @param folderIds the folder IDs
2268            * @param status the status
2269            * @param start the lower bound of the range of bookmarks entries
2270            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2271            * @return the range of matching bookmarks entries that the user has permission to view
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2275                    long groupId, long[] folderIds, int status, int start, int end)
2276                    throws com.liferay.portal.kernel.exception.SystemException {
2277                    return getPersistence()
2278                                       .filterFindByG_F_S(groupId, folderIds, status, start, end);
2279            }
2280    
2281            /**
2282            * 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;.
2283            *
2284            * <p>
2285            * 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.
2286            * </p>
2287            *
2288            * @param groupId the group ID
2289            * @param folderIds the folder IDs
2290            * @param status the status
2291            * @param start the lower bound of the range of bookmarks entries
2292            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2293            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2294            * @return the ordered range of matching bookmarks entries that the user has permission to view
2295            * @throws SystemException if a system exception occurred
2296            */
2297            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2298                    long groupId, long[] folderIds, int status, int start, int end,
2299                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2300                    throws com.liferay.portal.kernel.exception.SystemException {
2301                    return getPersistence()
2302                                       .filterFindByG_F_S(groupId, folderIds, status, start, end,
2303                            orderByComparator);
2304            }
2305    
2306            /**
2307            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2308            *
2309            * <p>
2310            * 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.
2311            * </p>
2312            *
2313            * @param groupId the group ID
2314            * @param folderIds the folder IDs
2315            * @param status the status
2316            * @return the matching bookmarks entries
2317            * @throws SystemException if a system exception occurred
2318            */
2319            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2320                    long groupId, long[] folderIds, int status)
2321                    throws com.liferay.portal.kernel.exception.SystemException {
2322                    return getPersistence().findByG_F_S(groupId, folderIds, status);
2323            }
2324    
2325            /**
2326            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2327            *
2328            * <p>
2329            * 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.
2330            * </p>
2331            *
2332            * @param groupId the group ID
2333            * @param folderIds the folder IDs
2334            * @param status the status
2335            * @param start the lower bound of the range of bookmarks entries
2336            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2337            * @return the range of matching bookmarks entries
2338            * @throws SystemException if a system exception occurred
2339            */
2340            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2341                    long groupId, long[] folderIds, int status, int start, int end)
2342                    throws com.liferay.portal.kernel.exception.SystemException {
2343                    return getPersistence()
2344                                       .findByG_F_S(groupId, folderIds, status, start, end);
2345            }
2346    
2347            /**
2348            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2349            *
2350            * <p>
2351            * 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.
2352            * </p>
2353            *
2354            * @param groupId the group ID
2355            * @param folderIds the folder IDs
2356            * @param status the status
2357            * @param start the lower bound of the range of bookmarks entries
2358            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2359            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2360            * @return the ordered range of matching bookmarks entries
2361            * @throws SystemException if a system exception occurred
2362            */
2363            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2364                    long groupId, long[] folderIds, int status, int start, int end,
2365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2366                    throws com.liferay.portal.kernel.exception.SystemException {
2367                    return getPersistence()
2368                                       .findByG_F_S(groupId, folderIds, status, start, end,
2369                            orderByComparator);
2370            }
2371    
2372            /**
2373            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
2374            *
2375            * @param groupId the group ID
2376            * @param folderId the folder ID
2377            * @param status the status
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static void removeByG_F_S(long groupId, long folderId, int status)
2381                    throws com.liferay.portal.kernel.exception.SystemException {
2382                    getPersistence().removeByG_F_S(groupId, folderId, status);
2383            }
2384    
2385            /**
2386            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2387            *
2388            * @param groupId the group ID
2389            * @param folderId the folder ID
2390            * @param status the status
2391            * @return the number of matching bookmarks entries
2392            * @throws SystemException if a system exception occurred
2393            */
2394            public static int countByG_F_S(long groupId, long folderId, int status)
2395                    throws com.liferay.portal.kernel.exception.SystemException {
2396                    return getPersistence().countByG_F_S(groupId, folderId, status);
2397            }
2398    
2399            /**
2400            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2401            *
2402            * @param groupId the group ID
2403            * @param folderIds the folder IDs
2404            * @param status the status
2405            * @return the number of matching bookmarks entries
2406            * @throws SystemException if a system exception occurred
2407            */
2408            public static int countByG_F_S(long groupId, long[] folderIds, int status)
2409                    throws com.liferay.portal.kernel.exception.SystemException {
2410                    return getPersistence().countByG_F_S(groupId, folderIds, status);
2411            }
2412    
2413            /**
2414            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2415            *
2416            * @param groupId the group ID
2417            * @param folderId the folder ID
2418            * @param status the status
2419            * @return the number of matching bookmarks entries that the user has permission to view
2420            * @throws SystemException if a system exception occurred
2421            */
2422            public static int filterCountByG_F_S(long groupId, long folderId, int status)
2423                    throws com.liferay.portal.kernel.exception.SystemException {
2424                    return getPersistence().filterCountByG_F_S(groupId, folderId, status);
2425            }
2426    
2427            /**
2428            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2429            *
2430            * @param groupId the group ID
2431            * @param folderIds the folder IDs
2432            * @param status the status
2433            * @return the number of matching bookmarks entries that the user has permission to view
2434            * @throws SystemException if a system exception occurred
2435            */
2436            public static int filterCountByG_F_S(long groupId, long[] folderIds,
2437                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2438                    return getPersistence().filterCountByG_F_S(groupId, folderIds, status);
2439            }
2440    
2441            /**
2442            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2443            *
2444            * @param groupId the group ID
2445            * @param folderId the folder ID
2446            * @param status the status
2447            * @return the matching bookmarks entries
2448            * @throws SystemException if a system exception occurred
2449            */
2450            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2451                    long groupId, long folderId, int status)
2452                    throws com.liferay.portal.kernel.exception.SystemException {
2453                    return getPersistence().findByG_F_NotS(groupId, folderId, status);
2454            }
2455    
2456            /**
2457            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2458            *
2459            * <p>
2460            * 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.
2461            * </p>
2462            *
2463            * @param groupId the group ID
2464            * @param folderId the folder ID
2465            * @param status the status
2466            * @param start the lower bound of the range of bookmarks entries
2467            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2468            * @return the range of matching bookmarks entries
2469            * @throws SystemException if a system exception occurred
2470            */
2471            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2472                    long groupId, long folderId, int status, int start, int end)
2473                    throws com.liferay.portal.kernel.exception.SystemException {
2474                    return getPersistence()
2475                                       .findByG_F_NotS(groupId, folderId, status, start, end);
2476            }
2477    
2478            /**
2479            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2480            *
2481            * <p>
2482            * 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.
2483            * </p>
2484            *
2485            * @param groupId the group ID
2486            * @param folderId the folder ID
2487            * @param status the status
2488            * @param start the lower bound of the range of bookmarks entries
2489            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2490            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2491            * @return the ordered range of matching bookmarks entries
2492            * @throws SystemException if a system exception occurred
2493            */
2494            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2495                    long groupId, long folderId, int status, int start, int end,
2496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2497                    throws com.liferay.portal.kernel.exception.SystemException {
2498                    return getPersistence()
2499                                       .findByG_F_NotS(groupId, folderId, status, start, end,
2500                            orderByComparator);
2501            }
2502    
2503            /**
2504            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2505            *
2506            * @param groupId the group ID
2507            * @param folderId the folder ID
2508            * @param status the status
2509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2510            * @return the first matching bookmarks entry
2511            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2512            * @throws SystemException if a system exception occurred
2513            */
2514            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First(
2515                    long groupId, long folderId, int status,
2516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2517                    throws com.liferay.portal.kernel.exception.SystemException,
2518                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2519                    return getPersistence()
2520                                       .findByG_F_NotS_First(groupId, folderId, status,
2521                            orderByComparator);
2522            }
2523    
2524            /**
2525            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2526            *
2527            * @param groupId the group ID
2528            * @param folderId the folder ID
2529            * @param status the status
2530            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2531            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2532            * @throws SystemException if a system exception occurred
2533            */
2534            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First(
2535                    long groupId, long folderId, int status,
2536                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2537                    throws com.liferay.portal.kernel.exception.SystemException {
2538                    return getPersistence()
2539                                       .fetchByG_F_NotS_First(groupId, folderId, status,
2540                            orderByComparator);
2541            }
2542    
2543            /**
2544            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2545            *
2546            * @param groupId the group ID
2547            * @param folderId the folder ID
2548            * @param status the status
2549            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2550            * @return the last matching bookmarks entry
2551            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2552            * @throws SystemException if a system exception occurred
2553            */
2554            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last(
2555                    long groupId, long folderId, int status,
2556                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2557                    throws com.liferay.portal.kernel.exception.SystemException,
2558                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2559                    return getPersistence()
2560                                       .findByG_F_NotS_Last(groupId, folderId, status,
2561                            orderByComparator);
2562            }
2563    
2564            /**
2565            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2566            *
2567            * @param groupId the group ID
2568            * @param folderId the folder ID
2569            * @param status the status
2570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2571            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2572            * @throws SystemException if a system exception occurred
2573            */
2574            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last(
2575                    long groupId, long folderId, int status,
2576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2577                    throws com.liferay.portal.kernel.exception.SystemException {
2578                    return getPersistence()
2579                                       .fetchByG_F_NotS_Last(groupId, folderId, status,
2580                            orderByComparator);
2581            }
2582    
2583            /**
2584            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2585            *
2586            * @param entryId the primary key of the current bookmarks entry
2587            * @param groupId the group ID
2588            * @param folderId the folder ID
2589            * @param status the status
2590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2591            * @return the previous, current, and next bookmarks entry
2592            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2593            * @throws SystemException if a system exception occurred
2594            */
2595            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext(
2596                    long entryId, long groupId, long folderId, int status,
2597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2598                    throws com.liferay.portal.kernel.exception.SystemException,
2599                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2600                    return getPersistence()
2601                                       .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId,
2602                            status, orderByComparator);
2603            }
2604    
2605            /**
2606            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2607            *
2608            * @param groupId the group ID
2609            * @param folderId the folder ID
2610            * @param status the status
2611            * @return the matching bookmarks entries that the user has permission to view
2612            * @throws SystemException if a system exception occurred
2613            */
2614            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2615                    long groupId, long folderId, int status)
2616                    throws com.liferay.portal.kernel.exception.SystemException {
2617                    return getPersistence().filterFindByG_F_NotS(groupId, folderId, status);
2618            }
2619    
2620            /**
2621            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2622            *
2623            * <p>
2624            * 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.
2625            * </p>
2626            *
2627            * @param groupId the group ID
2628            * @param folderId the folder ID
2629            * @param status the status
2630            * @param start the lower bound of the range of bookmarks entries
2631            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2632            * @return the range of matching bookmarks entries that the user has permission to view
2633            * @throws SystemException if a system exception occurred
2634            */
2635            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2636                    long groupId, long folderId, int status, int start, int end)
2637                    throws com.liferay.portal.kernel.exception.SystemException {
2638                    return getPersistence()
2639                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end);
2640            }
2641    
2642            /**
2643            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2644            *
2645            * <p>
2646            * 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.
2647            * </p>
2648            *
2649            * @param groupId the group ID
2650            * @param folderId the folder ID
2651            * @param status the status
2652            * @param start the lower bound of the range of bookmarks entries
2653            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2654            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2655            * @return the ordered range of matching bookmarks entries that the user has permission to view
2656            * @throws SystemException if a system exception occurred
2657            */
2658            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2659                    long groupId, long folderId, int status, int start, int end,
2660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2661                    throws com.liferay.portal.kernel.exception.SystemException {
2662                    return getPersistence()
2663                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end,
2664                            orderByComparator);
2665            }
2666    
2667            /**
2668            * 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 &ne; &#63;.
2669            *
2670            * @param entryId the primary key of the current bookmarks entry
2671            * @param groupId the group ID
2672            * @param folderId the folder ID
2673            * @param status the status
2674            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2675            * @return the previous, current, and next bookmarks entry
2676            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2677            * @throws SystemException if a system exception occurred
2678            */
2679            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext(
2680                    long entryId, long groupId, long folderId, int status,
2681                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2682                    throws com.liferay.portal.kernel.exception.SystemException,
2683                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2684                    return getPersistence()
2685                                       .filterFindByG_F_NotS_PrevAndNext(entryId, groupId,
2686                            folderId, status, orderByComparator);
2687            }
2688    
2689            /**
2690            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2691            *
2692            * @param groupId the group ID
2693            * @param folderIds the folder IDs
2694            * @param status the status
2695            * @return the matching bookmarks entries that the user has permission to view
2696            * @throws SystemException if a system exception occurred
2697            */
2698            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2699                    long groupId, long[] folderIds, int status)
2700                    throws com.liferay.portal.kernel.exception.SystemException {
2701                    return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status);
2702            }
2703    
2704            /**
2705            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2706            *
2707            * <p>
2708            * 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.
2709            * </p>
2710            *
2711            * @param groupId the group ID
2712            * @param folderIds the folder IDs
2713            * @param status the status
2714            * @param start the lower bound of the range of bookmarks entries
2715            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2716            * @return the range of matching bookmarks entries that the user has permission to view
2717            * @throws SystemException if a system exception occurred
2718            */
2719            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2720                    long groupId, long[] folderIds, int status, int start, int end)
2721                    throws com.liferay.portal.kernel.exception.SystemException {
2722                    return getPersistence()
2723                                       .filterFindByG_F_NotS(groupId, folderIds, status, start, end);
2724            }
2725    
2726            /**
2727            * 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 &ne; &#63;.
2728            *
2729            * <p>
2730            * 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.
2731            * </p>
2732            *
2733            * @param groupId the group ID
2734            * @param folderIds the folder IDs
2735            * @param status the status
2736            * @param start the lower bound of the range of bookmarks entries
2737            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2738            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2739            * @return the ordered range of matching bookmarks entries that the user has permission to view
2740            * @throws SystemException if a system exception occurred
2741            */
2742            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2743                    long groupId, long[] folderIds, int status, int start, int end,
2744                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2745                    throws com.liferay.portal.kernel.exception.SystemException {
2746                    return getPersistence()
2747                                       .filterFindByG_F_NotS(groupId, folderIds, status, start,
2748                            end, orderByComparator);
2749            }
2750    
2751            /**
2752            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2753            *
2754            * <p>
2755            * 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.
2756            * </p>
2757            *
2758            * @param groupId the group ID
2759            * @param folderIds the folder IDs
2760            * @param status the status
2761            * @return the matching bookmarks entries
2762            * @throws SystemException if a system exception occurred
2763            */
2764            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2765                    long groupId, long[] folderIds, int status)
2766                    throws com.liferay.portal.kernel.exception.SystemException {
2767                    return getPersistence().findByG_F_NotS(groupId, folderIds, status);
2768            }
2769    
2770            /**
2771            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2772            *
2773            * <p>
2774            * 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.
2775            * </p>
2776            *
2777            * @param groupId the group ID
2778            * @param folderIds the folder IDs
2779            * @param status the status
2780            * @param start the lower bound of the range of bookmarks entries
2781            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2782            * @return the range of matching bookmarks entries
2783            * @throws SystemException if a system exception occurred
2784            */
2785            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2786                    long groupId, long[] folderIds, int status, int start, int end)
2787                    throws com.liferay.portal.kernel.exception.SystemException {
2788                    return getPersistence()
2789                                       .findByG_F_NotS(groupId, folderIds, status, start, end);
2790            }
2791    
2792            /**
2793            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2794            *
2795            * <p>
2796            * 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.
2797            * </p>
2798            *
2799            * @param groupId the group ID
2800            * @param folderIds the folder IDs
2801            * @param status the status
2802            * @param start the lower bound of the range of bookmarks entries
2803            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2804            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2805            * @return the ordered range of matching bookmarks entries
2806            * @throws SystemException if a system exception occurred
2807            */
2808            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2809                    long groupId, long[] folderIds, int status, int start, int end,
2810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2811                    throws com.liferay.portal.kernel.exception.SystemException {
2812                    return getPersistence()
2813                                       .findByG_F_NotS(groupId, folderIds, status, start, end,
2814                            orderByComparator);
2815            }
2816    
2817            /**
2818            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63; from the database.
2819            *
2820            * @param groupId the group ID
2821            * @param folderId the folder ID
2822            * @param status the status
2823            * @throws SystemException if a system exception occurred
2824            */
2825            public static void removeByG_F_NotS(long groupId, long folderId, int status)
2826                    throws com.liferay.portal.kernel.exception.SystemException {
2827                    getPersistence().removeByG_F_NotS(groupId, folderId, status);
2828            }
2829    
2830            /**
2831            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2832            *
2833            * @param groupId the group ID
2834            * @param folderId the folder ID
2835            * @param status the status
2836            * @return the number of matching bookmarks entries
2837            * @throws SystemException if a system exception occurred
2838            */
2839            public static int countByG_F_NotS(long groupId, long folderId, int status)
2840                    throws com.liferay.portal.kernel.exception.SystemException {
2841                    return getPersistence().countByG_F_NotS(groupId, folderId, status);
2842            }
2843    
2844            /**
2845            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2846            *
2847            * @param groupId the group ID
2848            * @param folderIds the folder IDs
2849            * @param status the status
2850            * @return the number of matching bookmarks entries
2851            * @throws SystemException if a system exception occurred
2852            */
2853            public static int countByG_F_NotS(long groupId, long[] folderIds, int status)
2854                    throws com.liferay.portal.kernel.exception.SystemException {
2855                    return getPersistence().countByG_F_NotS(groupId, folderIds, status);
2856            }
2857    
2858            /**
2859            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2860            *
2861            * @param groupId the group ID
2862            * @param folderId the folder ID
2863            * @param status the status
2864            * @return the number of matching bookmarks entries that the user has permission to view
2865            * @throws SystemException if a system exception occurred
2866            */
2867            public static int filterCountByG_F_NotS(long groupId, long folderId,
2868                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2869                    return getPersistence().filterCountByG_F_NotS(groupId, folderId, status);
2870            }
2871    
2872            /**
2873            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2874            *
2875            * @param groupId the group ID
2876            * @param folderIds the folder IDs
2877            * @param status the status
2878            * @return the number of matching bookmarks entries that the user has permission to view
2879            * @throws SystemException if a system exception occurred
2880            */
2881            public static int filterCountByG_F_NotS(long groupId, long[] folderIds,
2882                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2883                    return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status);
2884            }
2885    
2886            /**
2887            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2888            *
2889            * @param groupId the group ID
2890            * @param userId the user ID
2891            * @param folderId the folder ID
2892            * @param status the status
2893            * @return the matching bookmarks entries
2894            * @throws SystemException if a system exception occurred
2895            */
2896            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2897                    long groupId, long userId, long folderId, int status)
2898                    throws com.liferay.portal.kernel.exception.SystemException {
2899                    return getPersistence().findByG_U_F_S(groupId, userId, folderId, status);
2900            }
2901    
2902            /**
2903            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2904            *
2905            * <p>
2906            * 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.
2907            * </p>
2908            *
2909            * @param groupId the group ID
2910            * @param userId the user ID
2911            * @param folderId the folder ID
2912            * @param status the status
2913            * @param start the lower bound of the range of bookmarks entries
2914            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2915            * @return the range of matching bookmarks entries
2916            * @throws SystemException if a system exception occurred
2917            */
2918            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2919                    long groupId, long userId, long folderId, int status, int start, int end)
2920                    throws com.liferay.portal.kernel.exception.SystemException {
2921                    return getPersistence()
2922                                       .findByG_U_F_S(groupId, userId, folderId, status, start, end);
2923            }
2924    
2925            /**
2926            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2927            *
2928            * <p>
2929            * 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.
2930            * </p>
2931            *
2932            * @param groupId the group ID
2933            * @param userId the user ID
2934            * @param folderId the folder ID
2935            * @param status the status
2936            * @param start the lower bound of the range of bookmarks entries
2937            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2938            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2939            * @return the ordered range of matching bookmarks entries
2940            * @throws SystemException if a system exception occurred
2941            */
2942            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2943                    long groupId, long userId, long folderId, int status, int start,
2944                    int end,
2945                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2946                    throws com.liferay.portal.kernel.exception.SystemException {
2947                    return getPersistence()
2948                                       .findByG_U_F_S(groupId, userId, folderId, status, start,
2949                            end, orderByComparator);
2950            }
2951    
2952            /**
2953            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2954            *
2955            * @param groupId the group ID
2956            * @param userId the user ID
2957            * @param folderId the folder ID
2958            * @param status the status
2959            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2960            * @return the first matching bookmarks entry
2961            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2962            * @throws SystemException if a system exception occurred
2963            */
2964            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First(
2965                    long groupId, long userId, long folderId, int status,
2966                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2967                    throws com.liferay.portal.kernel.exception.SystemException,
2968                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2969                    return getPersistence()
2970                                       .findByG_U_F_S_First(groupId, userId, folderId, status,
2971                            orderByComparator);
2972            }
2973    
2974            /**
2975            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2976            *
2977            * @param groupId the group ID
2978            * @param userId the user ID
2979            * @param folderId the folder ID
2980            * @param status the status
2981            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2982            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2983            * @throws SystemException if a system exception occurred
2984            */
2985            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First(
2986                    long groupId, long userId, long folderId, int status,
2987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2988                    throws com.liferay.portal.kernel.exception.SystemException {
2989                    return getPersistence()
2990                                       .fetchByG_U_F_S_First(groupId, userId, folderId, status,
2991                            orderByComparator);
2992            }
2993    
2994            /**
2995            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2996            *
2997            * @param groupId the group ID
2998            * @param userId the user ID
2999            * @param folderId the folder ID
3000            * @param status the status
3001            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3002            * @return the last matching bookmarks entry
3003            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3004            * @throws SystemException if a system exception occurred
3005            */
3006            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last(
3007                    long groupId, long userId, long folderId, int status,
3008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3009                    throws com.liferay.portal.kernel.exception.SystemException,
3010                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3011                    return getPersistence()
3012                                       .findByG_U_F_S_Last(groupId, userId, folderId, status,
3013                            orderByComparator);
3014            }
3015    
3016            /**
3017            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3018            *
3019            * @param groupId the group ID
3020            * @param userId the user ID
3021            * @param folderId the folder ID
3022            * @param status the status
3023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3024            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3025            * @throws SystemException if a system exception occurred
3026            */
3027            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last(
3028                    long groupId, long userId, long folderId, int status,
3029                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3030                    throws com.liferay.portal.kernel.exception.SystemException {
3031                    return getPersistence()
3032                                       .fetchByG_U_F_S_Last(groupId, userId, folderId, status,
3033                            orderByComparator);
3034            }
3035    
3036            /**
3037            * 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;.
3038            *
3039            * @param entryId the primary key of the current bookmarks entry
3040            * @param groupId the group ID
3041            * @param userId the user ID
3042            * @param folderId the folder ID
3043            * @param status the status
3044            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3045            * @return the previous, current, and next bookmarks entry
3046            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3047            * @throws SystemException if a system exception occurred
3048            */
3049            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext(
3050                    long entryId, long groupId, long userId, long folderId, int status,
3051                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3052                    throws com.liferay.portal.kernel.exception.SystemException,
3053                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3054                    return getPersistence()
3055                                       .findByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3056                            folderId, status, orderByComparator);
3057            }
3058    
3059            /**
3060            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3061            *
3062            * @param groupId the group ID
3063            * @param userId the user ID
3064            * @param folderId the folder ID
3065            * @param status the status
3066            * @return the matching bookmarks entries that the user has permission to view
3067            * @throws SystemException if a system exception occurred
3068            */
3069            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3070                    long groupId, long userId, long folderId, int status)
3071                    throws com.liferay.portal.kernel.exception.SystemException {
3072                    return getPersistence()
3073                                       .filterFindByG_U_F_S(groupId, userId, folderId, status);
3074            }
3075    
3076            /**
3077            * 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;.
3078            *
3079            * <p>
3080            * 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.
3081            * </p>
3082            *
3083            * @param groupId the group ID
3084            * @param userId the user ID
3085            * @param folderId the folder ID
3086            * @param status the status
3087            * @param start the lower bound of the range of bookmarks entries
3088            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3089            * @return the range of matching bookmarks entries that the user has permission to view
3090            * @throws SystemException if a system exception occurred
3091            */
3092            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3093                    long groupId, long userId, long folderId, int status, int start, int end)
3094                    throws com.liferay.portal.kernel.exception.SystemException {
3095                    return getPersistence()
3096                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3097                            start, end);
3098            }
3099    
3100            /**
3101            * 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;.
3102            *
3103            * <p>
3104            * 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.
3105            * </p>
3106            *
3107            * @param groupId the group ID
3108            * @param userId the user ID
3109            * @param folderId the folder ID
3110            * @param status the status
3111            * @param start the lower bound of the range of bookmarks entries
3112            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3113            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3114            * @return the ordered range of matching bookmarks entries that the user has permission to view
3115            * @throws SystemException if a system exception occurred
3116            */
3117            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3118                    long groupId, long userId, long folderId, int status, int start,
3119                    int end,
3120                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3121                    throws com.liferay.portal.kernel.exception.SystemException {
3122                    return getPersistence()
3123                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3124                            start, end, orderByComparator);
3125            }
3126    
3127            /**
3128            * 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;.
3129            *
3130            * @param entryId the primary key of the current bookmarks entry
3131            * @param groupId the group ID
3132            * @param userId the user ID
3133            * @param folderId the folder ID
3134            * @param status the status
3135            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3136            * @return the previous, current, and next bookmarks entry
3137            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3138            * @throws SystemException if a system exception occurred
3139            */
3140            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext(
3141                    long entryId, long groupId, long userId, long folderId, int status,
3142                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3143                    throws com.liferay.portal.kernel.exception.SystemException,
3144                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3145                    return getPersistence()
3146                                       .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3147                            folderId, status, orderByComparator);
3148            }
3149    
3150            /**
3151            * 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;.
3152            *
3153            * @param groupId the group ID
3154            * @param userId the user ID
3155            * @param folderIds the folder IDs
3156            * @param status the status
3157            * @return the matching bookmarks entries that the user has permission to view
3158            * @throws SystemException if a system exception occurred
3159            */
3160            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3161                    long groupId, long userId, long[] folderIds, int status)
3162                    throws com.liferay.portal.kernel.exception.SystemException {
3163                    return getPersistence()
3164                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status);
3165            }
3166    
3167            /**
3168            * 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;.
3169            *
3170            * <p>
3171            * 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.
3172            * </p>
3173            *
3174            * @param groupId the group ID
3175            * @param userId the user ID
3176            * @param folderIds the folder IDs
3177            * @param status the status
3178            * @param start the lower bound of the range of bookmarks entries
3179            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3180            * @return the range of matching bookmarks entries that the user has permission to view
3181            * @throws SystemException if a system exception occurred
3182            */
3183            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3184                    long groupId, long userId, long[] folderIds, int status, int start,
3185                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3186                    return getPersistence()
3187                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3188                            start, end);
3189            }
3190    
3191            /**
3192            * 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;.
3193            *
3194            * <p>
3195            * 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.
3196            * </p>
3197            *
3198            * @param groupId the group ID
3199            * @param userId the user ID
3200            * @param folderIds the folder IDs
3201            * @param status the status
3202            * @param start the lower bound of the range of bookmarks entries
3203            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3204            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3205            * @return the ordered range of matching bookmarks entries that the user has permission to view
3206            * @throws SystemException if a system exception occurred
3207            */
3208            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3209                    long groupId, long userId, long[] folderIds, int status, int start,
3210                    int end,
3211                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3212                    throws com.liferay.portal.kernel.exception.SystemException {
3213                    return getPersistence()
3214                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3215                            start, end, orderByComparator);
3216            }
3217    
3218            /**
3219            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3220            *
3221            * <p>
3222            * 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.
3223            * </p>
3224            *
3225            * @param groupId the group ID
3226            * @param userId the user ID
3227            * @param folderIds the folder IDs
3228            * @param status the status
3229            * @return the matching bookmarks entries
3230            * @throws SystemException if a system exception occurred
3231            */
3232            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3233                    long groupId, long userId, long[] folderIds, int status)
3234                    throws com.liferay.portal.kernel.exception.SystemException {
3235                    return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status);
3236            }
3237    
3238            /**
3239            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3240            *
3241            * <p>
3242            * 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.
3243            * </p>
3244            *
3245            * @param groupId the group ID
3246            * @param userId the user ID
3247            * @param folderIds the folder IDs
3248            * @param status the status
3249            * @param start the lower bound of the range of bookmarks entries
3250            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3251            * @return the range of matching bookmarks entries
3252            * @throws SystemException if a system exception occurred
3253            */
3254            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3255                    long groupId, long userId, long[] folderIds, int status, int start,
3256                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3257                    return getPersistence()
3258                                       .findByG_U_F_S(groupId, userId, folderIds, status, start, end);
3259            }
3260    
3261            /**
3262            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3263            *
3264            * <p>
3265            * 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.
3266            * </p>
3267            *
3268            * @param groupId the group ID
3269            * @param userId the user ID
3270            * @param folderIds the folder IDs
3271            * @param status the status
3272            * @param start the lower bound of the range of bookmarks entries
3273            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3274            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3275            * @return the ordered range of matching bookmarks entries
3276            * @throws SystemException if a system exception occurred
3277            */
3278            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3279                    long groupId, long userId, long[] folderIds, int status, int start,
3280                    int end,
3281                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3282                    throws com.liferay.portal.kernel.exception.SystemException {
3283                    return getPersistence()
3284                                       .findByG_U_F_S(groupId, userId, folderIds, status, start,
3285                            end, orderByComparator);
3286            }
3287    
3288            /**
3289            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63; from the database.
3290            *
3291            * @param groupId the group ID
3292            * @param userId the user ID
3293            * @param folderId the folder ID
3294            * @param status the status
3295            * @throws SystemException if a system exception occurred
3296            */
3297            public static void removeByG_U_F_S(long groupId, long userId,
3298                    long folderId, int status)
3299                    throws com.liferay.portal.kernel.exception.SystemException {
3300                    getPersistence().removeByG_U_F_S(groupId, userId, folderId, status);
3301            }
3302    
3303            /**
3304            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3305            *
3306            * @param groupId the group ID
3307            * @param userId the user ID
3308            * @param folderId the folder ID
3309            * @param status the status
3310            * @return the number of matching bookmarks entries
3311            * @throws SystemException if a system exception occurred
3312            */
3313            public static int countByG_U_F_S(long groupId, long userId, long folderId,
3314                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3315                    return getPersistence().countByG_U_F_S(groupId, userId, folderId, status);
3316            }
3317    
3318            /**
3319            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3320            *
3321            * @param groupId the group ID
3322            * @param userId the user ID
3323            * @param folderIds the folder IDs
3324            * @param status the status
3325            * @return the number of matching bookmarks entries
3326            * @throws SystemException if a system exception occurred
3327            */
3328            public static int countByG_U_F_S(long groupId, long userId,
3329                    long[] folderIds, int status)
3330                    throws com.liferay.portal.kernel.exception.SystemException {
3331                    return getPersistence()
3332                                       .countByG_U_F_S(groupId, userId, folderIds, status);
3333            }
3334    
3335            /**
3336            * 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;.
3337            *
3338            * @param groupId the group ID
3339            * @param userId the user ID
3340            * @param folderId the folder ID
3341            * @param status the status
3342            * @return the number of matching bookmarks entries that the user has permission to view
3343            * @throws SystemException if a system exception occurred
3344            */
3345            public static int filterCountByG_U_F_S(long groupId, long userId,
3346                    long folderId, int status)
3347                    throws com.liferay.portal.kernel.exception.SystemException {
3348                    return getPersistence()
3349                                       .filterCountByG_U_F_S(groupId, userId, folderId, status);
3350            }
3351    
3352            /**
3353            * 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;.
3354            *
3355            * @param groupId the group ID
3356            * @param userId the user ID
3357            * @param folderIds the folder IDs
3358            * @param status the status
3359            * @return the number of matching bookmarks entries that the user has permission to view
3360            * @throws SystemException if a system exception occurred
3361            */
3362            public static int filterCountByG_U_F_S(long groupId, long userId,
3363                    long[] folderIds, int status)
3364                    throws com.liferay.portal.kernel.exception.SystemException {
3365                    return getPersistence()
3366                                       .filterCountByG_U_F_S(groupId, userId, folderIds, status);
3367            }
3368    
3369            /**
3370            * Caches the bookmarks entry in the entity cache if it is enabled.
3371            *
3372            * @param bookmarksEntry the bookmarks entry
3373            */
3374            public static void cacheResult(
3375                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
3376                    getPersistence().cacheResult(bookmarksEntry);
3377            }
3378    
3379            /**
3380            * Caches the bookmarks entries in the entity cache if it is enabled.
3381            *
3382            * @param bookmarksEntries the bookmarks entries
3383            */
3384            public static void cacheResult(
3385                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
3386                    getPersistence().cacheResult(bookmarksEntries);
3387            }
3388    
3389            /**
3390            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
3391            *
3392            * @param entryId the primary key for the new bookmarks entry
3393            * @return the new bookmarks entry
3394            */
3395            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
3396                    long entryId) {
3397                    return getPersistence().create(entryId);
3398            }
3399    
3400            /**
3401            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
3402            *
3403            * @param entryId the primary key of the bookmarks entry
3404            * @return the bookmarks entry that was removed
3405            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3406            * @throws SystemException if a system exception occurred
3407            */
3408            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
3409                    long entryId)
3410                    throws com.liferay.portal.kernel.exception.SystemException,
3411                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3412                    return getPersistence().remove(entryId);
3413            }
3414    
3415            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
3416                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry)
3417                    throws com.liferay.portal.kernel.exception.SystemException {
3418                    return getPersistence().updateImpl(bookmarksEntry);
3419            }
3420    
3421            /**
3422            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
3423            *
3424            * @param entryId the primary key of the bookmarks entry
3425            * @return the bookmarks entry
3426            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3427            * @throws SystemException if a system exception occurred
3428            */
3429            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
3430                    long entryId)
3431                    throws com.liferay.portal.kernel.exception.SystemException,
3432                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3433                    return getPersistence().findByPrimaryKey(entryId);
3434            }
3435    
3436            /**
3437            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
3438            *
3439            * @param entryId the primary key of the bookmarks entry
3440            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
3441            * @throws SystemException if a system exception occurred
3442            */
3443            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
3444                    long entryId)
3445                    throws com.liferay.portal.kernel.exception.SystemException {
3446                    return getPersistence().fetchByPrimaryKey(entryId);
3447            }
3448    
3449            /**
3450            * Returns all the bookmarks entries.
3451            *
3452            * @return the bookmarks entries
3453            * @throws SystemException if a system exception occurred
3454            */
3455            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
3456                    throws com.liferay.portal.kernel.exception.SystemException {
3457                    return getPersistence().findAll();
3458            }
3459    
3460            /**
3461            * Returns a range of all the bookmarks entries.
3462            *
3463            * <p>
3464            * 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.
3465            * </p>
3466            *
3467            * @param start the lower bound of the range of bookmarks entries
3468            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3469            * @return the range of bookmarks entries
3470            * @throws SystemException if a system exception occurred
3471            */
3472            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3473                    int start, int end)
3474                    throws com.liferay.portal.kernel.exception.SystemException {
3475                    return getPersistence().findAll(start, end);
3476            }
3477    
3478            /**
3479            * Returns an ordered range of all the bookmarks entries.
3480            *
3481            * <p>
3482            * 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.
3483            * </p>
3484            *
3485            * @param start the lower bound of the range of bookmarks entries
3486            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3487            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3488            * @return the ordered range of bookmarks entries
3489            * @throws SystemException if a system exception occurred
3490            */
3491            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3492                    int start, int end,
3493                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3494                    throws com.liferay.portal.kernel.exception.SystemException {
3495                    return getPersistence().findAll(start, end, orderByComparator);
3496            }
3497    
3498            /**
3499            * Removes all the bookmarks entries from the database.
3500            *
3501            * @throws SystemException if a system exception occurred
3502            */
3503            public static void removeAll()
3504                    throws com.liferay.portal.kernel.exception.SystemException {
3505                    getPersistence().removeAll();
3506            }
3507    
3508            /**
3509            * Returns the number of bookmarks entries.
3510            *
3511            * @return the number of bookmarks entries
3512            * @throws SystemException if a system exception occurred
3513            */
3514            public static int countAll()
3515                    throws com.liferay.portal.kernel.exception.SystemException {
3516                    return getPersistence().countAll();
3517            }
3518    
3519            public static BookmarksEntryPersistence getPersistence() {
3520                    if (_persistence == null) {
3521                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
3522    
3523                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
3524                                    "_persistence");
3525                    }
3526    
3527                    return _persistence;
3528            }
3529    
3530            /**
3531             * @deprecated As of 6.2.0
3532             */
3533            public void setPersistence(BookmarksEntryPersistence persistence) {
3534            }
3535    
3536            private static BookmarksEntryPersistence _persistence;
3537    }