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 groupId = &#63; and status &ne; &#63;.
1537            *
1538            * @param groupId the group 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> findByG_NotS(
1544                    long groupId, int status)
1545                    throws com.liferay.portal.kernel.exception.SystemException {
1546                    return getPersistence().findByG_NotS(groupId, status);
1547            }
1548    
1549            /**
1550            * Returns a range of all the bookmarks entries where groupId = &#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 groupId the group 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> findByG_NotS(
1564                    long groupId, int status, int start, int end)
1565                    throws com.liferay.portal.kernel.exception.SystemException {
1566                    return getPersistence().findByG_NotS(groupId, status, start, end);
1567            }
1568    
1569            /**
1570            * Returns an ordered range of all the bookmarks entries where groupId = &#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 groupId the group 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> findByG_NotS(
1585                    long groupId, 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                                       .findByG_NotS(groupId, status, start, end, orderByComparator);
1590            }
1591    
1592            /**
1593            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1594            *
1595            * @param groupId the group ID
1596            * @param status the status
1597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1598            * @return the first matching bookmarks entry
1599            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1600            * @throws SystemException if a system exception occurred
1601            */
1602            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_First(
1603                    long groupId, int status,
1604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1605                    throws com.liferay.portal.kernel.exception.SystemException,
1606                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1607                    return getPersistence()
1608                                       .findByG_NotS_First(groupId, status, orderByComparator);
1609            }
1610    
1611            /**
1612            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1613            *
1614            * @param groupId the group ID
1615            * @param status the status
1616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1617            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1618            * @throws SystemException if a system exception occurred
1619            */
1620            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_First(
1621                    long groupId, int status,
1622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1623                    throws com.liferay.portal.kernel.exception.SystemException {
1624                    return getPersistence()
1625                                       .fetchByG_NotS_First(groupId, status, orderByComparator);
1626            }
1627    
1628            /**
1629            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1630            *
1631            * @param groupId the group ID
1632            * @param status the status
1633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1634            * @return the last matching bookmarks entry
1635            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_Last(
1639                    long groupId, int status,
1640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1641                    throws com.liferay.portal.kernel.exception.SystemException,
1642                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1643                    return getPersistence()
1644                                       .findByG_NotS_Last(groupId, status, orderByComparator);
1645            }
1646    
1647            /**
1648            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1649            *
1650            * @param groupId the group ID
1651            * @param status the status
1652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1653            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1654            * @throws SystemException if a system exception occurred
1655            */
1656            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_Last(
1657                    long groupId, int status,
1658                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1659                    throws com.liferay.portal.kernel.exception.SystemException {
1660                    return getPersistence()
1661                                       .fetchByG_NotS_Last(groupId, status, orderByComparator);
1662            }
1663    
1664            /**
1665            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1666            *
1667            * @param entryId the primary key of the current bookmarks entry
1668            * @param groupId the group ID
1669            * @param status the status
1670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1671            * @return the previous, current, and next bookmarks entry
1672            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1673            * @throws SystemException if a system exception occurred
1674            */
1675            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_NotS_PrevAndNext(
1676                    long entryId, long groupId, int status,
1677                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1678                    throws com.liferay.portal.kernel.exception.SystemException,
1679                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1680                    return getPersistence()
1681                                       .findByG_NotS_PrevAndNext(entryId, groupId, status,
1682                            orderByComparator);
1683            }
1684    
1685            /**
1686            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1687            *
1688            * @param groupId the group ID
1689            * @param status the status
1690            * @return the matching bookmarks entries that the user has permission to view
1691            * @throws SystemException if a system exception occurred
1692            */
1693            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1694                    long groupId, int status)
1695                    throws com.liferay.portal.kernel.exception.SystemException {
1696                    return getPersistence().filterFindByG_NotS(groupId, status);
1697            }
1698    
1699            /**
1700            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1701            *
1702            * <p>
1703            * 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.
1704            * </p>
1705            *
1706            * @param groupId the group ID
1707            * @param status the status
1708            * @param start the lower bound of the range of bookmarks entries
1709            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1710            * @return the range of matching bookmarks entries that the user has permission to view
1711            * @throws SystemException if a system exception occurred
1712            */
1713            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1714                    long groupId, int status, int start, int end)
1715                    throws com.liferay.portal.kernel.exception.SystemException {
1716                    return getPersistence().filterFindByG_NotS(groupId, status, start, end);
1717            }
1718    
1719            /**
1720            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status &ne; &#63;.
1721            *
1722            * <p>
1723            * 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.
1724            * </p>
1725            *
1726            * @param groupId the group ID
1727            * @param status the status
1728            * @param start the lower bound of the range of bookmarks entries
1729            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1730            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1731            * @return the ordered range of matching bookmarks entries that the user has permission to view
1732            * @throws SystemException if a system exception occurred
1733            */
1734            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1735                    long groupId, int status, int start, int end,
1736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1737                    throws com.liferay.portal.kernel.exception.SystemException {
1738                    return getPersistence()
1739                                       .filterFindByG_NotS(groupId, status, start, end,
1740                            orderByComparator);
1741            }
1742    
1743            /**
1744            * 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 &ne; &#63;.
1745            *
1746            * @param entryId the primary key of the current bookmarks entry
1747            * @param groupId the group ID
1748            * @param status the status
1749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1750            * @return the previous, current, and next bookmarks entry
1751            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1752            * @throws SystemException if a system exception occurred
1753            */
1754            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_NotS_PrevAndNext(
1755                    long entryId, long groupId, int status,
1756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1757                    throws com.liferay.portal.kernel.exception.SystemException,
1758                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1759                    return getPersistence()
1760                                       .filterFindByG_NotS_PrevAndNext(entryId, groupId, status,
1761                            orderByComparator);
1762            }
1763    
1764            /**
1765            * Removes all the bookmarks entries where groupId = &#63; and status &ne; &#63; from the database.
1766            *
1767            * @param groupId the group ID
1768            * @param status the status
1769            * @throws SystemException if a system exception occurred
1770            */
1771            public static void removeByG_NotS(long groupId, int status)
1772                    throws com.liferay.portal.kernel.exception.SystemException {
1773                    getPersistence().removeByG_NotS(groupId, status);
1774            }
1775    
1776            /**
1777            * Returns the number of bookmarks entries where groupId = &#63; and status &ne; &#63;.
1778            *
1779            * @param groupId the group ID
1780            * @param status the status
1781            * @return the number of matching bookmarks entries
1782            * @throws SystemException if a system exception occurred
1783            */
1784            public static int countByG_NotS(long groupId, int status)
1785                    throws com.liferay.portal.kernel.exception.SystemException {
1786                    return getPersistence().countByG_NotS(groupId, status);
1787            }
1788    
1789            /**
1790            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1791            *
1792            * @param groupId the group ID
1793            * @param status the status
1794            * @return the number of matching bookmarks entries that the user has permission to view
1795            * @throws SystemException if a system exception occurred
1796            */
1797            public static int filterCountByG_NotS(long groupId, int status)
1798                    throws com.liferay.portal.kernel.exception.SystemException {
1799                    return getPersistence().filterCountByG_NotS(groupId, status);
1800            }
1801    
1802            /**
1803            * Returns all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1804            *
1805            * @param companyId the company ID
1806            * @param status the status
1807            * @return the matching bookmarks entries
1808            * @throws SystemException if a system exception occurred
1809            */
1810            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1811                    long companyId, int status)
1812                    throws com.liferay.portal.kernel.exception.SystemException {
1813                    return getPersistence().findByC_NotS(companyId, status);
1814            }
1815    
1816            /**
1817            * Returns a range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1818            *
1819            * <p>
1820            * 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.
1821            * </p>
1822            *
1823            * @param companyId the company ID
1824            * @param status the status
1825            * @param start the lower bound of the range of bookmarks entries
1826            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1827            * @return the range of matching bookmarks entries
1828            * @throws SystemException if a system exception occurred
1829            */
1830            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1831                    long companyId, int status, int start, int end)
1832                    throws com.liferay.portal.kernel.exception.SystemException {
1833                    return getPersistence().findByC_NotS(companyId, status, start, end);
1834            }
1835    
1836            /**
1837            * Returns an ordered range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1838            *
1839            * <p>
1840            * 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.
1841            * </p>
1842            *
1843            * @param companyId the company ID
1844            * @param status the status
1845            * @param start the lower bound of the range of bookmarks entries
1846            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1847            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1848            * @return the ordered range of matching bookmarks entries
1849            * @throws SystemException if a system exception occurred
1850            */
1851            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1852                    long companyId, int status, int start, int end,
1853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1854                    throws com.liferay.portal.kernel.exception.SystemException {
1855                    return getPersistence()
1856                                       .findByC_NotS(companyId, status, start, end,
1857                            orderByComparator);
1858            }
1859    
1860            /**
1861            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1862            *
1863            * @param companyId the company ID
1864            * @param status the status
1865            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1866            * @return the first matching bookmarks entry
1867            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1868            * @throws SystemException if a system exception occurred
1869            */
1870            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First(
1871                    long companyId, int status,
1872                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1873                    throws com.liferay.portal.kernel.exception.SystemException,
1874                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1875                    return getPersistence()
1876                                       .findByC_NotS_First(companyId, status, orderByComparator);
1877            }
1878    
1879            /**
1880            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1881            *
1882            * @param companyId the company ID
1883            * @param status the status
1884            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1885            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1886            * @throws SystemException if a system exception occurred
1887            */
1888            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First(
1889                    long companyId, int status,
1890                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1891                    throws com.liferay.portal.kernel.exception.SystemException {
1892                    return getPersistence()
1893                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1894            }
1895    
1896            /**
1897            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1898            *
1899            * @param companyId the company ID
1900            * @param status the status
1901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1902            * @return the last matching bookmarks entry
1903            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1904            * @throws SystemException if a system exception occurred
1905            */
1906            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last(
1907                    long companyId, int status,
1908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1909                    throws com.liferay.portal.kernel.exception.SystemException,
1910                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1911                    return getPersistence()
1912                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1913            }
1914    
1915            /**
1916            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1917            *
1918            * @param companyId the company ID
1919            * @param status the status
1920            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1921            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1922            * @throws SystemException if a system exception occurred
1923            */
1924            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last(
1925                    long companyId, int status,
1926                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1927                    throws com.liferay.portal.kernel.exception.SystemException {
1928                    return getPersistence()
1929                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1930            }
1931    
1932            /**
1933            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1934            *
1935            * @param entryId the primary key of the current bookmarks entry
1936            * @param companyId the company ID
1937            * @param status the status
1938            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1939            * @return the previous, current, and next bookmarks entry
1940            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1941            * @throws SystemException if a system exception occurred
1942            */
1943            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext(
1944                    long entryId, long companyId, int status,
1945                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1946                    throws com.liferay.portal.kernel.exception.SystemException,
1947                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1948                    return getPersistence()
1949                                       .findByC_NotS_PrevAndNext(entryId, companyId, status,
1950                            orderByComparator);
1951            }
1952    
1953            /**
1954            * Removes all the bookmarks entries where companyId = &#63; and status &ne; &#63; from the database.
1955            *
1956            * @param companyId the company ID
1957            * @param status the status
1958            * @throws SystemException if a system exception occurred
1959            */
1960            public static void removeByC_NotS(long companyId, int status)
1961                    throws com.liferay.portal.kernel.exception.SystemException {
1962                    getPersistence().removeByC_NotS(companyId, status);
1963            }
1964    
1965            /**
1966            * Returns the number of bookmarks entries where companyId = &#63; and status &ne; &#63;.
1967            *
1968            * @param companyId the company ID
1969            * @param status the status
1970            * @return the number of matching bookmarks entries
1971            * @throws SystemException if a system exception occurred
1972            */
1973            public static int countByC_NotS(long companyId, int status)
1974                    throws com.liferay.portal.kernel.exception.SystemException {
1975                    return getPersistence().countByC_NotS(companyId, status);
1976            }
1977    
1978            /**
1979            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1980            *
1981            * @param groupId the group ID
1982            * @param userId the user ID
1983            * @param status the status
1984            * @return the matching bookmarks entries
1985            * @throws SystemException if a system exception occurred
1986            */
1987            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1988                    long groupId, long userId, int status)
1989                    throws com.liferay.portal.kernel.exception.SystemException {
1990                    return getPersistence().findByG_U_S(groupId, userId, status);
1991            }
1992    
1993            /**
1994            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1995            *
1996            * <p>
1997            * 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.
1998            * </p>
1999            *
2000            * @param groupId the group ID
2001            * @param userId the user ID
2002            * @param status the status
2003            * @param start the lower bound of the range of bookmarks entries
2004            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2005            * @return the range of matching bookmarks entries
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
2009                    long groupId, long userId, int status, int start, int end)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
2012            }
2013    
2014            /**
2015            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
2016            *
2017            * <p>
2018            * 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.
2019            * </p>
2020            *
2021            * @param groupId the group ID
2022            * @param userId the user ID
2023            * @param status the status
2024            * @param start the lower bound of the range of bookmarks entries
2025            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2026            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2027            * @return the ordered range of matching bookmarks entries
2028            * @throws SystemException if a system exception occurred
2029            */
2030            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
2031                    long groupId, long userId, int status, int start, int end,
2032                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2033                    throws com.liferay.portal.kernel.exception.SystemException {
2034                    return getPersistence()
2035                                       .findByG_U_S(groupId, userId, status, start, end,
2036                            orderByComparator);
2037            }
2038    
2039            /**
2040            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2041            *
2042            * @param groupId the group ID
2043            * @param userId the user ID
2044            * @param status the status
2045            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2046            * @return the first matching bookmarks entry
2047            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2048            * @throws SystemException if a system exception occurred
2049            */
2050            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First(
2051                    long groupId, long userId, int status,
2052                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2053                    throws com.liferay.portal.kernel.exception.SystemException,
2054                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2055                    return getPersistence()
2056                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
2057            }
2058    
2059            /**
2060            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2061            *
2062            * @param groupId the group ID
2063            * @param userId the user ID
2064            * @param status the status
2065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2066            * @return the first matching bookmarks entry, or <code>null</code> 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 fetchByG_U_S_First(
2070                    long groupId, long userId, int status,
2071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2072                    throws com.liferay.portal.kernel.exception.SystemException {
2073                    return getPersistence()
2074                                       .fetchByG_U_S_First(groupId, userId, status,
2075                            orderByComparator);
2076            }
2077    
2078            /**
2079            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2080            *
2081            * @param groupId the group ID
2082            * @param userId the user ID
2083            * @param status the status
2084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2085            * @return the last matching bookmarks entry
2086            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException 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 findByG_U_S_Last(
2090                    long groupId, long userId, int status,
2091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2092                    throws com.liferay.portal.kernel.exception.SystemException,
2093                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2094                    return getPersistence()
2095                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
2096            }
2097    
2098            /**
2099            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2100            *
2101            * @param groupId the group ID
2102            * @param userId the user 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, or <code>null</code> if a matching bookmarks entry could not be found
2106            * @throws SystemException if a system exception occurred
2107            */
2108            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last(
2109                    long groupId, long userId, int status,
2110                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2111                    throws com.liferay.portal.kernel.exception.SystemException {
2112                    return getPersistence()
2113                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
2114            }
2115    
2116            /**
2117            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2118            *
2119            * @param entryId the primary key of the current bookmarks entry
2120            * @param groupId the group ID
2121            * @param userId the user ID
2122            * @param status the status
2123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2124            * @return the previous, current, and next bookmarks entry
2125            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2126            * @throws SystemException if a system exception occurred
2127            */
2128            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext(
2129                    long entryId, long groupId, long userId, int status,
2130                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2131                    throws com.liferay.portal.kernel.exception.SystemException,
2132                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2133                    return getPersistence()
2134                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
2135                            orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2140            *
2141            * @param groupId the group ID
2142            * @param userId the user ID
2143            * @param status the status
2144            * @return the matching bookmarks entries that the user has permission to view
2145            * @throws SystemException if a system exception occurred
2146            */
2147            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
2148                    long groupId, long userId, int status)
2149                    throws com.liferay.portal.kernel.exception.SystemException {
2150                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
2151            }
2152    
2153            /**
2154            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2155            *
2156            * <p>
2157            * 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.
2158            * </p>
2159            *
2160            * @param groupId the group ID
2161            * @param userId the user ID
2162            * @param status the status
2163            * @param start the lower bound of the range of bookmarks entries
2164            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2165            * @return the range of matching bookmarks entries that the user has permission to view
2166            * @throws SystemException if a system exception occurred
2167            */
2168            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
2169                    long groupId, long userId, int status, int start, int end)
2170                    throws com.liferay.portal.kernel.exception.SystemException {
2171                    return getPersistence()
2172                                       .filterFindByG_U_S(groupId, userId, status, start, end);
2173            }
2174    
2175            /**
2176            * 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;.
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 userId the user 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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2188            * @return the ordered range of matching bookmarks entries that the user has permission to view
2189            * @throws SystemException if a system exception occurred
2190            */
2191            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
2192                    long groupId, long userId, int status, int start, int end,
2193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2194                    throws com.liferay.portal.kernel.exception.SystemException {
2195                    return getPersistence()
2196                                       .filterFindByG_U_S(groupId, userId, status, start, end,
2197                            orderByComparator);
2198            }
2199    
2200            /**
2201            * 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;.
2202            *
2203            * @param entryId the primary key of the current bookmarks entry
2204            * @param groupId the group ID
2205            * @param userId the user ID
2206            * @param status the status
2207            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2208            * @return the previous, current, and next bookmarks entry
2209            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2210            * @throws SystemException if a system exception occurred
2211            */
2212            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext(
2213                    long entryId, long groupId, long userId, int status,
2214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2215                    throws com.liferay.portal.kernel.exception.SystemException,
2216                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2217                    return getPersistence()
2218                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
2219                            status, orderByComparator);
2220            }
2221    
2222            /**
2223            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
2224            *
2225            * @param groupId the group ID
2226            * @param userId the user ID
2227            * @param status the status
2228            * @throws SystemException if a system exception occurred
2229            */
2230            public static void removeByG_U_S(long groupId, long userId, int status)
2231                    throws com.liferay.portal.kernel.exception.SystemException {
2232                    getPersistence().removeByG_U_S(groupId, userId, status);
2233            }
2234    
2235            /**
2236            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
2237            *
2238            * @param groupId the group ID
2239            * @param userId the user ID
2240            * @param status the status
2241            * @return the number of matching bookmarks entries
2242            * @throws SystemException if a system exception occurred
2243            */
2244            public static int countByG_U_S(long groupId, long userId, int status)
2245                    throws com.liferay.portal.kernel.exception.SystemException {
2246                    return getPersistence().countByG_U_S(groupId, userId, status);
2247            }
2248    
2249            /**
2250            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2251            *
2252            * @param groupId the group ID
2253            * @param userId the user ID
2254            * @param status the status
2255            * @return the number of matching bookmarks entries that the user has permission to view
2256            * @throws SystemException if a system exception occurred
2257            */
2258            public static int filterCountByG_U_S(long groupId, long userId, int status)
2259                    throws com.liferay.portal.kernel.exception.SystemException {
2260                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
2261            }
2262    
2263            /**
2264            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2265            *
2266            * @param groupId the group ID
2267            * @param userId the user ID
2268            * @param status the status
2269            * @return the matching bookmarks entries
2270            * @throws SystemException if a system exception occurred
2271            */
2272            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2273                    long groupId, long userId, int status)
2274                    throws com.liferay.portal.kernel.exception.SystemException {
2275                    return getPersistence().findByG_U_NotS(groupId, userId, status);
2276            }
2277    
2278            /**
2279            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2280            *
2281            * <p>
2282            * 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.
2283            * </p>
2284            *
2285            * @param groupId the group ID
2286            * @param userId the user ID
2287            * @param status the status
2288            * @param start the lower bound of the range of bookmarks entries
2289            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2290            * @return the range of matching bookmarks entries
2291            * @throws SystemException if a system exception occurred
2292            */
2293            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2294                    long groupId, long userId, int status, int start, int end)
2295                    throws com.liferay.portal.kernel.exception.SystemException {
2296                    return getPersistence()
2297                                       .findByG_U_NotS(groupId, userId, status, start, end);
2298            }
2299    
2300            /**
2301            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2302            *
2303            * <p>
2304            * 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.
2305            * </p>
2306            *
2307            * @param groupId the group ID
2308            * @param userId the user ID
2309            * @param status the status
2310            * @param start the lower bound of the range of bookmarks entries
2311            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2313            * @return the ordered range of matching bookmarks entries
2314            * @throws SystemException if a system exception occurred
2315            */
2316            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2317                    long groupId, long userId, int status, int start, int end,
2318                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2319                    throws com.liferay.portal.kernel.exception.SystemException {
2320                    return getPersistence()
2321                                       .findByG_U_NotS(groupId, userId, status, start, end,
2322                            orderByComparator);
2323            }
2324    
2325            /**
2326            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2327            *
2328            * @param groupId the group ID
2329            * @param userId the user ID
2330            * @param status the status
2331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2332            * @return the first matching bookmarks entry
2333            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2334            * @throws SystemException if a system exception occurred
2335            */
2336            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_First(
2337                    long groupId, long userId, int status,
2338                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2339                    throws com.liferay.portal.kernel.exception.SystemException,
2340                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2341                    return getPersistence()
2342                                       .findByG_U_NotS_First(groupId, userId, status,
2343                            orderByComparator);
2344            }
2345    
2346            /**
2347            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2348            *
2349            * @param groupId the group ID
2350            * @param userId the user ID
2351            * @param status the status
2352            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2353            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2354            * @throws SystemException if a system exception occurred
2355            */
2356            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_First(
2357                    long groupId, long userId, int status,
2358                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2359                    throws com.liferay.portal.kernel.exception.SystemException {
2360                    return getPersistence()
2361                                       .fetchByG_U_NotS_First(groupId, userId, status,
2362                            orderByComparator);
2363            }
2364    
2365            /**
2366            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2367            *
2368            * @param groupId the group ID
2369            * @param userId the user ID
2370            * @param status the status
2371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2372            * @return the last matching bookmarks entry
2373            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2374            * @throws SystemException if a system exception occurred
2375            */
2376            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_Last(
2377                    long groupId, long userId, int status,
2378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2379                    throws com.liferay.portal.kernel.exception.SystemException,
2380                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2381                    return getPersistence()
2382                                       .findByG_U_NotS_Last(groupId, userId, status,
2383                            orderByComparator);
2384            }
2385    
2386            /**
2387            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2388            *
2389            * @param groupId the group ID
2390            * @param userId the user ID
2391            * @param status the status
2392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2393            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2394            * @throws SystemException if a system exception occurred
2395            */
2396            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_Last(
2397                    long groupId, long userId, int status,
2398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2399                    throws com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence()
2401                                       .fetchByG_U_NotS_Last(groupId, userId, status,
2402                            orderByComparator);
2403            }
2404    
2405            /**
2406            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2407            *
2408            * @param entryId the primary key of the current bookmarks entry
2409            * @param groupId the group ID
2410            * @param userId the user ID
2411            * @param status the status
2412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2413            * @return the previous, current, and next bookmarks entry
2414            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2415            * @throws SystemException if a system exception occurred
2416            */
2417            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_NotS_PrevAndNext(
2418                    long entryId, long groupId, long userId, int status,
2419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2420                    throws com.liferay.portal.kernel.exception.SystemException,
2421                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2422                    return getPersistence()
2423                                       .findByG_U_NotS_PrevAndNext(entryId, groupId, userId,
2424                            status, orderByComparator);
2425            }
2426    
2427            /**
2428            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2429            *
2430            * @param groupId the group ID
2431            * @param userId the user ID
2432            * @param status the status
2433            * @return the matching bookmarks entries that the user has permission to view
2434            * @throws SystemException if a system exception occurred
2435            */
2436            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2437                    long groupId, long userId, int status)
2438                    throws com.liferay.portal.kernel.exception.SystemException {
2439                    return getPersistence().filterFindByG_U_NotS(groupId, userId, status);
2440            }
2441    
2442            /**
2443            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2444            *
2445            * <p>
2446            * 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.
2447            * </p>
2448            *
2449            * @param groupId the group ID
2450            * @param userId the user ID
2451            * @param status the status
2452            * @param start the lower bound of the range of bookmarks entries
2453            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2454            * @return the range of matching bookmarks entries that the user has permission to view
2455            * @throws SystemException if a system exception occurred
2456            */
2457            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2458                    long groupId, long userId, int status, int start, int end)
2459                    throws com.liferay.portal.kernel.exception.SystemException {
2460                    return getPersistence()
2461                                       .filterFindByG_U_NotS(groupId, userId, status, start, end);
2462            }
2463    
2464            /**
2465            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2466            *
2467            * <p>
2468            * 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.
2469            * </p>
2470            *
2471            * @param groupId the group ID
2472            * @param userId the user ID
2473            * @param status the status
2474            * @param start the lower bound of the range of bookmarks entries
2475            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2476            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2477            * @return the ordered range of matching bookmarks entries that the user has permission to view
2478            * @throws SystemException if a system exception occurred
2479            */
2480            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2481                    long groupId, long userId, int status, int start, int end,
2482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2483                    throws com.liferay.portal.kernel.exception.SystemException {
2484                    return getPersistence()
2485                                       .filterFindByG_U_NotS(groupId, userId, status, start, end,
2486                            orderByComparator);
2487            }
2488    
2489            /**
2490            * 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 &ne; &#63;.
2491            *
2492            * @param entryId the primary key of the current bookmarks entry
2493            * @param groupId the group ID
2494            * @param userId the user ID
2495            * @param status the status
2496            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2497            * @return the previous, current, and next bookmarks entry
2498            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2499            * @throws SystemException if a system exception occurred
2500            */
2501            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_NotS_PrevAndNext(
2502                    long entryId, long groupId, long userId, int status,
2503                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2504                    throws com.liferay.portal.kernel.exception.SystemException,
2505                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2506                    return getPersistence()
2507                                       .filterFindByG_U_NotS_PrevAndNext(entryId, groupId, userId,
2508                            status, orderByComparator);
2509            }
2510    
2511            /**
2512            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63; from the database.
2513            *
2514            * @param groupId the group ID
2515            * @param userId the user ID
2516            * @param status the status
2517            * @throws SystemException if a system exception occurred
2518            */
2519            public static void removeByG_U_NotS(long groupId, long userId, int status)
2520                    throws com.liferay.portal.kernel.exception.SystemException {
2521                    getPersistence().removeByG_U_NotS(groupId, userId, status);
2522            }
2523    
2524            /**
2525            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2526            *
2527            * @param groupId the group ID
2528            * @param userId the user ID
2529            * @param status the status
2530            * @return the number of matching bookmarks entries
2531            * @throws SystemException if a system exception occurred
2532            */
2533            public static int countByG_U_NotS(long groupId, long userId, int status)
2534                    throws com.liferay.portal.kernel.exception.SystemException {
2535                    return getPersistence().countByG_U_NotS(groupId, userId, status);
2536            }
2537    
2538            /**
2539            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2540            *
2541            * @param groupId the group ID
2542            * @param userId the user ID
2543            * @param status the status
2544            * @return the number of matching bookmarks entries that the user has permission to view
2545            * @throws SystemException if a system exception occurred
2546            */
2547            public static int filterCountByG_U_NotS(long groupId, long userId,
2548                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2549                    return getPersistence().filterCountByG_U_NotS(groupId, userId, status);
2550            }
2551    
2552            /**
2553            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2554            *
2555            * @param groupId the group ID
2556            * @param folderId the folder ID
2557            * @param status the status
2558            * @return the matching bookmarks entries
2559            * @throws SystemException if a system exception occurred
2560            */
2561            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2562                    long groupId, long folderId, int status)
2563                    throws com.liferay.portal.kernel.exception.SystemException {
2564                    return getPersistence().findByG_F_S(groupId, folderId, status);
2565            }
2566    
2567            /**
2568            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2569            *
2570            * <p>
2571            * 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.
2572            * </p>
2573            *
2574            * @param groupId the group ID
2575            * @param folderId the folder ID
2576            * @param status the status
2577            * @param start the lower bound of the range of bookmarks entries
2578            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2579            * @return the range of matching bookmarks entries
2580            * @throws SystemException if a system exception occurred
2581            */
2582            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2583                    long groupId, long folderId, int status, int start, int end)
2584                    throws com.liferay.portal.kernel.exception.SystemException {
2585                    return getPersistence()
2586                                       .findByG_F_S(groupId, folderId, status, start, end);
2587            }
2588    
2589            /**
2590            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2591            *
2592            * <p>
2593            * 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.
2594            * </p>
2595            *
2596            * @param groupId the group ID
2597            * @param folderId the folder ID
2598            * @param status the status
2599            * @param start the lower bound of the range of bookmarks entries
2600            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2601            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2602            * @return the ordered range of matching bookmarks entries
2603            * @throws SystemException if a system exception occurred
2604            */
2605            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2606                    long groupId, long folderId, int status, int start, int end,
2607                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2608                    throws com.liferay.portal.kernel.exception.SystemException {
2609                    return getPersistence()
2610                                       .findByG_F_S(groupId, folderId, status, start, end,
2611                            orderByComparator);
2612            }
2613    
2614            /**
2615            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2616            *
2617            * @param groupId the group ID
2618            * @param folderId the folder ID
2619            * @param status the status
2620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2621            * @return the first matching bookmarks entry
2622            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2623            * @throws SystemException if a system exception occurred
2624            */
2625            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First(
2626                    long groupId, long folderId, int status,
2627                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2628                    throws com.liferay.portal.kernel.exception.SystemException,
2629                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2630                    return getPersistence()
2631                                       .findByG_F_S_First(groupId, folderId, status,
2632                            orderByComparator);
2633            }
2634    
2635            /**
2636            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2637            *
2638            * @param groupId the group ID
2639            * @param folderId the folder ID
2640            * @param status the status
2641            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2642            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2643            * @throws SystemException if a system exception occurred
2644            */
2645            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First(
2646                    long groupId, long folderId, int status,
2647                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2648                    throws com.liferay.portal.kernel.exception.SystemException {
2649                    return getPersistence()
2650                                       .fetchByG_F_S_First(groupId, folderId, status,
2651                            orderByComparator);
2652            }
2653    
2654            /**
2655            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2656            *
2657            * @param groupId the group ID
2658            * @param folderId the folder ID
2659            * @param status the status
2660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2661            * @return the last matching bookmarks entry
2662            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last(
2666                    long groupId, long folderId, int status,
2667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2668                    throws com.liferay.portal.kernel.exception.SystemException,
2669                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2670                    return getPersistence()
2671                                       .findByG_F_S_Last(groupId, folderId, status,
2672                            orderByComparator);
2673            }
2674    
2675            /**
2676            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2677            *
2678            * @param groupId the group ID
2679            * @param folderId the folder ID
2680            * @param status the status
2681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2682            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2683            * @throws SystemException if a system exception occurred
2684            */
2685            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last(
2686                    long groupId, long folderId, int status,
2687                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2688                    throws com.liferay.portal.kernel.exception.SystemException {
2689                    return getPersistence()
2690                                       .fetchByG_F_S_Last(groupId, folderId, status,
2691                            orderByComparator);
2692            }
2693    
2694            /**
2695            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2696            *
2697            * @param entryId the primary key of the current bookmarks entry
2698            * @param groupId the group ID
2699            * @param folderId the folder ID
2700            * @param status the status
2701            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2702            * @return the previous, current, and next bookmarks entry
2703            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2704            * @throws SystemException if a system exception occurred
2705            */
2706            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext(
2707                    long entryId, long groupId, long folderId, int status,
2708                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2709                    throws com.liferay.portal.kernel.exception.SystemException,
2710                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2711                    return getPersistence()
2712                                       .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status,
2713                            orderByComparator);
2714            }
2715    
2716            /**
2717            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2718            *
2719            * @param groupId the group ID
2720            * @param folderId the folder ID
2721            * @param status the status
2722            * @return the matching bookmarks entries that the user has permission to view
2723            * @throws SystemException if a system exception occurred
2724            */
2725            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2726                    long groupId, long folderId, int status)
2727                    throws com.liferay.portal.kernel.exception.SystemException {
2728                    return getPersistence().filterFindByG_F_S(groupId, folderId, status);
2729            }
2730    
2731            /**
2732            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2733            *
2734            * <p>
2735            * 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.
2736            * </p>
2737            *
2738            * @param groupId the group ID
2739            * @param folderId the folder ID
2740            * @param status the status
2741            * @param start the lower bound of the range of bookmarks entries
2742            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2743            * @return the range of matching bookmarks entries that the user has permission to view
2744            * @throws SystemException if a system exception occurred
2745            */
2746            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2747                    long groupId, long folderId, int status, int start, int end)
2748                    throws com.liferay.portal.kernel.exception.SystemException {
2749                    return getPersistence()
2750                                       .filterFindByG_F_S(groupId, folderId, status, start, end);
2751            }
2752    
2753            /**
2754            * 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;.
2755            *
2756            * <p>
2757            * 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.
2758            * </p>
2759            *
2760            * @param groupId the group ID
2761            * @param folderId the folder ID
2762            * @param status the status
2763            * @param start the lower bound of the range of bookmarks entries
2764            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2765            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2766            * @return the ordered range of matching bookmarks entries that the user has permission to view
2767            * @throws SystemException if a system exception occurred
2768            */
2769            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2770                    long groupId, long folderId, int status, int start, int end,
2771                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2772                    throws com.liferay.portal.kernel.exception.SystemException {
2773                    return getPersistence()
2774                                       .filterFindByG_F_S(groupId, folderId, status, start, end,
2775                            orderByComparator);
2776            }
2777    
2778            /**
2779            * 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;.
2780            *
2781            * @param entryId the primary key of the current bookmarks entry
2782            * @param groupId the group ID
2783            * @param folderId the folder ID
2784            * @param status the status
2785            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2786            * @return the previous, current, and next bookmarks entry
2787            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2788            * @throws SystemException if a system exception occurred
2789            */
2790            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext(
2791                    long entryId, long groupId, long folderId, int status,
2792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2793                    throws com.liferay.portal.kernel.exception.SystemException,
2794                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2795                    return getPersistence()
2796                                       .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId,
2797                            status, orderByComparator);
2798            }
2799    
2800            /**
2801            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2802            *
2803            * @param groupId the group ID
2804            * @param folderIds the folder IDs
2805            * @param status the status
2806            * @return the matching bookmarks entries that the user has permission to view
2807            * @throws SystemException if a system exception occurred
2808            */
2809            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2810                    long groupId, long[] folderIds, int status)
2811                    throws com.liferay.portal.kernel.exception.SystemException {
2812                    return getPersistence().filterFindByG_F_S(groupId, folderIds, status);
2813            }
2814    
2815            /**
2816            * 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;.
2817            *
2818            * <p>
2819            * 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.
2820            * </p>
2821            *
2822            * @param groupId the group ID
2823            * @param folderIds the folder IDs
2824            * @param status the status
2825            * @param start the lower bound of the range of bookmarks entries
2826            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2827            * @return the range of matching bookmarks entries that the user has permission to view
2828            * @throws SystemException if a system exception occurred
2829            */
2830            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2831                    long groupId, long[] folderIds, int status, int start, int end)
2832                    throws com.liferay.portal.kernel.exception.SystemException {
2833                    return getPersistence()
2834                                       .filterFindByG_F_S(groupId, folderIds, status, start, end);
2835            }
2836    
2837            /**
2838            * 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;.
2839            *
2840            * <p>
2841            * 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.
2842            * </p>
2843            *
2844            * @param groupId the group ID
2845            * @param folderIds the folder IDs
2846            * @param status the status
2847            * @param start the lower bound of the range of bookmarks entries
2848            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2849            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2850            * @return the ordered range of matching bookmarks entries that the user has permission to view
2851            * @throws SystemException if a system exception occurred
2852            */
2853            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2854                    long groupId, long[] folderIds, int status, int start, int end,
2855                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2856                    throws com.liferay.portal.kernel.exception.SystemException {
2857                    return getPersistence()
2858                                       .filterFindByG_F_S(groupId, folderIds, status, start, end,
2859                            orderByComparator);
2860            }
2861    
2862            /**
2863            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2864            *
2865            * <p>
2866            * 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.
2867            * </p>
2868            *
2869            * @param groupId the group ID
2870            * @param folderIds the folder IDs
2871            * @param status the status
2872            * @return the matching bookmarks entries
2873            * @throws SystemException if a system exception occurred
2874            */
2875            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2876                    long groupId, long[] folderIds, int status)
2877                    throws com.liferay.portal.kernel.exception.SystemException {
2878                    return getPersistence().findByG_F_S(groupId, folderIds, status);
2879            }
2880    
2881            /**
2882            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2883            *
2884            * <p>
2885            * 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.
2886            * </p>
2887            *
2888            * @param groupId the group ID
2889            * @param folderIds the folder IDs
2890            * @param status the status
2891            * @param start the lower bound of the range of bookmarks entries
2892            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2893            * @return the range of 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_F_S(
2897                    long groupId, long[] folderIds, int status, int start, int end)
2898                    throws com.liferay.portal.kernel.exception.SystemException {
2899                    return getPersistence()
2900                                       .findByG_F_S(groupId, folderIds, status, start, end);
2901            }
2902    
2903            /**
2904            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2905            *
2906            * <p>
2907            * 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.
2908            * </p>
2909            *
2910            * @param groupId the group ID
2911            * @param folderIds the folder IDs
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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2916            * @return the ordered range of matching bookmarks entries
2917            * @throws SystemException if a system exception occurred
2918            */
2919            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2920                    long groupId, long[] folderIds, int status, int start, int end,
2921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2922                    throws com.liferay.portal.kernel.exception.SystemException {
2923                    return getPersistence()
2924                                       .findByG_F_S(groupId, folderIds, status, start, end,
2925                            orderByComparator);
2926            }
2927    
2928            /**
2929            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
2930            *
2931            * @param groupId the group ID
2932            * @param folderId the folder ID
2933            * @param status the status
2934            * @throws SystemException if a system exception occurred
2935            */
2936            public static void removeByG_F_S(long groupId, long folderId, int status)
2937                    throws com.liferay.portal.kernel.exception.SystemException {
2938                    getPersistence().removeByG_F_S(groupId, folderId, status);
2939            }
2940    
2941            /**
2942            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2943            *
2944            * @param groupId the group ID
2945            * @param folderId the folder ID
2946            * @param status the status
2947            * @return the number of matching bookmarks entries
2948            * @throws SystemException if a system exception occurred
2949            */
2950            public static int countByG_F_S(long groupId, long folderId, int status)
2951                    throws com.liferay.portal.kernel.exception.SystemException {
2952                    return getPersistence().countByG_F_S(groupId, folderId, status);
2953            }
2954    
2955            /**
2956            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2957            *
2958            * @param groupId the group ID
2959            * @param folderIds the folder IDs
2960            * @param status the status
2961            * @return the number of matching bookmarks entries
2962            * @throws SystemException if a system exception occurred
2963            */
2964            public static int countByG_F_S(long groupId, long[] folderIds, int status)
2965                    throws com.liferay.portal.kernel.exception.SystemException {
2966                    return getPersistence().countByG_F_S(groupId, folderIds, status);
2967            }
2968    
2969            /**
2970            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2971            *
2972            * @param groupId the group ID
2973            * @param folderId the folder ID
2974            * @param status the status
2975            * @return the number of matching bookmarks entries that the user has permission to view
2976            * @throws SystemException if a system exception occurred
2977            */
2978            public static int filterCountByG_F_S(long groupId, long folderId, int status)
2979                    throws com.liferay.portal.kernel.exception.SystemException {
2980                    return getPersistence().filterCountByG_F_S(groupId, folderId, status);
2981            }
2982    
2983            /**
2984            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2985            *
2986            * @param groupId the group ID
2987            * @param folderIds the folder IDs
2988            * @param status the status
2989            * @return the number of matching bookmarks entries that the user has permission to view
2990            * @throws SystemException if a system exception occurred
2991            */
2992            public static int filterCountByG_F_S(long groupId, long[] folderIds,
2993                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2994                    return getPersistence().filterCountByG_F_S(groupId, folderIds, status);
2995            }
2996    
2997            /**
2998            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2999            *
3000            * @param groupId the group ID
3001            * @param folderId the folder ID
3002            * @param status the status
3003            * @return the matching bookmarks entries
3004            * @throws SystemException if a system exception occurred
3005            */
3006            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3007                    long groupId, long folderId, int status)
3008                    throws com.liferay.portal.kernel.exception.SystemException {
3009                    return getPersistence().findByG_F_NotS(groupId, folderId, status);
3010            }
3011    
3012            /**
3013            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3014            *
3015            * <p>
3016            * 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.
3017            * </p>
3018            *
3019            * @param groupId the group ID
3020            * @param folderId the folder ID
3021            * @param status the status
3022            * @param start the lower bound of the range of bookmarks entries
3023            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3024            * @return the range of matching bookmarks entries
3025            * @throws SystemException if a system exception occurred
3026            */
3027            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3028                    long groupId, long folderId, int status, int start, int end)
3029                    throws com.liferay.portal.kernel.exception.SystemException {
3030                    return getPersistence()
3031                                       .findByG_F_NotS(groupId, folderId, status, start, end);
3032            }
3033    
3034            /**
3035            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3036            *
3037            * <p>
3038            * 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.
3039            * </p>
3040            *
3041            * @param groupId the group ID
3042            * @param folderId the folder ID
3043            * @param status the status
3044            * @param start the lower bound of the range of bookmarks entries
3045            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3046            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3047            * @return the ordered range of matching bookmarks entries
3048            * @throws SystemException if a system exception occurred
3049            */
3050            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3051                    long groupId, long folderId, int status, int start, int end,
3052                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3053                    throws com.liferay.portal.kernel.exception.SystemException {
3054                    return getPersistence()
3055                                       .findByG_F_NotS(groupId, folderId, status, start, end,
3056                            orderByComparator);
3057            }
3058    
3059            /**
3060            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3061            *
3062            * @param groupId the group ID
3063            * @param folderId the folder ID
3064            * @param status the status
3065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3066            * @return the first matching bookmarks entry
3067            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3068            * @throws SystemException if a system exception occurred
3069            */
3070            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First(
3071                    long groupId, long folderId, int status,
3072                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3073                    throws com.liferay.portal.kernel.exception.SystemException,
3074                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3075                    return getPersistence()
3076                                       .findByG_F_NotS_First(groupId, folderId, status,
3077                            orderByComparator);
3078            }
3079    
3080            /**
3081            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3082            *
3083            * @param groupId the group ID
3084            * @param folderId the folder ID
3085            * @param status the status
3086            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3087            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3088            * @throws SystemException if a system exception occurred
3089            */
3090            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First(
3091                    long groupId, long folderId, int status,
3092                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3093                    throws com.liferay.portal.kernel.exception.SystemException {
3094                    return getPersistence()
3095                                       .fetchByG_F_NotS_First(groupId, folderId, status,
3096                            orderByComparator);
3097            }
3098    
3099            /**
3100            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3101            *
3102            * @param groupId the group ID
3103            * @param folderId the folder ID
3104            * @param status the status
3105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3106            * @return the last matching bookmarks entry
3107            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3108            * @throws SystemException if a system exception occurred
3109            */
3110            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last(
3111                    long groupId, long folderId, int status,
3112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3113                    throws com.liferay.portal.kernel.exception.SystemException,
3114                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3115                    return getPersistence()
3116                                       .findByG_F_NotS_Last(groupId, folderId, status,
3117                            orderByComparator);
3118            }
3119    
3120            /**
3121            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3122            *
3123            * @param groupId the group ID
3124            * @param folderId the folder ID
3125            * @param status the status
3126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3127            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3128            * @throws SystemException if a system exception occurred
3129            */
3130            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last(
3131                    long groupId, long folderId, int status,
3132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3133                    throws com.liferay.portal.kernel.exception.SystemException {
3134                    return getPersistence()
3135                                       .fetchByG_F_NotS_Last(groupId, folderId, status,
3136                            orderByComparator);
3137            }
3138    
3139            /**
3140            * 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;.
3141            *
3142            * @param entryId the primary key of the current bookmarks entry
3143            * @param groupId the group ID
3144            * @param folderId the folder ID
3145            * @param status the status
3146            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3147            * @return the previous, current, and next bookmarks entry
3148            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3149            * @throws SystemException if a system exception occurred
3150            */
3151            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext(
3152                    long entryId, long groupId, long folderId, int status,
3153                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3154                    throws com.liferay.portal.kernel.exception.SystemException,
3155                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3156                    return getPersistence()
3157                                       .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId,
3158                            status, orderByComparator);
3159            }
3160    
3161            /**
3162            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3163            *
3164            * @param groupId the group ID
3165            * @param folderId the folder ID
3166            * @param status the status
3167            * @return the matching bookmarks entries that the user has permission to view
3168            * @throws SystemException if a system exception occurred
3169            */
3170            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3171                    long groupId, long folderId, int status)
3172                    throws com.liferay.portal.kernel.exception.SystemException {
3173                    return getPersistence().filterFindByG_F_NotS(groupId, folderId, status);
3174            }
3175    
3176            /**
3177            * 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;.
3178            *
3179            * <p>
3180            * 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.
3181            * </p>
3182            *
3183            * @param groupId the group ID
3184            * @param folderId the folder ID
3185            * @param status the status
3186            * @param start the lower bound of the range of bookmarks entries
3187            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3188            * @return the range of matching bookmarks entries that the user has permission to view
3189            * @throws SystemException if a system exception occurred
3190            */
3191            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3192                    long groupId, long folderId, int status, int start, int end)
3193                    throws com.liferay.portal.kernel.exception.SystemException {
3194                    return getPersistence()
3195                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end);
3196            }
3197    
3198            /**
3199            * 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;.
3200            *
3201            * <p>
3202            * 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.
3203            * </p>
3204            *
3205            * @param groupId the group ID
3206            * @param folderId the folder ID
3207            * @param status the status
3208            * @param start the lower bound of the range of bookmarks entries
3209            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3210            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3211            * @return the ordered range of matching bookmarks entries that the user has permission to view
3212            * @throws SystemException if a system exception occurred
3213            */
3214            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3215                    long groupId, long folderId, int status, int start, int end,
3216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3217                    throws com.liferay.portal.kernel.exception.SystemException {
3218                    return getPersistence()
3219                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end,
3220                            orderByComparator);
3221            }
3222    
3223            /**
3224            * 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;.
3225            *
3226            * @param entryId the primary key of the current bookmarks entry
3227            * @param groupId the group ID
3228            * @param folderId the folder ID
3229            * @param status the status
3230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3231            * @return the previous, current, and next bookmarks entry
3232            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3233            * @throws SystemException if a system exception occurred
3234            */
3235            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext(
3236                    long entryId, long groupId, long folderId, int status,
3237                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3238                    throws com.liferay.portal.kernel.exception.SystemException,
3239                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3240                    return getPersistence()
3241                                       .filterFindByG_F_NotS_PrevAndNext(entryId, groupId,
3242                            folderId, status, orderByComparator);
3243            }
3244    
3245            /**
3246            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3247            *
3248            * @param groupId the group ID
3249            * @param folderIds the folder IDs
3250            * @param status the status
3251            * @return the matching bookmarks entries that the user has permission to view
3252            * @throws SystemException if a system exception occurred
3253            */
3254            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3255                    long groupId, long[] folderIds, int status)
3256                    throws com.liferay.portal.kernel.exception.SystemException {
3257                    return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status);
3258            }
3259    
3260            /**
3261            * 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;.
3262            *
3263            * <p>
3264            * 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.
3265            * </p>
3266            *
3267            * @param groupId the group ID
3268            * @param folderIds the folder IDs
3269            * @param status the status
3270            * @param start the lower bound of the range of bookmarks entries
3271            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3272            * @return the range of matching bookmarks entries that the user has permission to view
3273            * @throws SystemException if a system exception occurred
3274            */
3275            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3276                    long groupId, long[] folderIds, int status, int start, int end)
3277                    throws com.liferay.portal.kernel.exception.SystemException {
3278                    return getPersistence()
3279                                       .filterFindByG_F_NotS(groupId, folderIds, status, start, end);
3280            }
3281    
3282            /**
3283            * 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;.
3284            *
3285            * <p>
3286            * 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.
3287            * </p>
3288            *
3289            * @param groupId the group ID
3290            * @param folderIds the folder IDs
3291            * @param status the status
3292            * @param start the lower bound of the range of bookmarks entries
3293            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3294            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3295            * @return the ordered range of matching bookmarks entries that the user has permission to view
3296            * @throws SystemException if a system exception occurred
3297            */
3298            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
3299                    long groupId, long[] folderIds, int status, int start, int end,
3300                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3301                    throws com.liferay.portal.kernel.exception.SystemException {
3302                    return getPersistence()
3303                                       .filterFindByG_F_NotS(groupId, folderIds, status, start,
3304                            end, orderByComparator);
3305            }
3306    
3307            /**
3308            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3309            *
3310            * <p>
3311            * 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.
3312            * </p>
3313            *
3314            * @param groupId the group ID
3315            * @param folderIds the folder IDs
3316            * @param status the status
3317            * @return the matching bookmarks entries
3318            * @throws SystemException if a system exception occurred
3319            */
3320            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3321                    long groupId, long[] folderIds, int status)
3322                    throws com.liferay.portal.kernel.exception.SystemException {
3323                    return getPersistence().findByG_F_NotS(groupId, folderIds, status);
3324            }
3325    
3326            /**
3327            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3328            *
3329            * <p>
3330            * 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.
3331            * </p>
3332            *
3333            * @param groupId the group ID
3334            * @param folderIds the folder IDs
3335            * @param status the status
3336            * @param start the lower bound of the range of bookmarks entries
3337            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3338            * @return the range of matching bookmarks entries
3339            * @throws SystemException if a system exception occurred
3340            */
3341            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3342                    long groupId, long[] folderIds, int status, int start, int end)
3343                    throws com.liferay.portal.kernel.exception.SystemException {
3344                    return getPersistence()
3345                                       .findByG_F_NotS(groupId, folderIds, status, start, end);
3346            }
3347    
3348            /**
3349            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3350            *
3351            * <p>
3352            * 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.
3353            * </p>
3354            *
3355            * @param groupId the group ID
3356            * @param folderIds the folder IDs
3357            * @param status the status
3358            * @param start the lower bound of the range of bookmarks entries
3359            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3360            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3361            * @return the ordered range of matching bookmarks entries
3362            * @throws SystemException if a system exception occurred
3363            */
3364            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3365                    long groupId, long[] folderIds, int status, int start, int end,
3366                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3367                    throws com.liferay.portal.kernel.exception.SystemException {
3368                    return getPersistence()
3369                                       .findByG_F_NotS(groupId, folderIds, status, start, end,
3370                            orderByComparator);
3371            }
3372    
3373            /**
3374            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63; from the database.
3375            *
3376            * @param groupId the group ID
3377            * @param folderId the folder ID
3378            * @param status the status
3379            * @throws SystemException if a system exception occurred
3380            */
3381            public static void removeByG_F_NotS(long groupId, long folderId, int status)
3382                    throws com.liferay.portal.kernel.exception.SystemException {
3383                    getPersistence().removeByG_F_NotS(groupId, folderId, status);
3384            }
3385    
3386            /**
3387            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3388            *
3389            * @param groupId the group ID
3390            * @param folderId the folder ID
3391            * @param status the status
3392            * @return the number of matching bookmarks entries
3393            * @throws SystemException if a system exception occurred
3394            */
3395            public static int countByG_F_NotS(long groupId, long folderId, int status)
3396                    throws com.liferay.portal.kernel.exception.SystemException {
3397                    return getPersistence().countByG_F_NotS(groupId, folderId, status);
3398            }
3399    
3400            /**
3401            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3402            *
3403            * @param groupId the group ID
3404            * @param folderIds the folder IDs
3405            * @param status the status
3406            * @return the number of matching bookmarks entries
3407            * @throws SystemException if a system exception occurred
3408            */
3409            public static int countByG_F_NotS(long groupId, long[] folderIds, int status)
3410                    throws com.liferay.portal.kernel.exception.SystemException {
3411                    return getPersistence().countByG_F_NotS(groupId, folderIds, status);
3412            }
3413    
3414            /**
3415            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3416            *
3417            * @param groupId the group ID
3418            * @param folderId the folder ID
3419            * @param status the status
3420            * @return the number of matching bookmarks entries that the user has permission to view
3421            * @throws SystemException if a system exception occurred
3422            */
3423            public static int filterCountByG_F_NotS(long groupId, long folderId,
3424                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3425                    return getPersistence().filterCountByG_F_NotS(groupId, folderId, status);
3426            }
3427    
3428            /**
3429            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3430            *
3431            * @param groupId the group ID
3432            * @param folderIds the folder IDs
3433            * @param status the status
3434            * @return the number of matching bookmarks entries that the user has permission to view
3435            * @throws SystemException if a system exception occurred
3436            */
3437            public static int filterCountByG_F_NotS(long groupId, long[] folderIds,
3438                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3439                    return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status);
3440            }
3441    
3442            /**
3443            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3444            *
3445            * @param groupId the group ID
3446            * @param userId the user ID
3447            * @param folderId the folder ID
3448            * @param status the status
3449            * @return the matching bookmarks entries
3450            * @throws SystemException if a system exception occurred
3451            */
3452            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3453                    long groupId, long userId, long folderId, int status)
3454                    throws com.liferay.portal.kernel.exception.SystemException {
3455                    return getPersistence().findByG_U_F_S(groupId, userId, folderId, status);
3456            }
3457    
3458            /**
3459            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3460            *
3461            * <p>
3462            * 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.
3463            * </p>
3464            *
3465            * @param groupId the group ID
3466            * @param userId the user ID
3467            * @param folderId the folder ID
3468            * @param status the status
3469            * @param start the lower bound of the range of bookmarks entries
3470            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3471            * @return the range of matching bookmarks entries
3472            * @throws SystemException if a system exception occurred
3473            */
3474            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3475                    long groupId, long userId, long folderId, int status, int start, int end)
3476                    throws com.liferay.portal.kernel.exception.SystemException {
3477                    return getPersistence()
3478                                       .findByG_U_F_S(groupId, userId, folderId, status, start, end);
3479            }
3480    
3481            /**
3482            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3483            *
3484            * <p>
3485            * 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.
3486            * </p>
3487            *
3488            * @param groupId the group ID
3489            * @param userId the user ID
3490            * @param folderId the folder ID
3491            * @param status the status
3492            * @param start the lower bound of the range of bookmarks entries
3493            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3494            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3495            * @return the ordered range of matching bookmarks entries
3496            * @throws SystemException if a system exception occurred
3497            */
3498            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3499                    long groupId, long userId, long folderId, int status, int start,
3500                    int end,
3501                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3502                    throws com.liferay.portal.kernel.exception.SystemException {
3503                    return getPersistence()
3504                                       .findByG_U_F_S(groupId, userId, folderId, status, start,
3505                            end, orderByComparator);
3506            }
3507    
3508            /**
3509            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3510            *
3511            * @param groupId the group ID
3512            * @param userId the user ID
3513            * @param folderId the folder ID
3514            * @param status the status
3515            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3516            * @return the first matching bookmarks entry
3517            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3518            * @throws SystemException if a system exception occurred
3519            */
3520            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First(
3521                    long groupId, long userId, long folderId, int status,
3522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3523                    throws com.liferay.portal.kernel.exception.SystemException,
3524                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3525                    return getPersistence()
3526                                       .findByG_U_F_S_First(groupId, userId, folderId, status,
3527                            orderByComparator);
3528            }
3529    
3530            /**
3531            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3532            *
3533            * @param groupId the group ID
3534            * @param userId the user ID
3535            * @param folderId the folder ID
3536            * @param status the status
3537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3538            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3539            * @throws SystemException if a system exception occurred
3540            */
3541            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First(
3542                    long groupId, long userId, long folderId, int status,
3543                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3544                    throws com.liferay.portal.kernel.exception.SystemException {
3545                    return getPersistence()
3546                                       .fetchByG_U_F_S_First(groupId, userId, folderId, status,
3547                            orderByComparator);
3548            }
3549    
3550            /**
3551            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3552            *
3553            * @param groupId the group ID
3554            * @param userId the user ID
3555            * @param folderId the folder ID
3556            * @param status the status
3557            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3558            * @return the last matching bookmarks entry
3559            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3560            * @throws SystemException if a system exception occurred
3561            */
3562            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last(
3563                    long groupId, long userId, long folderId, int status,
3564                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3565                    throws com.liferay.portal.kernel.exception.SystemException,
3566                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3567                    return getPersistence()
3568                                       .findByG_U_F_S_Last(groupId, userId, folderId, status,
3569                            orderByComparator);
3570            }
3571    
3572            /**
3573            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3574            *
3575            * @param groupId the group ID
3576            * @param userId the user ID
3577            * @param folderId the folder ID
3578            * @param status the status
3579            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3580            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3581            * @throws SystemException if a system exception occurred
3582            */
3583            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last(
3584                    long groupId, long userId, long folderId, int status,
3585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3586                    throws com.liferay.portal.kernel.exception.SystemException {
3587                    return getPersistence()
3588                                       .fetchByG_U_F_S_Last(groupId, userId, folderId, status,
3589                            orderByComparator);
3590            }
3591    
3592            /**
3593            * 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;.
3594            *
3595            * @param entryId the primary key of the current bookmarks entry
3596            * @param groupId the group ID
3597            * @param userId the user ID
3598            * @param folderId the folder ID
3599            * @param status the status
3600            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3601            * @return the previous, current, and next bookmarks entry
3602            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3603            * @throws SystemException if a system exception occurred
3604            */
3605            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext(
3606                    long entryId, long groupId, long userId, long folderId, int status,
3607                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3608                    throws com.liferay.portal.kernel.exception.SystemException,
3609                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3610                    return getPersistence()
3611                                       .findByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3612                            folderId, status, orderByComparator);
3613            }
3614    
3615            /**
3616            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3617            *
3618            * @param groupId the group ID
3619            * @param userId the user ID
3620            * @param folderId the folder ID
3621            * @param status the status
3622            * @return the matching bookmarks entries that the user has permission to view
3623            * @throws SystemException if a system exception occurred
3624            */
3625            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3626                    long groupId, long userId, long folderId, int status)
3627                    throws com.liferay.portal.kernel.exception.SystemException {
3628                    return getPersistence()
3629                                       .filterFindByG_U_F_S(groupId, userId, folderId, status);
3630            }
3631    
3632            /**
3633            * 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;.
3634            *
3635            * <p>
3636            * 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.
3637            * </p>
3638            *
3639            * @param groupId the group ID
3640            * @param userId the user ID
3641            * @param folderId the folder ID
3642            * @param status the status
3643            * @param start the lower bound of the range of bookmarks entries
3644            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3645            * @return the range of matching bookmarks entries that the user has permission to view
3646            * @throws SystemException if a system exception occurred
3647            */
3648            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3649                    long groupId, long userId, long folderId, int status, int start, int end)
3650                    throws com.liferay.portal.kernel.exception.SystemException {
3651                    return getPersistence()
3652                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3653                            start, end);
3654            }
3655    
3656            /**
3657            * 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;.
3658            *
3659            * <p>
3660            * 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.
3661            * </p>
3662            *
3663            * @param groupId the group ID
3664            * @param userId the user ID
3665            * @param folderId the folder ID
3666            * @param status the status
3667            * @param start the lower bound of the range of bookmarks entries
3668            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3669            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3670            * @return the ordered range of matching bookmarks entries that the user has permission to view
3671            * @throws SystemException if a system exception occurred
3672            */
3673            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3674                    long groupId, long userId, long folderId, int status, int start,
3675                    int end,
3676                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3677                    throws com.liferay.portal.kernel.exception.SystemException {
3678                    return getPersistence()
3679                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3680                            start, end, orderByComparator);
3681            }
3682    
3683            /**
3684            * 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;.
3685            *
3686            * @param entryId the primary key of the current bookmarks entry
3687            * @param groupId the group ID
3688            * @param userId the user ID
3689            * @param folderId the folder ID
3690            * @param status the status
3691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3692            * @return the previous, current, and next bookmarks entry
3693            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3694            * @throws SystemException if a system exception occurred
3695            */
3696            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext(
3697                    long entryId, long groupId, long userId, long folderId, int status,
3698                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3699                    throws com.liferay.portal.kernel.exception.SystemException,
3700                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3701                    return getPersistence()
3702                                       .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3703                            folderId, status, orderByComparator);
3704            }
3705    
3706            /**
3707            * 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;.
3708            *
3709            * @param groupId the group ID
3710            * @param userId the user ID
3711            * @param folderIds the folder IDs
3712            * @param status the status
3713            * @return the matching bookmarks entries that the user has permission to view
3714            * @throws SystemException if a system exception occurred
3715            */
3716            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3717                    long groupId, long userId, long[] folderIds, int status)
3718                    throws com.liferay.portal.kernel.exception.SystemException {
3719                    return getPersistence()
3720                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status);
3721            }
3722    
3723            /**
3724            * 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;.
3725            *
3726            * <p>
3727            * 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.
3728            * </p>
3729            *
3730            * @param groupId the group ID
3731            * @param userId the user ID
3732            * @param folderIds the folder IDs
3733            * @param status the status
3734            * @param start the lower bound of the range of bookmarks entries
3735            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3736            * @return the range of matching bookmarks entries that the user has permission to view
3737            * @throws SystemException if a system exception occurred
3738            */
3739            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3740                    long groupId, long userId, long[] folderIds, int status, int start,
3741                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3742                    return getPersistence()
3743                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3744                            start, end);
3745            }
3746    
3747            /**
3748            * 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;.
3749            *
3750            * <p>
3751            * 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.
3752            * </p>
3753            *
3754            * @param groupId the group ID
3755            * @param userId the user ID
3756            * @param folderIds the folder IDs
3757            * @param status the status
3758            * @param start the lower bound of the range of bookmarks entries
3759            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3760            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3761            * @return the ordered range of matching bookmarks entries that the user has permission to view
3762            * @throws SystemException if a system exception occurred
3763            */
3764            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3765                    long groupId, long userId, long[] folderIds, int status, int start,
3766                    int end,
3767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3768                    throws com.liferay.portal.kernel.exception.SystemException {
3769                    return getPersistence()
3770                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3771                            start, end, orderByComparator);
3772            }
3773    
3774            /**
3775            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3776            *
3777            * <p>
3778            * 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.
3779            * </p>
3780            *
3781            * @param groupId the group ID
3782            * @param userId the user ID
3783            * @param folderIds the folder IDs
3784            * @param status the status
3785            * @return the matching bookmarks entries
3786            * @throws SystemException if a system exception occurred
3787            */
3788            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3789                    long groupId, long userId, long[] folderIds, int status)
3790                    throws com.liferay.portal.kernel.exception.SystemException {
3791                    return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status);
3792            }
3793    
3794            /**
3795            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3796            *
3797            * <p>
3798            * 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.
3799            * </p>
3800            *
3801            * @param groupId the group ID
3802            * @param userId the user ID
3803            * @param folderIds the folder IDs
3804            * @param status the status
3805            * @param start the lower bound of the range of bookmarks entries
3806            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3807            * @return the range of matching bookmarks entries
3808            * @throws SystemException if a system exception occurred
3809            */
3810            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3811                    long groupId, long userId, long[] folderIds, int status, int start,
3812                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3813                    return getPersistence()
3814                                       .findByG_U_F_S(groupId, userId, folderIds, status, start, end);
3815            }
3816    
3817            /**
3818            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3819            *
3820            * <p>
3821            * 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.
3822            * </p>
3823            *
3824            * @param groupId the group ID
3825            * @param userId the user ID
3826            * @param folderIds the folder IDs
3827            * @param status the status
3828            * @param start the lower bound of the range of bookmarks entries
3829            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3830            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3831            * @return the ordered range of matching bookmarks entries
3832            * @throws SystemException if a system exception occurred
3833            */
3834            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3835                    long groupId, long userId, long[] folderIds, int status, int start,
3836                    int end,
3837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3838                    throws com.liferay.portal.kernel.exception.SystemException {
3839                    return getPersistence()
3840                                       .findByG_U_F_S(groupId, userId, folderIds, status, start,
3841                            end, orderByComparator);
3842            }
3843    
3844            /**
3845            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63; from the database.
3846            *
3847            * @param groupId the group ID
3848            * @param userId the user ID
3849            * @param folderId the folder ID
3850            * @param status the status
3851            * @throws SystemException if a system exception occurred
3852            */
3853            public static void removeByG_U_F_S(long groupId, long userId,
3854                    long folderId, int status)
3855                    throws com.liferay.portal.kernel.exception.SystemException {
3856                    getPersistence().removeByG_U_F_S(groupId, userId, folderId, status);
3857            }
3858    
3859            /**
3860            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3861            *
3862            * @param groupId the group ID
3863            * @param userId the user ID
3864            * @param folderId the folder ID
3865            * @param status the status
3866            * @return the number of matching bookmarks entries
3867            * @throws SystemException if a system exception occurred
3868            */
3869            public static int countByG_U_F_S(long groupId, long userId, long folderId,
3870                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3871                    return getPersistence().countByG_U_F_S(groupId, userId, folderId, status);
3872            }
3873    
3874            /**
3875            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3876            *
3877            * @param groupId the group ID
3878            * @param userId the user ID
3879            * @param folderIds the folder IDs
3880            * @param status the status
3881            * @return the number of matching bookmarks entries
3882            * @throws SystemException if a system exception occurred
3883            */
3884            public static int countByG_U_F_S(long groupId, long userId,
3885                    long[] folderIds, int status)
3886                    throws com.liferay.portal.kernel.exception.SystemException {
3887                    return getPersistence()
3888                                       .countByG_U_F_S(groupId, userId, folderIds, status);
3889            }
3890    
3891            /**
3892            * 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;.
3893            *
3894            * @param groupId the group ID
3895            * @param userId the user ID
3896            * @param folderId the folder ID
3897            * @param status the status
3898            * @return the number of matching bookmarks entries that the user has permission to view
3899            * @throws SystemException if a system exception occurred
3900            */
3901            public static int filterCountByG_U_F_S(long groupId, long userId,
3902                    long folderId, int status)
3903                    throws com.liferay.portal.kernel.exception.SystemException {
3904                    return getPersistence()
3905                                       .filterCountByG_U_F_S(groupId, userId, folderId, status);
3906            }
3907    
3908            /**
3909            * 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;.
3910            *
3911            * @param groupId the group ID
3912            * @param userId the user ID
3913            * @param folderIds the folder IDs
3914            * @param status the status
3915            * @return the number of matching bookmarks entries that the user has permission to view
3916            * @throws SystemException if a system exception occurred
3917            */
3918            public static int filterCountByG_U_F_S(long groupId, long userId,
3919                    long[] folderIds, int status)
3920                    throws com.liferay.portal.kernel.exception.SystemException {
3921                    return getPersistence()
3922                                       .filterCountByG_U_F_S(groupId, userId, folderIds, status);
3923            }
3924    
3925            /**
3926            * Caches the bookmarks entry in the entity cache if it is enabled.
3927            *
3928            * @param bookmarksEntry the bookmarks entry
3929            */
3930            public static void cacheResult(
3931                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
3932                    getPersistence().cacheResult(bookmarksEntry);
3933            }
3934    
3935            /**
3936            * Caches the bookmarks entries in the entity cache if it is enabled.
3937            *
3938            * @param bookmarksEntries the bookmarks entries
3939            */
3940            public static void cacheResult(
3941                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
3942                    getPersistence().cacheResult(bookmarksEntries);
3943            }
3944    
3945            /**
3946            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
3947            *
3948            * @param entryId the primary key for the new bookmarks entry
3949            * @return the new bookmarks entry
3950            */
3951            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
3952                    long entryId) {
3953                    return getPersistence().create(entryId);
3954            }
3955    
3956            /**
3957            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
3958            *
3959            * @param entryId the primary key of the bookmarks entry
3960            * @return the bookmarks entry that was removed
3961            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3962            * @throws SystemException if a system exception occurred
3963            */
3964            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
3965                    long entryId)
3966                    throws com.liferay.portal.kernel.exception.SystemException,
3967                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3968                    return getPersistence().remove(entryId);
3969            }
3970    
3971            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
3972                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry)
3973                    throws com.liferay.portal.kernel.exception.SystemException {
3974                    return getPersistence().updateImpl(bookmarksEntry);
3975            }
3976    
3977            /**
3978            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
3979            *
3980            * @param entryId the primary key of the bookmarks entry
3981            * @return the bookmarks entry
3982            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3983            * @throws SystemException if a system exception occurred
3984            */
3985            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
3986                    long entryId)
3987                    throws com.liferay.portal.kernel.exception.SystemException,
3988                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3989                    return getPersistence().findByPrimaryKey(entryId);
3990            }
3991    
3992            /**
3993            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
3994            *
3995            * @param entryId the primary key of the bookmarks entry
3996            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
3997            * @throws SystemException if a system exception occurred
3998            */
3999            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
4000                    long entryId)
4001                    throws com.liferay.portal.kernel.exception.SystemException {
4002                    return getPersistence().fetchByPrimaryKey(entryId);
4003            }
4004    
4005            /**
4006            * Returns all the bookmarks entries.
4007            *
4008            * @return the bookmarks entries
4009            * @throws SystemException if a system exception occurred
4010            */
4011            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
4012                    throws com.liferay.portal.kernel.exception.SystemException {
4013                    return getPersistence().findAll();
4014            }
4015    
4016            /**
4017            * Returns a range of all the bookmarks entries.
4018            *
4019            * <p>
4020            * 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.
4021            * </p>
4022            *
4023            * @param start the lower bound of the range of bookmarks entries
4024            * @param end the upper bound of the range of bookmarks entries (not inclusive)
4025            * @return the range of bookmarks entries
4026            * @throws SystemException if a system exception occurred
4027            */
4028            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
4029                    int start, int end)
4030                    throws com.liferay.portal.kernel.exception.SystemException {
4031                    return getPersistence().findAll(start, end);
4032            }
4033    
4034            /**
4035            * Returns an ordered range of all the bookmarks entries.
4036            *
4037            * <p>
4038            * 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.
4039            * </p>
4040            *
4041            * @param start the lower bound of the range of bookmarks entries
4042            * @param end the upper bound of the range of bookmarks entries (not inclusive)
4043            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4044            * @return the ordered range of bookmarks entries
4045            * @throws SystemException if a system exception occurred
4046            */
4047            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
4048                    int start, int end,
4049                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4050                    throws com.liferay.portal.kernel.exception.SystemException {
4051                    return getPersistence().findAll(start, end, orderByComparator);
4052            }
4053    
4054            /**
4055            * Removes all the bookmarks entries from the database.
4056            *
4057            * @throws SystemException if a system exception occurred
4058            */
4059            public static void removeAll()
4060                    throws com.liferay.portal.kernel.exception.SystemException {
4061                    getPersistence().removeAll();
4062            }
4063    
4064            /**
4065            * Returns the number of bookmarks entries.
4066            *
4067            * @return the number of bookmarks entries
4068            * @throws SystemException if a system exception occurred
4069            */
4070            public static int countAll()
4071                    throws com.liferay.portal.kernel.exception.SystemException {
4072                    return getPersistence().countAll();
4073            }
4074    
4075            public static BookmarksEntryPersistence getPersistence() {
4076                    if (_persistence == null) {
4077                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
4078    
4079                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
4080                                    "_persistence");
4081                    }
4082    
4083                    return _persistence;
4084            }
4085    
4086            /**
4087             * @deprecated As of 6.2.0
4088             */
4089            public void setPersistence(BookmarksEntryPersistence persistence) {
4090            }
4091    
4092            private static BookmarksEntryPersistence _persistence;
4093    }