001    /**
002     * Copyright (c) 2000-present 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 aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
026    
027    import java.util.List;
028    
029    /**
030     * 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see BookmarksEntryPersistence
038     * @see BookmarksEntryPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class BookmarksEntryUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(BookmarksEntry bookmarksEntry) {
060                    getPersistence().clearCache(bookmarksEntry);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<BookmarksEntry> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<BookmarksEntry> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
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<BookmarksEntry> orderByComparator) {
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                    return getPersistence().update(bookmarksEntry);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(bookmarksEntry, serviceContext);
110            }
111    
112            /**
113            * Returns all the bookmarks entries where resourceBlockId = &#63;.
114            *
115            * @param resourceBlockId the resource block ID
116            * @return the matching bookmarks entries
117            */
118            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
119                    long resourceBlockId) {
120                    return getPersistence().findByResourceBlockId(resourceBlockId);
121            }
122    
123            /**
124            * Returns a range of all the bookmarks entries where resourceBlockId = &#63;.
125            *
126            * <p>
127            * 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.
128            * </p>
129            *
130            * @param resourceBlockId the resource block ID
131            * @param start the lower bound of the range of bookmarks entries
132            * @param end the upper bound of the range of bookmarks entries (not inclusive)
133            * @return the range of matching bookmarks entries
134            */
135            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
136                    long resourceBlockId, int start, int end) {
137                    return getPersistence()
138                                       .findByResourceBlockId(resourceBlockId, start, end);
139            }
140    
141            /**
142            * Returns an ordered range of all the bookmarks entries where resourceBlockId = &#63;.
143            *
144            * <p>
145            * 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.
146            * </p>
147            *
148            * @param resourceBlockId the resource block ID
149            * @param start the lower bound of the range of bookmarks entries
150            * @param end the upper bound of the range of bookmarks entries (not inclusive)
151            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
152            * @return the ordered range of matching bookmarks entries
153            */
154            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
155                    long resourceBlockId, int start, int end,
156                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
157                    return getPersistence()
158                                       .findByResourceBlockId(resourceBlockId, start, end,
159                            orderByComparator);
160            }
161    
162            /**
163            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
164            *
165            * @param resourceBlockId the resource block ID
166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
167            * @return the first matching bookmarks entry
168            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
169            */
170            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First(
171                    long resourceBlockId,
172                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
173                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
174                    return getPersistence()
175                                       .findByResourceBlockId_First(resourceBlockId,
176                            orderByComparator);
177            }
178    
179            /**
180            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
181            *
182            * @param resourceBlockId the resource block ID
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
185            */
186            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First(
187                    long resourceBlockId,
188                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
189                    return getPersistence()
190                                       .fetchByResourceBlockId_First(resourceBlockId,
191                            orderByComparator);
192            }
193    
194            /**
195            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
196            *
197            * @param resourceBlockId the resource block ID
198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
199            * @return the last matching bookmarks entry
200            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
201            */
202            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last(
203                    long resourceBlockId,
204                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
205                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
206                    return getPersistence()
207                                       .findByResourceBlockId_Last(resourceBlockId,
208                            orderByComparator);
209            }
210    
211            /**
212            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
213            *
214            * @param resourceBlockId the resource block ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
217            */
218            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last(
219                    long resourceBlockId,
220                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
221                    return getPersistence()
222                                       .fetchByResourceBlockId_Last(resourceBlockId,
223                            orderByComparator);
224            }
225    
226            /**
227            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = &#63;.
228            *
229            * @param entryId the primary key of the current bookmarks entry
230            * @param resourceBlockId the resource block ID
231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
232            * @return the previous, current, and next bookmarks entry
233            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
234            */
235            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext(
236                    long entryId, long resourceBlockId,
237                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
238                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
239                    return getPersistence()
240                                       .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId,
241                            orderByComparator);
242            }
243    
244            /**
245            * Removes all the bookmarks entries where resourceBlockId = &#63; from the database.
246            *
247            * @param resourceBlockId the resource block ID
248            */
249            public static void removeByResourceBlockId(long resourceBlockId) {
250                    getPersistence().removeByResourceBlockId(resourceBlockId);
251            }
252    
253            /**
254            * Returns the number of bookmarks entries where resourceBlockId = &#63;.
255            *
256            * @param resourceBlockId the resource block ID
257            * @return the number of matching bookmarks entries
258            */
259            public static int countByResourceBlockId(long resourceBlockId) {
260                    return getPersistence().countByResourceBlockId(resourceBlockId);
261            }
262    
263            /**
264            * Returns all the bookmarks entries where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @return the matching bookmarks entries
268            */
269            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
270                    java.lang.String uuid) {
271                    return getPersistence().findByUuid(uuid);
272            }
273    
274            /**
275            * Returns a range of all the bookmarks entries where uuid = &#63;.
276            *
277            * <p>
278            * 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.
279            * </p>
280            *
281            * @param uuid the uuid
282            * @param start the lower bound of the range of bookmarks entries
283            * @param end the upper bound of the range of bookmarks entries (not inclusive)
284            * @return the range of matching bookmarks entries
285            */
286            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
287                    java.lang.String uuid, int start, int end) {
288                    return getPersistence().findByUuid(uuid, start, end);
289            }
290    
291            /**
292            * Returns an ordered range of all the bookmarks entries where uuid = &#63;.
293            *
294            * <p>
295            * 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.
296            * </p>
297            *
298            * @param uuid the uuid
299            * @param start the lower bound of the range of bookmarks entries
300            * @param end the upper bound of the range of bookmarks entries (not inclusive)
301            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
302            * @return the ordered range of matching bookmarks entries
303            */
304            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
305                    java.lang.String uuid, int start, int end,
306                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
307                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
308            }
309    
310            /**
311            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
312            *
313            * @param uuid the uuid
314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
315            * @return the first matching bookmarks entry
316            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
317            */
318            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First(
319                    java.lang.String uuid,
320                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
321                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
322                    return getPersistence().findByUuid_First(uuid, orderByComparator);
323            }
324    
325            /**
326            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
327            *
328            * @param uuid the uuid
329            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
330            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
331            */
332            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First(
333                    java.lang.String uuid,
334                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
335                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
336            }
337    
338            /**
339            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
340            *
341            * @param uuid the uuid
342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
343            * @return the last matching bookmarks entry
344            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
345            */
346            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last(
347                    java.lang.String uuid,
348                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
349                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
350                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
351            }
352    
353            /**
354            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
355            *
356            * @param uuid the uuid
357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
358            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
359            */
360            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last(
361                    java.lang.String uuid,
362                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
363                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
364            }
365    
366            /**
367            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63;.
368            *
369            * @param entryId the primary key of the current bookmarks entry
370            * @param uuid the uuid
371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
372            * @return the previous, current, and next bookmarks entry
373            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
374            */
375            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext(
376                    long entryId, java.lang.String uuid,
377                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
378                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
379                    return getPersistence()
380                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
381            }
382    
383            /**
384            * Removes all the bookmarks entries where uuid = &#63; from the database.
385            *
386            * @param uuid the uuid
387            */
388            public static void removeByUuid(java.lang.String uuid) {
389                    getPersistence().removeByUuid(uuid);
390            }
391    
392            /**
393            * Returns the number of bookmarks entries where uuid = &#63;.
394            *
395            * @param uuid the uuid
396            * @return the number of matching bookmarks entries
397            */
398            public static int countByUuid(java.lang.String uuid) {
399                    return getPersistence().countByUuid(uuid);
400            }
401    
402            /**
403            * 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.
404            *
405            * @param uuid the uuid
406            * @param groupId the group ID
407            * @return the matching bookmarks entry
408            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
409            */
410            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G(
411                    java.lang.String uuid, long groupId)
412                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
413                    return getPersistence().findByUUID_G(uuid, groupId);
414            }
415    
416            /**
417            * 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.
418            *
419            * @param uuid the uuid
420            * @param groupId the group ID
421            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
422            */
423            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
424                    java.lang.String uuid, long groupId) {
425                    return getPersistence().fetchByUUID_G(uuid, groupId);
426            }
427    
428            /**
429            * 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.
430            *
431            * @param uuid the uuid
432            * @param groupId the group ID
433            * @param retrieveFromCache whether to use the finder cache
434            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
435            */
436            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
437                    java.lang.String uuid, long groupId, boolean retrieveFromCache) {
438                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
439            }
440    
441            /**
442            * Removes the bookmarks entry where uuid = &#63; and groupId = &#63; from the database.
443            *
444            * @param uuid the uuid
445            * @param groupId the group ID
446            * @return the bookmarks entry that was removed
447            */
448            public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G(
449                    java.lang.String uuid, long groupId)
450                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
451                    return getPersistence().removeByUUID_G(uuid, groupId);
452            }
453    
454            /**
455            * Returns the number of bookmarks entries where uuid = &#63; and groupId = &#63;.
456            *
457            * @param uuid the uuid
458            * @param groupId the group ID
459            * @return the number of matching bookmarks entries
460            */
461            public static int countByUUID_G(java.lang.String uuid, long groupId) {
462                    return getPersistence().countByUUID_G(uuid, groupId);
463            }
464    
465            /**
466            * Returns all the bookmarks entries where uuid = &#63; and companyId = &#63;.
467            *
468            * @param uuid the uuid
469            * @param companyId the company ID
470            * @return the matching bookmarks entries
471            */
472            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
473                    java.lang.String uuid, long companyId) {
474                    return getPersistence().findByUuid_C(uuid, companyId);
475            }
476    
477            /**
478            * Returns a range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
479            *
480            * <p>
481            * 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.
482            * </p>
483            *
484            * @param uuid the uuid
485            * @param companyId the company ID
486            * @param start the lower bound of the range of bookmarks entries
487            * @param end the upper bound of the range of bookmarks entries (not inclusive)
488            * @return the range of matching bookmarks entries
489            */
490            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
491                    java.lang.String uuid, long companyId, int start, int end) {
492                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
493            }
494    
495            /**
496            * Returns an ordered range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
497            *
498            * <p>
499            * 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.
500            * </p>
501            *
502            * @param uuid the uuid
503            * @param companyId the company ID
504            * @param start the lower bound of the range of bookmarks entries
505            * @param end the upper bound of the range of bookmarks entries (not inclusive)
506            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
507            * @return the ordered range of matching bookmarks entries
508            */
509            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
510                    java.lang.String uuid, long companyId, int start, int end,
511                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
512                    return getPersistence()
513                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
514            }
515    
516            /**
517            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
522            * @return the first matching bookmarks entry
523            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
524            */
525            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First(
526                    java.lang.String uuid, long companyId,
527                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
528                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
529                    return getPersistence()
530                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
531            }
532    
533            /**
534            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
535            *
536            * @param uuid the uuid
537            * @param companyId the company ID
538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
539            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
540            */
541            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First(
542                    java.lang.String uuid, long companyId,
543                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
544                    return getPersistence()
545                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
546            }
547    
548            /**
549            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
550            *
551            * @param uuid the uuid
552            * @param companyId the company ID
553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
554            * @return the last matching bookmarks entry
555            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
556            */
557            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last(
558                    java.lang.String uuid, long companyId,
559                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
560                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
561                    return getPersistence()
562                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
563            }
564    
565            /**
566            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
567            *
568            * @param uuid the uuid
569            * @param companyId the company ID
570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
571            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
572            */
573            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last(
574                    java.lang.String uuid, long companyId,
575                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
576                    return getPersistence()
577                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
578            }
579    
580            /**
581            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
582            *
583            * @param entryId the primary key of the current bookmarks entry
584            * @param uuid the uuid
585            * @param companyId the company ID
586            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
587            * @return the previous, current, and next bookmarks entry
588            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
589            */
590            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext(
591                    long entryId, java.lang.String uuid, long companyId,
592                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
593                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
594                    return getPersistence()
595                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
596                            orderByComparator);
597            }
598    
599            /**
600            * Removes all the bookmarks entries where uuid = &#63; and companyId = &#63; from the database.
601            *
602            * @param uuid the uuid
603            * @param companyId the company ID
604            */
605            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
606                    getPersistence().removeByUuid_C(uuid, companyId);
607            }
608    
609            /**
610            * Returns the number of bookmarks entries where uuid = &#63; and companyId = &#63;.
611            *
612            * @param uuid the uuid
613            * @param companyId the company ID
614            * @return the number of matching bookmarks entries
615            */
616            public static int countByUuid_C(java.lang.String uuid, long companyId) {
617                    return getPersistence().countByUuid_C(uuid, companyId);
618            }
619    
620            /**
621            * Returns all the bookmarks entries where companyId = &#63;.
622            *
623            * @param companyId the company ID
624            * @return the matching bookmarks entries
625            */
626            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
627                    long companyId) {
628                    return getPersistence().findByCompanyId(companyId);
629            }
630    
631            /**
632            * Returns a range of all the bookmarks entries where companyId = &#63;.
633            *
634            * <p>
635            * 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.
636            * </p>
637            *
638            * @param companyId the company ID
639            * @param start the lower bound of the range of bookmarks entries
640            * @param end the upper bound of the range of bookmarks entries (not inclusive)
641            * @return the range of matching bookmarks entries
642            */
643            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
644                    long companyId, int start, int end) {
645                    return getPersistence().findByCompanyId(companyId, start, end);
646            }
647    
648            /**
649            * Returns an ordered range of all the bookmarks entries where companyId = &#63;.
650            *
651            * <p>
652            * 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.
653            * </p>
654            *
655            * @param companyId the company ID
656            * @param start the lower bound of the range of bookmarks entries
657            * @param end the upper bound of the range of bookmarks entries (not inclusive)
658            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
659            * @return the ordered range of matching bookmarks entries
660            */
661            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByCompanyId(
662                    long companyId, int start, int end,
663                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
664                    return getPersistence()
665                                       .findByCompanyId(companyId, start, end, orderByComparator);
666            }
667    
668            /**
669            * Returns the first bookmarks entry in the ordered set where companyId = &#63;.
670            *
671            * @param companyId the company ID
672            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
673            * @return the first matching bookmarks entry
674            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
675            */
676            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_First(
677                    long companyId,
678                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
679                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
680                    return getPersistence()
681                                       .findByCompanyId_First(companyId, orderByComparator);
682            }
683    
684            /**
685            * Returns the first bookmarks entry in the ordered set where companyId = &#63;.
686            *
687            * @param companyId the company ID
688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
689            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
690            */
691            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_First(
692                    long companyId,
693                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
694                    return getPersistence()
695                                       .fetchByCompanyId_First(companyId, orderByComparator);
696            }
697    
698            /**
699            * Returns the last bookmarks entry in the ordered set where companyId = &#63;.
700            *
701            * @param companyId the company ID
702            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
703            * @return the last matching bookmarks entry
704            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
705            */
706            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByCompanyId_Last(
707                    long companyId,
708                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
709                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
710                    return getPersistence()
711                                       .findByCompanyId_Last(companyId, orderByComparator);
712            }
713    
714            /**
715            * Returns the last bookmarks entry in the ordered set where companyId = &#63;.
716            *
717            * @param companyId the company ID
718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
719            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
720            */
721            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByCompanyId_Last(
722                    long companyId,
723                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
724                    return getPersistence()
725                                       .fetchByCompanyId_Last(companyId, orderByComparator);
726            }
727    
728            /**
729            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = &#63;.
730            *
731            * @param entryId the primary key of the current bookmarks entry
732            * @param companyId the company ID
733            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
734            * @return the previous, current, and next bookmarks entry
735            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
736            */
737            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByCompanyId_PrevAndNext(
738                    long entryId, long companyId,
739                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
740                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
741                    return getPersistence()
742                                       .findByCompanyId_PrevAndNext(entryId, companyId,
743                            orderByComparator);
744            }
745    
746            /**
747            * Removes all the bookmarks entries where companyId = &#63; from the database.
748            *
749            * @param companyId the company ID
750            */
751            public static void removeByCompanyId(long companyId) {
752                    getPersistence().removeByCompanyId(companyId);
753            }
754    
755            /**
756            * Returns the number of bookmarks entries where companyId = &#63;.
757            *
758            * @param companyId the company ID
759            * @return the number of matching bookmarks entries
760            */
761            public static int countByCompanyId(long companyId) {
762                    return getPersistence().countByCompanyId(companyId);
763            }
764    
765            /**
766            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63;.
767            *
768            * @param groupId the group ID
769            * @param folderId the folder ID
770            * @return the matching bookmarks entries
771            */
772            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
773                    long groupId, long folderId) {
774                    return getPersistence().findByG_F(groupId, folderId);
775            }
776    
777            /**
778            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
779            *
780            * <p>
781            * 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.
782            * </p>
783            *
784            * @param groupId the group ID
785            * @param folderId the folder ID
786            * @param start the lower bound of the range of bookmarks entries
787            * @param end the upper bound of the range of bookmarks entries (not inclusive)
788            * @return the range of matching bookmarks entries
789            */
790            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
791                    long groupId, long folderId, int start, int end) {
792                    return getPersistence().findByG_F(groupId, folderId, start, end);
793            }
794    
795            /**
796            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
797            *
798            * <p>
799            * 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.
800            * </p>
801            *
802            * @param groupId the group ID
803            * @param folderId the folder ID
804            * @param start the lower bound of the range of bookmarks entries
805            * @param end the upper bound of the range of bookmarks entries (not inclusive)
806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
807            * @return the ordered range of matching bookmarks entries
808            */
809            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
810                    long groupId, long folderId, int start, int end,
811                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
812                    return getPersistence()
813                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
814            }
815    
816            /**
817            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
818            *
819            * @param groupId the group ID
820            * @param folderId the folder ID
821            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
822            * @return the first matching bookmarks entry
823            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
824            */
825            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
826                    long groupId, long folderId,
827                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
828                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
829                    return getPersistence()
830                                       .findByG_F_First(groupId, folderId, orderByComparator);
831            }
832    
833            /**
834            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
835            *
836            * @param groupId the group ID
837            * @param folderId the folder ID
838            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
839            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
840            */
841            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First(
842                    long groupId, long folderId,
843                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
844                    return getPersistence()
845                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
846            }
847    
848            /**
849            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
850            *
851            * @param groupId the group ID
852            * @param folderId the folder ID
853            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
854            * @return the last matching bookmarks entry
855            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
856            */
857            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
858                    long groupId, long folderId,
859                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
860                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
861                    return getPersistence()
862                                       .findByG_F_Last(groupId, folderId, orderByComparator);
863            }
864    
865            /**
866            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
867            *
868            * @param groupId the group ID
869            * @param folderId the folder ID
870            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
871            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
872            */
873            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last(
874                    long groupId, long folderId,
875                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
876                    return getPersistence()
877                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
878            }
879    
880            /**
881            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
882            *
883            * @param entryId the primary key of the current bookmarks entry
884            * @param groupId the group ID
885            * @param folderId the folder ID
886            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
887            * @return the previous, current, and next bookmarks entry
888            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
889            */
890            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
891                    long entryId, long groupId, long folderId,
892                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
893                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
894                    return getPersistence()
895                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
896                            orderByComparator);
897            }
898    
899            /**
900            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
901            *
902            * @param groupId the group ID
903            * @param folderId the folder ID
904            * @return the matching bookmarks entries that the user has permission to view
905            */
906            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
907                    long groupId, long folderId) {
908                    return getPersistence().filterFindByG_F(groupId, folderId);
909            }
910    
911            /**
912            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
913            *
914            * <p>
915            * 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.
916            * </p>
917            *
918            * @param groupId the group ID
919            * @param folderId the folder ID
920            * @param start the lower bound of the range of bookmarks entries
921            * @param end the upper bound of the range of bookmarks entries (not inclusive)
922            * @return the range of matching bookmarks entries that the user has permission to view
923            */
924            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
925                    long groupId, long folderId, int start, int end) {
926                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
927            }
928    
929            /**
930            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
931            *
932            * <p>
933            * 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.
934            * </p>
935            *
936            * @param groupId the group ID
937            * @param folderId the folder ID
938            * @param start the lower bound of the range of bookmarks entries
939            * @param end the upper bound of the range of bookmarks entries (not inclusive)
940            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
941            * @return the ordered range of matching bookmarks entries that the user has permission to view
942            */
943            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
944                    long groupId, long folderId, int start, int end,
945                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
946                    return getPersistence()
947                                       .filterFindByG_F(groupId, folderId, start, end,
948                            orderByComparator);
949            }
950    
951            /**
952            * 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;.
953            *
954            * @param entryId the primary key of the current bookmarks entry
955            * @param groupId the group ID
956            * @param folderId the folder ID
957            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
958            * @return the previous, current, and next bookmarks entry
959            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
960            */
961            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
962                    long entryId, long groupId, long folderId,
963                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
964                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
965                    return getPersistence()
966                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
967                            orderByComparator);
968            }
969    
970            /**
971            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
972            *
973            * @param groupId the group ID
974            * @param folderIds the folder IDs
975            * @return the matching bookmarks entries that the user has permission to view
976            */
977            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
978                    long groupId, long[] folderIds) {
979                    return getPersistence().filterFindByG_F(groupId, folderIds);
980            }
981    
982            /**
983            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
984            *
985            * <p>
986            * 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.
987            * </p>
988            *
989            * @param groupId the group ID
990            * @param folderIds the folder IDs
991            * @param start the lower bound of the range of bookmarks entries
992            * @param end the upper bound of the range of bookmarks entries (not inclusive)
993            * @return the range of matching bookmarks entries that the user has permission to view
994            */
995            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
996                    long groupId, long[] folderIds, int start, int end) {
997                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
998            }
999    
1000            /**
1001            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1002            *
1003            * <p>
1004            * 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.
1005            * </p>
1006            *
1007            * @param groupId the group ID
1008            * @param folderIds the folder IDs
1009            * @param start the lower bound of the range of bookmarks entries
1010            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1011            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1012            * @return the ordered range of matching bookmarks entries that the user has permission to view
1013            */
1014            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1015                    long groupId, long[] folderIds, int start, int end,
1016                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1017                    return getPersistence()
1018                                       .filterFindByG_F(groupId, folderIds, start, end,
1019                            orderByComparator);
1020            }
1021    
1022            /**
1023            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1024            *
1025            * <p>
1026            * 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.
1027            * </p>
1028            *
1029            * @param groupId the group ID
1030            * @param folderIds the folder IDs
1031            * @return the matching bookmarks entries
1032            */
1033            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1034                    long groupId, long[] folderIds) {
1035                    return getPersistence().findByG_F(groupId, folderIds);
1036            }
1037    
1038            /**
1039            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1040            *
1041            * <p>
1042            * 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.
1043            * </p>
1044            *
1045            * @param groupId the group ID
1046            * @param folderIds the folder IDs
1047            * @param start the lower bound of the range of bookmarks entries
1048            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1049            * @return the range of matching bookmarks entries
1050            */
1051            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1052                    long groupId, long[] folderIds, int start, int end) {
1053                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1054            }
1055    
1056            /**
1057            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1058            *
1059            * <p>
1060            * 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.
1061            * </p>
1062            *
1063            * @param groupId the group ID
1064            * @param folderIds the folder IDs
1065            * @param start the lower bound of the range of bookmarks entries
1066            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1067            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1068            * @return the ordered range of matching bookmarks entries
1069            */
1070            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1071                    long groupId, long[] folderIds, int start, int end,
1072                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1073                    return getPersistence()
1074                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1075            }
1076    
1077            /**
1078            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1079            *
1080            * @param groupId the group ID
1081            * @param folderId the folder ID
1082            */
1083            public static void removeByG_F(long groupId, long folderId) {
1084                    getPersistence().removeByG_F(groupId, folderId);
1085            }
1086    
1087            /**
1088            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63;.
1089            *
1090            * @param groupId the group ID
1091            * @param folderId the folder ID
1092            * @return the number of matching bookmarks entries
1093            */
1094            public static int countByG_F(long groupId, long folderId) {
1095                    return getPersistence().countByG_F(groupId, folderId);
1096            }
1097    
1098            /**
1099            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63;.
1100            *
1101            * @param groupId the group ID
1102            * @param folderIds the folder IDs
1103            * @return the number of matching bookmarks entries
1104            */
1105            public static int countByG_F(long groupId, long[] folderIds) {
1106                    return getPersistence().countByG_F(groupId, folderIds);
1107            }
1108    
1109            /**
1110            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1111            *
1112            * @param groupId the group ID
1113            * @param folderId the folder ID
1114            * @return the number of matching bookmarks entries that the user has permission to view
1115            */
1116            public static int filterCountByG_F(long groupId, long folderId) {
1117                    return getPersistence().filterCountByG_F(groupId, folderId);
1118            }
1119    
1120            /**
1121            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1122            *
1123            * @param groupId the group ID
1124            * @param folderIds the folder IDs
1125            * @return the number of matching bookmarks entries that the user has permission to view
1126            */
1127            public static int filterCountByG_F(long groupId, long[] folderIds) {
1128                    return getPersistence().filterCountByG_F(groupId, folderIds);
1129            }
1130    
1131            /**
1132            * Returns all the bookmarks entries where groupId = &#63; and status = &#63;.
1133            *
1134            * @param groupId the group ID
1135            * @param status the status
1136            * @return the matching bookmarks entries
1137            */
1138            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1139                    long groupId, int status) {
1140                    return getPersistence().findByG_S(groupId, status);
1141            }
1142    
1143            /**
1144            * Returns a range of all the bookmarks entries where groupId = &#63; and status = &#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 status the status
1152            * @param start the lower bound of the range of bookmarks entries
1153            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1154            * @return the range of matching bookmarks entries
1155            */
1156            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1157                    long groupId, int status, int start, int end) {
1158                    return getPersistence().findByG_S(groupId, status, start, end);
1159            }
1160    
1161            /**
1162            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and status = &#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 status the status
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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1173            * @return the ordered range of matching bookmarks entries
1174            */
1175            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1176                    long groupId, int status, int start, int end,
1177                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1178                    return getPersistence()
1179                                       .findByG_S(groupId, status, start, end, orderByComparator);
1180            }
1181    
1182            /**
1183            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1184            *
1185            * @param groupId the group ID
1186            * @param status the status
1187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1188            * @return the first matching bookmarks entry
1189            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1190            */
1191            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First(
1192                    long groupId, int status,
1193                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1194                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1195                    return getPersistence()
1196                                       .findByG_S_First(groupId, status, orderByComparator);
1197            }
1198    
1199            /**
1200            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1201            *
1202            * @param groupId the group ID
1203            * @param status the status
1204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1205            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1206            */
1207            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First(
1208                    long groupId, int status,
1209                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1210                    return getPersistence()
1211                                       .fetchByG_S_First(groupId, status, orderByComparator);
1212            }
1213    
1214            /**
1215            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1216            *
1217            * @param groupId the group ID
1218            * @param status the status
1219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1220            * @return the last matching bookmarks entry
1221            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1222            */
1223            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last(
1224                    long groupId, int status,
1225                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1226                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1227                    return getPersistence()
1228                                       .findByG_S_Last(groupId, status, orderByComparator);
1229            }
1230    
1231            /**
1232            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1233            *
1234            * @param groupId the group ID
1235            * @param status the status
1236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1237            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1238            */
1239            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last(
1240                    long groupId, int status,
1241                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1242                    return getPersistence()
1243                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1244            }
1245    
1246            /**
1247            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1248            *
1249            * @param entryId the primary key of the current bookmarks entry
1250            * @param groupId the group ID
1251            * @param status the status
1252            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1253            * @return the previous, current, and next bookmarks entry
1254            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1255            */
1256            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext(
1257                    long entryId, long groupId, int status,
1258                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1259                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1260                    return getPersistence()
1261                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1262                            orderByComparator);
1263            }
1264    
1265            /**
1266            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1267            *
1268            * @param groupId the group ID
1269            * @param status the status
1270            * @return the matching bookmarks entries that the user has permission to view
1271            */
1272            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1273                    long groupId, int status) {
1274                    return getPersistence().filterFindByG_S(groupId, status);
1275            }
1276    
1277            /**
1278            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1279            *
1280            * <p>
1281            * 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.
1282            * </p>
1283            *
1284            * @param groupId the group ID
1285            * @param status the status
1286            * @param start the lower bound of the range of bookmarks entries
1287            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1288            * @return the range of matching bookmarks entries that the user has permission to view
1289            */
1290            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1291                    long groupId, int status, int start, int end) {
1292                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1293            }
1294    
1295            /**
1296            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status = &#63;.
1297            *
1298            * <p>
1299            * 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.
1300            * </p>
1301            *
1302            * @param groupId the group ID
1303            * @param status the status
1304            * @param start the lower bound of the range of bookmarks entries
1305            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1306            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1307            * @return the ordered range of matching bookmarks entries that the user has permission to view
1308            */
1309            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1310                    long groupId, int status, int start, int end,
1311                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1312                    return getPersistence()
1313                                       .filterFindByG_S(groupId, status, start, end,
1314                            orderByComparator);
1315            }
1316    
1317            /**
1318            * 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;.
1319            *
1320            * @param entryId the primary key of the current bookmarks entry
1321            * @param groupId the group ID
1322            * @param status the status
1323            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1324            * @return the previous, current, and next bookmarks entry
1325            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1326            */
1327            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext(
1328                    long entryId, long groupId, int status,
1329                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1330                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1331                    return getPersistence()
1332                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
1333                            orderByComparator);
1334            }
1335    
1336            /**
1337            * Removes all the bookmarks entries where groupId = &#63; and status = &#63; from the database.
1338            *
1339            * @param groupId the group ID
1340            * @param status the status
1341            */
1342            public static void removeByG_S(long groupId, int status) {
1343                    getPersistence().removeByG_S(groupId, status);
1344            }
1345    
1346            /**
1347            * Returns the number of bookmarks entries where groupId = &#63; and status = &#63;.
1348            *
1349            * @param groupId the group ID
1350            * @param status the status
1351            * @return the number of matching bookmarks entries
1352            */
1353            public static int countByG_S(long groupId, int status) {
1354                    return getPersistence().countByG_S(groupId, status);
1355            }
1356    
1357            /**
1358            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1359            *
1360            * @param groupId the group ID
1361            * @param status the status
1362            * @return the number of matching bookmarks entries that the user has permission to view
1363            */
1364            public static int filterCountByG_S(long groupId, int status) {
1365                    return getPersistence().filterCountByG_S(groupId, status);
1366            }
1367    
1368            /**
1369            * Returns all the bookmarks entries where groupId = &#63; and status &ne; &#63;.
1370            *
1371            * @param groupId the group ID
1372            * @param status the status
1373            * @return the matching bookmarks entries
1374            */
1375            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS(
1376                    long groupId, int status) {
1377                    return getPersistence().findByG_NotS(groupId, status);
1378            }
1379    
1380            /**
1381            * Returns a range of all the bookmarks entries where groupId = &#63; and status &ne; &#63;.
1382            *
1383            * <p>
1384            * 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.
1385            * </p>
1386            *
1387            * @param groupId the group ID
1388            * @param status the status
1389            * @param start the lower bound of the range of bookmarks entries
1390            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1391            * @return the range of matching bookmarks entries
1392            */
1393            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS(
1394                    long groupId, int status, int start, int end) {
1395                    return getPersistence().findByG_NotS(groupId, status, start, end);
1396            }
1397    
1398            /**
1399            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and status &ne; &#63;.
1400            *
1401            * <p>
1402            * 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.
1403            * </p>
1404            *
1405            * @param groupId the group ID
1406            * @param status the status
1407            * @param start the lower bound of the range of bookmarks entries
1408            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1409            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1410            * @return the ordered range of matching bookmarks entries
1411            */
1412            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_NotS(
1413                    long groupId, int status, int start, int end,
1414                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1415                    return getPersistence()
1416                                       .findByG_NotS(groupId, status, start, end, orderByComparator);
1417            }
1418    
1419            /**
1420            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1421            *
1422            * @param groupId the group ID
1423            * @param status the status
1424            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1425            * @return the first matching bookmarks entry
1426            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1427            */
1428            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_First(
1429                    long groupId, int status,
1430                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1431                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1432                    return getPersistence()
1433                                       .findByG_NotS_First(groupId, status, orderByComparator);
1434            }
1435    
1436            /**
1437            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1438            *
1439            * @param groupId the group ID
1440            * @param status the status
1441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1442            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1443            */
1444            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_First(
1445                    long groupId, int status,
1446                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1447                    return getPersistence()
1448                                       .fetchByG_NotS_First(groupId, status, orderByComparator);
1449            }
1450    
1451            /**
1452            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1453            *
1454            * @param groupId the group ID
1455            * @param status the status
1456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1457            * @return the last matching bookmarks entry
1458            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1459            */
1460            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_NotS_Last(
1461                    long groupId, int status,
1462                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1463                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1464                    return getPersistence()
1465                                       .findByG_NotS_Last(groupId, status, orderByComparator);
1466            }
1467    
1468            /**
1469            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1470            *
1471            * @param groupId the group ID
1472            * @param status the status
1473            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1474            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1475            */
1476            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_NotS_Last(
1477                    long groupId, int status,
1478                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1479                    return getPersistence()
1480                                       .fetchByG_NotS_Last(groupId, status, orderByComparator);
1481            }
1482    
1483            /**
1484            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1485            *
1486            * @param entryId the primary key of the current bookmarks entry
1487            * @param groupId the group ID
1488            * @param status the status
1489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1490            * @return the previous, current, and next bookmarks entry
1491            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1492            */
1493            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_NotS_PrevAndNext(
1494                    long entryId, long groupId, int status,
1495                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1496                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1497                    return getPersistence()
1498                                       .findByG_NotS_PrevAndNext(entryId, groupId, status,
1499                            orderByComparator);
1500            }
1501    
1502            /**
1503            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1504            *
1505            * @param groupId the group ID
1506            * @param status the status
1507            * @return the matching bookmarks entries that the user has permission to view
1508            */
1509            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1510                    long groupId, int status) {
1511                    return getPersistence().filterFindByG_NotS(groupId, status);
1512            }
1513    
1514            /**
1515            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1516            *
1517            * <p>
1518            * 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.
1519            * </p>
1520            *
1521            * @param groupId the group ID
1522            * @param status the status
1523            * @param start the lower bound of the range of bookmarks entries
1524            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1525            * @return the range of matching bookmarks entries that the user has permission to view
1526            */
1527            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1528                    long groupId, int status, int start, int end) {
1529                    return getPersistence().filterFindByG_NotS(groupId, status, start, end);
1530            }
1531    
1532            /**
1533            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status &ne; &#63;.
1534            *
1535            * <p>
1536            * 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.
1537            * </p>
1538            *
1539            * @param groupId the group ID
1540            * @param status the status
1541            * @param start the lower bound of the range of bookmarks entries
1542            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1543            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1544            * @return the ordered range of matching bookmarks entries that the user has permission to view
1545            */
1546            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_NotS(
1547                    long groupId, int status, int start, int end,
1548                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1549                    return getPersistence()
1550                                       .filterFindByG_NotS(groupId, status, start, end,
1551                            orderByComparator);
1552            }
1553    
1554            /**
1555            * 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;.
1556            *
1557            * @param entryId the primary key of the current bookmarks entry
1558            * @param groupId the group ID
1559            * @param status the status
1560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1561            * @return the previous, current, and next bookmarks entry
1562            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1563            */
1564            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_NotS_PrevAndNext(
1565                    long entryId, long groupId, int status,
1566                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1567                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1568                    return getPersistence()
1569                                       .filterFindByG_NotS_PrevAndNext(entryId, groupId, status,
1570                            orderByComparator);
1571            }
1572    
1573            /**
1574            * Removes all the bookmarks entries where groupId = &#63; and status &ne; &#63; from the database.
1575            *
1576            * @param groupId the group ID
1577            * @param status the status
1578            */
1579            public static void removeByG_NotS(long groupId, int status) {
1580                    getPersistence().removeByG_NotS(groupId, status);
1581            }
1582    
1583            /**
1584            * Returns the number of bookmarks entries where groupId = &#63; and status &ne; &#63;.
1585            *
1586            * @param groupId the group ID
1587            * @param status the status
1588            * @return the number of matching bookmarks entries
1589            */
1590            public static int countByG_NotS(long groupId, int status) {
1591                    return getPersistence().countByG_NotS(groupId, status);
1592            }
1593    
1594            /**
1595            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1596            *
1597            * @param groupId the group ID
1598            * @param status the status
1599            * @return the number of matching bookmarks entries that the user has permission to view
1600            */
1601            public static int filterCountByG_NotS(long groupId, int status) {
1602                    return getPersistence().filterCountByG_NotS(groupId, status);
1603            }
1604    
1605            /**
1606            * Returns all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1607            *
1608            * @param companyId the company ID
1609            * @param status the status
1610            * @return the matching bookmarks entries
1611            */
1612            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1613                    long companyId, int status) {
1614                    return getPersistence().findByC_NotS(companyId, status);
1615            }
1616    
1617            /**
1618            * Returns a range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1619            *
1620            * <p>
1621            * 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.
1622            * </p>
1623            *
1624            * @param companyId the company ID
1625            * @param status the status
1626            * @param start the lower bound of the range of bookmarks entries
1627            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1628            * @return the range of matching bookmarks entries
1629            */
1630            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1631                    long companyId, int status, int start, int end) {
1632                    return getPersistence().findByC_NotS(companyId, status, start, end);
1633            }
1634    
1635            /**
1636            * Returns an ordered range of all the bookmarks entries where companyId = &#63; and status &ne; &#63;.
1637            *
1638            * <p>
1639            * 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.
1640            * </p>
1641            *
1642            * @param companyId the company ID
1643            * @param status the status
1644            * @param start the lower bound of the range of bookmarks entries
1645            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1646            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1647            * @return the ordered range of matching bookmarks entries
1648            */
1649            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByC_NotS(
1650                    long companyId, int status, int start, int end,
1651                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1652                    return getPersistence()
1653                                       .findByC_NotS(companyId, status, start, end,
1654                            orderByComparator);
1655            }
1656    
1657            /**
1658            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1659            *
1660            * @param companyId the company ID
1661            * @param status the status
1662            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1663            * @return the first matching bookmarks entry
1664            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1665            */
1666            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_First(
1667                    long companyId, int status,
1668                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1669                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1670                    return getPersistence()
1671                                       .findByC_NotS_First(companyId, status, orderByComparator);
1672            }
1673    
1674            /**
1675            * Returns the first bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1676            *
1677            * @param companyId the company ID
1678            * @param status the status
1679            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1680            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1681            */
1682            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_First(
1683                    long companyId, int status,
1684                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1685                    return getPersistence()
1686                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1687            }
1688    
1689            /**
1690            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1691            *
1692            * @param companyId the company ID
1693            * @param status the status
1694            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1695            * @return the last matching bookmarks entry
1696            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1697            */
1698            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByC_NotS_Last(
1699                    long companyId, int status,
1700                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1701                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1702                    return getPersistence()
1703                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1704            }
1705    
1706            /**
1707            * Returns the last bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1708            *
1709            * @param companyId the company ID
1710            * @param status the status
1711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1712            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1713            */
1714            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByC_NotS_Last(
1715                    long companyId, int status,
1716                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1717                    return getPersistence()
1718                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1719            }
1720    
1721            /**
1722            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1723            *
1724            * @param entryId the primary key of the current bookmarks entry
1725            * @param companyId the company ID
1726            * @param status the status
1727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1728            * @return the previous, current, and next bookmarks entry
1729            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1730            */
1731            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByC_NotS_PrevAndNext(
1732                    long entryId, long companyId, int status,
1733                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1734                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1735                    return getPersistence()
1736                                       .findByC_NotS_PrevAndNext(entryId, companyId, status,
1737                            orderByComparator);
1738            }
1739    
1740            /**
1741            * Removes all the bookmarks entries where companyId = &#63; and status &ne; &#63; from the database.
1742            *
1743            * @param companyId the company ID
1744            * @param status the status
1745            */
1746            public static void removeByC_NotS(long companyId, int status) {
1747                    getPersistence().removeByC_NotS(companyId, status);
1748            }
1749    
1750            /**
1751            * Returns the number of bookmarks entries where companyId = &#63; and status &ne; &#63;.
1752            *
1753            * @param companyId the company ID
1754            * @param status the status
1755            * @return the number of matching bookmarks entries
1756            */
1757            public static int countByC_NotS(long companyId, int status) {
1758                    return getPersistence().countByC_NotS(companyId, status);
1759            }
1760    
1761            /**
1762            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1763            *
1764            * @param groupId the group ID
1765            * @param userId the user ID
1766            * @param status the status
1767            * @return the matching bookmarks entries
1768            */
1769            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1770                    long groupId, long userId, int status) {
1771                    return getPersistence().findByG_U_S(groupId, userId, status);
1772            }
1773    
1774            /**
1775            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1776            *
1777            * <p>
1778            * 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.
1779            * </p>
1780            *
1781            * @param groupId the group ID
1782            * @param userId the user ID
1783            * @param status the status
1784            * @param start the lower bound of the range of bookmarks entries
1785            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1786            * @return the range of matching bookmarks entries
1787            */
1788            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1789                    long groupId, long userId, int status, int start, int end) {
1790                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
1791            }
1792    
1793            /**
1794            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1795            *
1796            * <p>
1797            * 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.
1798            * </p>
1799            *
1800            * @param groupId the group ID
1801            * @param userId the user ID
1802            * @param status the status
1803            * @param start the lower bound of the range of bookmarks entries
1804            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1805            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1806            * @return the ordered range of matching bookmarks entries
1807            */
1808            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1809                    long groupId, long userId, int status, int start, int end,
1810                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1811                    return getPersistence()
1812                                       .findByG_U_S(groupId, userId, status, start, end,
1813                            orderByComparator);
1814            }
1815    
1816            /**
1817            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1818            *
1819            * @param groupId the group ID
1820            * @param userId the user ID
1821            * @param status the status
1822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1823            * @return the first matching bookmarks entry
1824            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1825            */
1826            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First(
1827                    long groupId, long userId, int status,
1828                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1829                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1830                    return getPersistence()
1831                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
1832            }
1833    
1834            /**
1835            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1836            *
1837            * @param groupId the group ID
1838            * @param userId the user ID
1839            * @param status the status
1840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1841            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1842            */
1843            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First(
1844                    long groupId, long userId, int status,
1845                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1846                    return getPersistence()
1847                                       .fetchByG_U_S_First(groupId, userId, status,
1848                            orderByComparator);
1849            }
1850    
1851            /**
1852            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1853            *
1854            * @param groupId the group ID
1855            * @param userId the user ID
1856            * @param status the status
1857            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1858            * @return the last matching bookmarks entry
1859            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1860            */
1861            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last(
1862                    long groupId, long userId, int status,
1863                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1864                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1865                    return getPersistence()
1866                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
1867            }
1868    
1869            /**
1870            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1871            *
1872            * @param groupId the group ID
1873            * @param userId the user ID
1874            * @param status the status
1875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1876            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1877            */
1878            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last(
1879                    long groupId, long userId, int status,
1880                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1881                    return getPersistence()
1882                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
1883            }
1884    
1885            /**
1886            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1887            *
1888            * @param entryId the primary key of the current bookmarks entry
1889            * @param groupId the group ID
1890            * @param userId the user ID
1891            * @param status the status
1892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1893            * @return the previous, current, and next bookmarks entry
1894            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1895            */
1896            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext(
1897                    long entryId, long groupId, long userId, int status,
1898                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1899                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1900                    return getPersistence()
1901                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
1902                            orderByComparator);
1903            }
1904    
1905            /**
1906            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1907            *
1908            * @param groupId the group ID
1909            * @param userId the user ID
1910            * @param status the status
1911            * @return the matching bookmarks entries that the user has permission to view
1912            */
1913            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1914                    long groupId, long userId, int status) {
1915                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
1916            }
1917    
1918            /**
1919            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1920            *
1921            * <p>
1922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1923            * </p>
1924            *
1925            * @param groupId the group ID
1926            * @param userId the user ID
1927            * @param status the status
1928            * @param start the lower bound of the range of bookmarks entries
1929            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1930            * @return the range of matching bookmarks entries that the user has permission to view
1931            */
1932            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1933                    long groupId, long userId, int status, int start, int end) {
1934                    return getPersistence()
1935                                       .filterFindByG_U_S(groupId, userId, status, start, end);
1936            }
1937    
1938            /**
1939            * 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;.
1940            *
1941            * <p>
1942            * 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.
1943            * </p>
1944            *
1945            * @param groupId the group ID
1946            * @param userId the user ID
1947            * @param status the status
1948            * @param start the lower bound of the range of bookmarks entries
1949            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1950            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1951            * @return the ordered range of matching bookmarks entries that the user has permission to view
1952            */
1953            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1954                    long groupId, long userId, int status, int start, int end,
1955                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
1956                    return getPersistence()
1957                                       .filterFindByG_U_S(groupId, userId, status, start, end,
1958                            orderByComparator);
1959            }
1960    
1961            /**
1962            * 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;.
1963            *
1964            * @param entryId the primary key of the current bookmarks entry
1965            * @param groupId the group ID
1966            * @param userId the user ID
1967            * @param status the status
1968            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1969            * @return the previous, current, and next bookmarks entry
1970            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1971            */
1972            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext(
1973                    long entryId, long groupId, long userId, int status,
1974                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
1975                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
1976                    return getPersistence()
1977                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
1978                            status, orderByComparator);
1979            }
1980    
1981            /**
1982            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
1983            *
1984            * @param groupId the group ID
1985            * @param userId the user ID
1986            * @param status the status
1987            */
1988            public static void removeByG_U_S(long groupId, long userId, int status) {
1989                    getPersistence().removeByG_U_S(groupId, userId, status);
1990            }
1991    
1992            /**
1993            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1994            *
1995            * @param groupId the group ID
1996            * @param userId the user ID
1997            * @param status the status
1998            * @return the number of matching bookmarks entries
1999            */
2000            public static int countByG_U_S(long groupId, long userId, int status) {
2001                    return getPersistence().countByG_U_S(groupId, userId, status);
2002            }
2003    
2004            /**
2005            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2006            *
2007            * @param groupId the group ID
2008            * @param userId the user ID
2009            * @param status the status
2010            * @return the number of matching bookmarks entries that the user has permission to view
2011            */
2012            public static int filterCountByG_U_S(long groupId, long userId, int status) {
2013                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
2014            }
2015    
2016            /**
2017            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2018            *
2019            * @param groupId the group ID
2020            * @param userId the user ID
2021            * @param status the status
2022            * @return the matching bookmarks entries
2023            */
2024            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2025                    long groupId, long userId, int status) {
2026                    return getPersistence().findByG_U_NotS(groupId, userId, status);
2027            }
2028    
2029            /**
2030            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2031            *
2032            * <p>
2033            * 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.
2034            * </p>
2035            *
2036            * @param groupId the group ID
2037            * @param userId the user ID
2038            * @param status the status
2039            * @param start the lower bound of the range of bookmarks entries
2040            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2041            * @return the range of matching bookmarks entries
2042            */
2043            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2044                    long groupId, long userId, int status, int start, int end) {
2045                    return getPersistence()
2046                                       .findByG_U_NotS(groupId, userId, status, start, end);
2047            }
2048    
2049            /**
2050            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2051            *
2052            * <p>
2053            * 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.
2054            * </p>
2055            *
2056            * @param groupId the group ID
2057            * @param userId the user ID
2058            * @param status the status
2059            * @param start the lower bound of the range of bookmarks entries
2060            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2061            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2062            * @return the ordered range of matching bookmarks entries
2063            */
2064            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_NotS(
2065                    long groupId, long userId, int status, int start, int end,
2066                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2067                    return getPersistence()
2068                                       .findByG_U_NotS(groupId, userId, status, start, end,
2069                            orderByComparator);
2070            }
2071    
2072            /**
2073            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2074            *
2075            * @param groupId the group ID
2076            * @param userId the user ID
2077            * @param status the status
2078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2079            * @return the first matching bookmarks entry
2080            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2081            */
2082            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_First(
2083                    long groupId, long userId, int status,
2084                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2085                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2086                    return getPersistence()
2087                                       .findByG_U_NotS_First(groupId, userId, status,
2088                            orderByComparator);
2089            }
2090    
2091            /**
2092            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2093            *
2094            * @param groupId the group ID
2095            * @param userId the user ID
2096            * @param status the status
2097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2098            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2099            */
2100            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_First(
2101                    long groupId, long userId, int status,
2102                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2103                    return getPersistence()
2104                                       .fetchByG_U_NotS_First(groupId, userId, status,
2105                            orderByComparator);
2106            }
2107    
2108            /**
2109            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2110            *
2111            * @param groupId the group ID
2112            * @param userId the user ID
2113            * @param status the status
2114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2115            * @return the last matching bookmarks entry
2116            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2117            */
2118            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_NotS_Last(
2119                    long groupId, long userId, int status,
2120                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2121                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2122                    return getPersistence()
2123                                       .findByG_U_NotS_Last(groupId, userId, status,
2124                            orderByComparator);
2125            }
2126    
2127            /**
2128            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2129            *
2130            * @param groupId the group ID
2131            * @param userId the user ID
2132            * @param status the status
2133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2134            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2135            */
2136            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_NotS_Last(
2137                    long groupId, long userId, int status,
2138                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2139                    return getPersistence()
2140                                       .fetchByG_U_NotS_Last(groupId, userId, status,
2141                            orderByComparator);
2142            }
2143    
2144            /**
2145            * 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;.
2146            *
2147            * @param entryId the primary key of the current bookmarks entry
2148            * @param groupId the group ID
2149            * @param userId the user ID
2150            * @param status the status
2151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2152            * @return the previous, current, and next bookmarks entry
2153            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2154            */
2155            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_NotS_PrevAndNext(
2156                    long entryId, long groupId, long userId, int status,
2157                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2158                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2159                    return getPersistence()
2160                                       .findByG_U_NotS_PrevAndNext(entryId, groupId, userId,
2161                            status, orderByComparator);
2162            }
2163    
2164            /**
2165            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2166            *
2167            * @param groupId the group ID
2168            * @param userId the user ID
2169            * @param status the status
2170            * @return the matching bookmarks entries that the user has permission to view
2171            */
2172            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2173                    long groupId, long userId, int status) {
2174                    return getPersistence().filterFindByG_U_NotS(groupId, userId, status);
2175            }
2176    
2177            /**
2178            * 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;.
2179            *
2180            * <p>
2181            * 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.
2182            * </p>
2183            *
2184            * @param groupId the group ID
2185            * @param userId the user ID
2186            * @param status the status
2187            * @param start the lower bound of the range of bookmarks entries
2188            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2189            * @return the range of matching bookmarks entries that the user has permission to view
2190            */
2191            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2192                    long groupId, long userId, int status, int start, int end) {
2193                    return getPersistence()
2194                                       .filterFindByG_U_NotS(groupId, userId, status, start, end);
2195            }
2196    
2197            /**
2198            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2199            *
2200            * <p>
2201            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2202            * </p>
2203            *
2204            * @param groupId the group ID
2205            * @param userId the user ID
2206            * @param status the status
2207            * @param start the lower bound of the range of bookmarks entries
2208            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2210            * @return the ordered range of matching bookmarks entries that the user has permission to view
2211            */
2212            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_NotS(
2213                    long groupId, long userId, int status, int start, int end,
2214                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2215                    return getPersistence()
2216                                       .filterFindByG_U_NotS(groupId, userId, status, start, end,
2217                            orderByComparator);
2218            }
2219    
2220            /**
2221            * 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;.
2222            *
2223            * @param entryId the primary key of the current bookmarks entry
2224            * @param groupId the group ID
2225            * @param userId the user ID
2226            * @param status the status
2227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2228            * @return the previous, current, and next bookmarks entry
2229            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2230            */
2231            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_NotS_PrevAndNext(
2232                    long entryId, long groupId, long userId, int status,
2233                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2234                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2235                    return getPersistence()
2236                                       .filterFindByG_U_NotS_PrevAndNext(entryId, groupId, userId,
2237                            status, orderByComparator);
2238            }
2239    
2240            /**
2241            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63; from the database.
2242            *
2243            * @param groupId the group ID
2244            * @param userId the user ID
2245            * @param status the status
2246            */
2247            public static void removeByG_U_NotS(long groupId, long userId, int status) {
2248                    getPersistence().removeByG_U_NotS(groupId, userId, status);
2249            }
2250    
2251            /**
2252            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
2253            *
2254            * @param groupId the group ID
2255            * @param userId the user ID
2256            * @param status the status
2257            * @return the number of matching bookmarks entries
2258            */
2259            public static int countByG_U_NotS(long groupId, long userId, int status) {
2260                    return getPersistence().countByG_U_NotS(groupId, userId, status);
2261            }
2262    
2263            /**
2264            * Returns the number of bookmarks entries that the user has permission to view 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 number of matching bookmarks entries that the user has permission to view
2270            */
2271            public static int filterCountByG_U_NotS(long groupId, long userId,
2272                    int status) {
2273                    return getPersistence().filterCountByG_U_NotS(groupId, userId, status);
2274            }
2275    
2276            /**
2277            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2278            *
2279            * @param groupId the group ID
2280            * @param folderId the folder ID
2281            * @param status the status
2282            * @return the matching bookmarks entries
2283            */
2284            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2285                    long groupId, long folderId, int status) {
2286                    return getPersistence().findByG_F_S(groupId, folderId, status);
2287            }
2288    
2289            /**
2290            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2291            *
2292            * <p>
2293            * 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.
2294            * </p>
2295            *
2296            * @param groupId the group ID
2297            * @param folderId the folder ID
2298            * @param status the status
2299            * @param start the lower bound of the range of bookmarks entries
2300            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2301            * @return the range of matching bookmarks entries
2302            */
2303            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2304                    long groupId, long folderId, int status, int start, int end) {
2305                    return getPersistence()
2306                                       .findByG_F_S(groupId, folderId, status, start, end);
2307            }
2308    
2309            /**
2310            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2311            *
2312            * <p>
2313            * 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.
2314            * </p>
2315            *
2316            * @param groupId the group ID
2317            * @param folderId the folder ID
2318            * @param status the status
2319            * @param start the lower bound of the range of bookmarks entries
2320            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2321            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2322            * @return the ordered range of matching bookmarks entries
2323            */
2324            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2325                    long groupId, long folderId, int status, int start, int end,
2326                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2327                    return getPersistence()
2328                                       .findByG_F_S(groupId, folderId, status, start, end,
2329                            orderByComparator);
2330            }
2331    
2332            /**
2333            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2334            *
2335            * @param groupId the group ID
2336            * @param folderId the folder ID
2337            * @param status the status
2338            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2339            * @return the first matching bookmarks entry
2340            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2341            */
2342            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First(
2343                    long groupId, long folderId, int status,
2344                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2345                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2346                    return getPersistence()
2347                                       .findByG_F_S_First(groupId, folderId, status,
2348                            orderByComparator);
2349            }
2350    
2351            /**
2352            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2353            *
2354            * @param groupId the group ID
2355            * @param folderId the folder ID
2356            * @param status the status
2357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2358            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2359            */
2360            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First(
2361                    long groupId, long folderId, int status,
2362                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2363                    return getPersistence()
2364                                       .fetchByG_F_S_First(groupId, folderId, status,
2365                            orderByComparator);
2366            }
2367    
2368            /**
2369            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2370            *
2371            * @param groupId the group ID
2372            * @param folderId the folder ID
2373            * @param status the status
2374            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2375            * @return the last matching bookmarks entry
2376            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2377            */
2378            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last(
2379                    long groupId, long folderId, int status,
2380                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2381                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2382                    return getPersistence()
2383                                       .findByG_F_S_Last(groupId, folderId, status,
2384                            orderByComparator);
2385            }
2386    
2387            /**
2388            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2389            *
2390            * @param groupId the group ID
2391            * @param folderId the folder ID
2392            * @param status the status
2393            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2394            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2395            */
2396            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last(
2397                    long groupId, long folderId, int status,
2398                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2399                    return getPersistence()
2400                                       .fetchByG_F_S_Last(groupId, folderId, status,
2401                            orderByComparator);
2402            }
2403    
2404            /**
2405            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
2406            *
2407            * @param entryId the primary key of the current bookmarks entry
2408            * @param groupId the group ID
2409            * @param folderId the folder ID
2410            * @param status the status
2411            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2412            * @return the previous, current, and next bookmarks entry
2413            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2414            */
2415            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext(
2416                    long entryId, long groupId, long folderId, int status,
2417                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2418                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2419                    return getPersistence()
2420                                       .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status,
2421                            orderByComparator);
2422            }
2423    
2424            /**
2425            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2426            *
2427            * @param groupId the group ID
2428            * @param folderId the folder ID
2429            * @param status the status
2430            * @return the matching bookmarks entries that the user has permission to view
2431            */
2432            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2433                    long groupId, long folderId, int status) {
2434                    return getPersistence().filterFindByG_F_S(groupId, folderId, status);
2435            }
2436    
2437            /**
2438            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2439            *
2440            * <p>
2441            * 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.
2442            * </p>
2443            *
2444            * @param groupId the group ID
2445            * @param folderId the folder ID
2446            * @param status the status
2447            * @param start the lower bound of the range of bookmarks entries
2448            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2449            * @return the range of matching bookmarks entries that the user has permission to view
2450            */
2451            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2452                    long groupId, long folderId, int status, int start, int end) {
2453                    return getPersistence()
2454                                       .filterFindByG_F_S(groupId, folderId, status, start, end);
2455            }
2456    
2457            /**
2458            * 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;.
2459            *
2460            * <p>
2461            * 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.
2462            * </p>
2463            *
2464            * @param groupId the group ID
2465            * @param folderId the folder ID
2466            * @param status the status
2467            * @param start the lower bound of the range of bookmarks entries
2468            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2469            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2470            * @return the ordered range of matching bookmarks entries that the user has permission to view
2471            */
2472            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2473                    long groupId, long folderId, int status, int start, int end,
2474                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2475                    return getPersistence()
2476                                       .filterFindByG_F_S(groupId, folderId, status, start, end,
2477                            orderByComparator);
2478            }
2479    
2480            /**
2481            * 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;.
2482            *
2483            * @param entryId the primary key of the current bookmarks entry
2484            * @param groupId the group ID
2485            * @param folderId the folder ID
2486            * @param status the status
2487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2488            * @return the previous, current, and next bookmarks entry
2489            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2490            */
2491            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext(
2492                    long entryId, long groupId, long folderId, int status,
2493                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2494                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2495                    return getPersistence()
2496                                       .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId,
2497                            status, orderByComparator);
2498            }
2499    
2500            /**
2501            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2502            *
2503            * @param groupId the group ID
2504            * @param folderIds the folder IDs
2505            * @param status the status
2506            * @return the matching bookmarks entries that the user has permission to view
2507            */
2508            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2509                    long groupId, long[] folderIds, int status) {
2510                    return getPersistence().filterFindByG_F_S(groupId, folderIds, status);
2511            }
2512    
2513            /**
2514            * 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;.
2515            *
2516            * <p>
2517            * 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.
2518            * </p>
2519            *
2520            * @param groupId the group ID
2521            * @param folderIds the folder IDs
2522            * @param status the status
2523            * @param start the lower bound of the range of bookmarks entries
2524            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2525            * @return the range of matching bookmarks entries that the user has permission to view
2526            */
2527            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2528                    long groupId, long[] folderIds, int status, int start, int end) {
2529                    return getPersistence()
2530                                       .filterFindByG_F_S(groupId, folderIds, status, start, end);
2531            }
2532    
2533            /**
2534            * 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;.
2535            *
2536            * <p>
2537            * 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.
2538            * </p>
2539            *
2540            * @param groupId the group ID
2541            * @param folderIds the folder IDs
2542            * @param status the status
2543            * @param start the lower bound of the range of bookmarks entries
2544            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2545            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2546            * @return the ordered range of matching bookmarks entries that the user has permission to view
2547            */
2548            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
2549                    long groupId, long[] folderIds, int status, int start, int end,
2550                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2551                    return getPersistence()
2552                                       .filterFindByG_F_S(groupId, folderIds, status, start, end,
2553                            orderByComparator);
2554            }
2555    
2556            /**
2557            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2558            *
2559            * <p>
2560            * 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.
2561            * </p>
2562            *
2563            * @param groupId the group ID
2564            * @param folderIds the folder IDs
2565            * @param status the status
2566            * @return the matching bookmarks entries
2567            */
2568            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2569                    long groupId, long[] folderIds, int status) {
2570                    return getPersistence().findByG_F_S(groupId, folderIds, status);
2571            }
2572    
2573            /**
2574            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2575            *
2576            * <p>
2577            * 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.
2578            * </p>
2579            *
2580            * @param groupId the group ID
2581            * @param folderIds the folder IDs
2582            * @param status the status
2583            * @param start the lower bound of the range of bookmarks entries
2584            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2585            * @return the range of matching bookmarks entries
2586            */
2587            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2588                    long groupId, long[] folderIds, int status, int start, int end) {
2589                    return getPersistence()
2590                                       .findByG_F_S(groupId, folderIds, status, start, end);
2591            }
2592    
2593            /**
2594            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2595            *
2596            * <p>
2597            * 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.
2598            * </p>
2599            *
2600            * @param groupId the group ID
2601            * @param folderIds the folder IDs
2602            * @param status the status
2603            * @param start the lower bound of the range of bookmarks entries
2604            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2605            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2606            * @return the ordered range of matching bookmarks entries
2607            */
2608            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2609                    long groupId, long[] folderIds, int status, int start, int end,
2610                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2611                    return getPersistence()
2612                                       .findByG_F_S(groupId, folderIds, status, start, end,
2613                            orderByComparator);
2614            }
2615    
2616            /**
2617            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
2618            *
2619            * @param groupId the group ID
2620            * @param folderId the folder ID
2621            * @param status the status
2622            */
2623            public static void removeByG_F_S(long groupId, long folderId, int status) {
2624                    getPersistence().removeByG_F_S(groupId, folderId, status);
2625            }
2626    
2627            /**
2628            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2629            *
2630            * @param groupId the group ID
2631            * @param folderId the folder ID
2632            * @param status the status
2633            * @return the number of matching bookmarks entries
2634            */
2635            public static int countByG_F_S(long groupId, long folderId, int status) {
2636                    return getPersistence().countByG_F_S(groupId, folderId, status);
2637            }
2638    
2639            /**
2640            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2641            *
2642            * @param groupId the group ID
2643            * @param folderIds the folder IDs
2644            * @param status the status
2645            * @return the number of matching bookmarks entries
2646            */
2647            public static int countByG_F_S(long groupId, long[] folderIds, int status) {
2648                    return getPersistence().countByG_F_S(groupId, folderIds, status);
2649            }
2650    
2651            /**
2652            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2653            *
2654            * @param groupId the group ID
2655            * @param folderId the folder ID
2656            * @param status the status
2657            * @return the number of matching bookmarks entries that the user has permission to view
2658            */
2659            public static int filterCountByG_F_S(long groupId, long folderId, int status) {
2660                    return getPersistence().filterCountByG_F_S(groupId, folderId, status);
2661            }
2662    
2663            /**
2664            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2665            *
2666            * @param groupId the group ID
2667            * @param folderIds the folder IDs
2668            * @param status the status
2669            * @return the number of matching bookmarks entries that the user has permission to view
2670            */
2671            public static int filterCountByG_F_S(long groupId, long[] folderIds,
2672                    int status) {
2673                    return getPersistence().filterCountByG_F_S(groupId, folderIds, status);
2674            }
2675    
2676            /**
2677            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2678            *
2679            * @param groupId the group ID
2680            * @param folderId the folder ID
2681            * @param status the status
2682            * @return the matching bookmarks entries
2683            */
2684            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2685                    long groupId, long folderId, int status) {
2686                    return getPersistence().findByG_F_NotS(groupId, folderId, status);
2687            }
2688    
2689            /**
2690            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2691            *
2692            * <p>
2693            * 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.
2694            * </p>
2695            *
2696            * @param groupId the group ID
2697            * @param folderId the folder ID
2698            * @param status the status
2699            * @param start the lower bound of the range of bookmarks entries
2700            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2701            * @return the range of matching bookmarks entries
2702            */
2703            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2704                    long groupId, long folderId, int status, int start, int end) {
2705                    return getPersistence()
2706                                       .findByG_F_NotS(groupId, folderId, status, start, end);
2707            }
2708    
2709            /**
2710            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2711            *
2712            * <p>
2713            * 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.
2714            * </p>
2715            *
2716            * @param groupId the group ID
2717            * @param folderId the folder ID
2718            * @param status the status
2719            * @param start the lower bound of the range of bookmarks entries
2720            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2721            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2722            * @return the ordered range of matching bookmarks entries
2723            */
2724            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2725                    long groupId, long folderId, int status, int start, int end,
2726                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2727                    return getPersistence()
2728                                       .findByG_F_NotS(groupId, folderId, status, start, end,
2729                            orderByComparator);
2730            }
2731    
2732            /**
2733            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2734            *
2735            * @param groupId the group ID
2736            * @param folderId the folder ID
2737            * @param status the status
2738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2739            * @return the first matching bookmarks entry
2740            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2741            */
2742            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First(
2743                    long groupId, long folderId, int status,
2744                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2745                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2746                    return getPersistence()
2747                                       .findByG_F_NotS_First(groupId, folderId, status,
2748                            orderByComparator);
2749            }
2750    
2751            /**
2752            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2753            *
2754            * @param groupId the group ID
2755            * @param folderId the folder ID
2756            * @param status the status
2757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2758            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2759            */
2760            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First(
2761                    long groupId, long folderId, int status,
2762                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2763                    return getPersistence()
2764                                       .fetchByG_F_NotS_First(groupId, folderId, status,
2765                            orderByComparator);
2766            }
2767    
2768            /**
2769            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2770            *
2771            * @param groupId the group ID
2772            * @param folderId the folder ID
2773            * @param status the status
2774            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2775            * @return the last matching bookmarks entry
2776            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2777            */
2778            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last(
2779                    long groupId, long folderId, int status,
2780                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2781                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2782                    return getPersistence()
2783                                       .findByG_F_NotS_Last(groupId, folderId, status,
2784                            orderByComparator);
2785            }
2786    
2787            /**
2788            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2789            *
2790            * @param groupId the group ID
2791            * @param folderId the folder ID
2792            * @param status the status
2793            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2794            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2795            */
2796            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last(
2797                    long groupId, long folderId, int status,
2798                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2799                    return getPersistence()
2800                                       .fetchByG_F_NotS_Last(groupId, folderId, status,
2801                            orderByComparator);
2802            }
2803    
2804            /**
2805            * 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;.
2806            *
2807            * @param entryId the primary key of the current bookmarks entry
2808            * @param groupId the group ID
2809            * @param folderId the folder ID
2810            * @param status the status
2811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2812            * @return the previous, current, and next bookmarks entry
2813            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2814            */
2815            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext(
2816                    long entryId, long groupId, long folderId, int status,
2817                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2818                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2819                    return getPersistence()
2820                                       .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId,
2821                            status, orderByComparator);
2822            }
2823    
2824            /**
2825            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2826            *
2827            * @param groupId the group ID
2828            * @param folderId the folder ID
2829            * @param status the status
2830            * @return the matching bookmarks entries that the user has permission to view
2831            */
2832            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2833                    long groupId, long folderId, int status) {
2834                    return getPersistence().filterFindByG_F_NotS(groupId, folderId, status);
2835            }
2836    
2837            /**
2838            * 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;.
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 folderId the folder ID
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            * @return the range of matching bookmarks entries that the user has permission to view
2850            */
2851            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2852                    long groupId, long folderId, int status, int start, int end) {
2853                    return getPersistence()
2854                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end);
2855            }
2856    
2857            /**
2858            * 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;.
2859            *
2860            * <p>
2861            * 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.
2862            * </p>
2863            *
2864            * @param groupId the group ID
2865            * @param folderId the folder ID
2866            * @param status the status
2867            * @param start the lower bound of the range of bookmarks entries
2868            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2869            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2870            * @return the ordered range of matching bookmarks entries that the user has permission to view
2871            */
2872            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2873                    long groupId, long folderId, int status, int start, int end,
2874                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2875                    return getPersistence()
2876                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end,
2877                            orderByComparator);
2878            }
2879    
2880            /**
2881            * 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;.
2882            *
2883            * @param entryId the primary key of the current bookmarks entry
2884            * @param groupId the group ID
2885            * @param folderId the folder ID
2886            * @param status the status
2887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2888            * @return the previous, current, and next bookmarks entry
2889            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2890            */
2891            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext(
2892                    long entryId, long groupId, long folderId, int status,
2893                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
2894                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
2895                    return getPersistence()
2896                                       .filterFindByG_F_NotS_PrevAndNext(entryId, groupId,
2897                            folderId, status, orderByComparator);
2898            }
2899    
2900            /**
2901            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2902            *
2903            * @param groupId the group ID
2904            * @param folderIds the folder IDs
2905            * @param status the status
2906            * @return the matching bookmarks entries that the user has permission to view
2907            */
2908            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2909                    long groupId, long[] folderIds, int status) {
2910                    return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status);
2911            }
2912    
2913            /**
2914            * 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;.
2915            *
2916            * <p>
2917            * 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.
2918            * </p>
2919            *
2920            * @param groupId the group ID
2921            * @param folderIds the folder IDs
2922            * @param status the status
2923            * @param start the lower bound of the range of bookmarks entries
2924            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2925            * @return the range of matching bookmarks entries that the user has permission to view
2926            */
2927            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2928                    long groupId, long[] folderIds, int status, int start, int end) {
2929                    return getPersistence()
2930                                       .filterFindByG_F_NotS(groupId, folderIds, status, start, end);
2931            }
2932    
2933            /**
2934            * 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;.
2935            *
2936            * <p>
2937            * 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.
2938            * </p>
2939            *
2940            * @param groupId the group ID
2941            * @param folderIds the folder IDs
2942            * @param status the status
2943            * @param start the lower bound of the range of bookmarks entries
2944            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2945            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2946            * @return the ordered range of matching bookmarks entries that the user has permission to view
2947            */
2948            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2949                    long groupId, long[] folderIds, int status, int start, int end,
2950                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
2951                    return getPersistence()
2952                                       .filterFindByG_F_NotS(groupId, folderIds, status, start,
2953                            end, orderByComparator);
2954            }
2955    
2956            /**
2957            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2958            *
2959            * <p>
2960            * 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.
2961            * </p>
2962            *
2963            * @param groupId the group ID
2964            * @param folderIds the folder IDs
2965            * @param status the status
2966            * @return the matching bookmarks entries
2967            */
2968            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2969                    long groupId, long[] folderIds, int status) {
2970                    return getPersistence().findByG_F_NotS(groupId, folderIds, status);
2971            }
2972    
2973            /**
2974            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2975            *
2976            * <p>
2977            * 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.
2978            * </p>
2979            *
2980            * @param groupId the group ID
2981            * @param folderIds the folder IDs
2982            * @param status the status
2983            * @param start the lower bound of the range of bookmarks entries
2984            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2985            * @return the range of matching bookmarks entries
2986            */
2987            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2988                    long groupId, long[] folderIds, int status, int start, int end) {
2989                    return getPersistence()
2990                                       .findByG_F_NotS(groupId, folderIds, status, start, end);
2991            }
2992    
2993            /**
2994            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2995            *
2996            * <p>
2997            * 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.
2998            * </p>
2999            *
3000            * @param groupId the group ID
3001            * @param folderIds the folder IDs
3002            * @param status the status
3003            * @param start the lower bound of the range of bookmarks entries
3004            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3005            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3006            * @return the ordered range of matching bookmarks entries
3007            */
3008            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
3009                    long groupId, long[] folderIds, int status, int start, int end,
3010                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3011                    return getPersistence()
3012                                       .findByG_F_NotS(groupId, folderIds, status, start, end,
3013                            orderByComparator);
3014            }
3015    
3016            /**
3017            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63; from the database.
3018            *
3019            * @param groupId the group ID
3020            * @param folderId the folder ID
3021            * @param status the status
3022            */
3023            public static void removeByG_F_NotS(long groupId, long folderId, int status) {
3024                    getPersistence().removeByG_F_NotS(groupId, folderId, status);
3025            }
3026    
3027            /**
3028            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3029            *
3030            * @param groupId the group ID
3031            * @param folderId the folder ID
3032            * @param status the status
3033            * @return the number of matching bookmarks entries
3034            */
3035            public static int countByG_F_NotS(long groupId, long folderId, int status) {
3036                    return getPersistence().countByG_F_NotS(groupId, folderId, status);
3037            }
3038    
3039            /**
3040            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3041            *
3042            * @param groupId the group ID
3043            * @param folderIds the folder IDs
3044            * @param status the status
3045            * @return the number of matching bookmarks entries
3046            */
3047            public static int countByG_F_NotS(long groupId, long[] folderIds, int status) {
3048                    return getPersistence().countByG_F_NotS(groupId, folderIds, status);
3049            }
3050    
3051            /**
3052            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
3053            *
3054            * @param groupId the group ID
3055            * @param folderId the folder ID
3056            * @param status the status
3057            * @return the number of matching bookmarks entries that the user has permission to view
3058            */
3059            public static int filterCountByG_F_NotS(long groupId, long folderId,
3060                    int status) {
3061                    return getPersistence().filterCountByG_F_NotS(groupId, folderId, status);
3062            }
3063    
3064            /**
3065            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
3066            *
3067            * @param groupId the group ID
3068            * @param folderIds the folder IDs
3069            * @param status the status
3070            * @return the number of matching bookmarks entries that the user has permission to view
3071            */
3072            public static int filterCountByG_F_NotS(long groupId, long[] folderIds,
3073                    int status) {
3074                    return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status);
3075            }
3076    
3077            /**
3078            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3079            *
3080            * @param groupId the group ID
3081            * @param userId the user ID
3082            * @param folderId the folder ID
3083            * @param status the status
3084            * @return the matching bookmarks entries
3085            */
3086            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3087                    long groupId, long userId, long folderId, int status) {
3088                    return getPersistence().findByG_U_F_S(groupId, userId, folderId, status);
3089            }
3090    
3091            /**
3092            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3093            *
3094            * <p>
3095            * 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.
3096            * </p>
3097            *
3098            * @param groupId the group ID
3099            * @param userId the user ID
3100            * @param folderId the folder ID
3101            * @param status the status
3102            * @param start the lower bound of the range of bookmarks entries
3103            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3104            * @return the range of matching bookmarks entries
3105            */
3106            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3107                    long groupId, long userId, long folderId, int status, int start, int end) {
3108                    return getPersistence()
3109                                       .findByG_U_F_S(groupId, userId, folderId, status, start, end);
3110            }
3111    
3112            /**
3113            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3114            *
3115            * <p>
3116            * 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.
3117            * </p>
3118            *
3119            * @param groupId the group ID
3120            * @param userId the user ID
3121            * @param folderId the folder ID
3122            * @param status the status
3123            * @param start the lower bound of the range of bookmarks entries
3124            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3125            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3126            * @return the ordered range of matching bookmarks entries
3127            */
3128            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3129                    long groupId, long userId, long folderId, int status, int start,
3130                    int end,
3131                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3132                    return getPersistence()
3133                                       .findByG_U_F_S(groupId, userId, folderId, status, start,
3134                            end, orderByComparator);
3135            }
3136    
3137            /**
3138            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3139            *
3140            * @param groupId the group ID
3141            * @param userId the user ID
3142            * @param folderId the folder ID
3143            * @param status the status
3144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3145            * @return the first matching bookmarks entry
3146            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3147            */
3148            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First(
3149                    long groupId, long userId, long folderId, int status,
3150                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
3151                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3152                    return getPersistence()
3153                                       .findByG_U_F_S_First(groupId, userId, folderId, status,
3154                            orderByComparator);
3155            }
3156    
3157            /**
3158            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3159            *
3160            * @param groupId the group ID
3161            * @param userId the user ID
3162            * @param folderId the folder ID
3163            * @param status the status
3164            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3165            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3166            */
3167            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First(
3168                    long groupId, long userId, long folderId, int status,
3169                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3170                    return getPersistence()
3171                                       .fetchByG_U_F_S_First(groupId, userId, folderId, status,
3172                            orderByComparator);
3173            }
3174    
3175            /**
3176            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3177            *
3178            * @param groupId the group ID
3179            * @param userId the user ID
3180            * @param folderId the folder ID
3181            * @param status the status
3182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3183            * @return the last matching bookmarks entry
3184            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
3185            */
3186            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last(
3187                    long groupId, long userId, long folderId, int status,
3188                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
3189                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3190                    return getPersistence()
3191                                       .findByG_U_F_S_Last(groupId, userId, folderId, status,
3192                            orderByComparator);
3193            }
3194    
3195            /**
3196            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3197            *
3198            * @param groupId the group ID
3199            * @param userId the user ID
3200            * @param folderId the folder ID
3201            * @param status the status
3202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3203            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
3204            */
3205            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last(
3206                    long groupId, long userId, long folderId, int status,
3207                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3208                    return getPersistence()
3209                                       .fetchByG_U_F_S_Last(groupId, userId, folderId, status,
3210                            orderByComparator);
3211            }
3212    
3213            /**
3214            * 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;.
3215            *
3216            * @param entryId the primary key of the current bookmarks entry
3217            * @param groupId the group ID
3218            * @param userId the user ID
3219            * @param folderId the folder ID
3220            * @param status the status
3221            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3222            * @return the previous, current, and next bookmarks entry
3223            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3224            */
3225            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext(
3226                    long entryId, long groupId, long userId, long folderId, int status,
3227                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
3228                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3229                    return getPersistence()
3230                                       .findByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3231                            folderId, status, orderByComparator);
3232            }
3233    
3234            /**
3235            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3236            *
3237            * @param groupId the group ID
3238            * @param userId the user ID
3239            * @param folderId the folder ID
3240            * @param status the status
3241            * @return the matching bookmarks entries that the user has permission to view
3242            */
3243            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3244                    long groupId, long userId, long folderId, int status) {
3245                    return getPersistence()
3246                                       .filterFindByG_U_F_S(groupId, userId, folderId, status);
3247            }
3248    
3249            /**
3250            * 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;.
3251            *
3252            * <p>
3253            * 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.
3254            * </p>
3255            *
3256            * @param groupId the group ID
3257            * @param userId the user ID
3258            * @param folderId the folder ID
3259            * @param status the status
3260            * @param start the lower bound of the range of bookmarks entries
3261            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3262            * @return the range of matching bookmarks entries that the user has permission to view
3263            */
3264            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3265                    long groupId, long userId, long folderId, int status, int start, int end) {
3266                    return getPersistence()
3267                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3268                            start, end);
3269            }
3270    
3271            /**
3272            * 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;.
3273            *
3274            * <p>
3275            * 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.
3276            * </p>
3277            *
3278            * @param groupId the group ID
3279            * @param userId the user ID
3280            * @param folderId the folder ID
3281            * @param status the status
3282            * @param start the lower bound of the range of bookmarks entries
3283            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3284            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3285            * @return the ordered range of matching bookmarks entries that the user has permission to view
3286            */
3287            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3288                    long groupId, long userId, long folderId, int status, int start,
3289                    int end,
3290                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3291                    return getPersistence()
3292                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
3293                            start, end, orderByComparator);
3294            }
3295    
3296            /**
3297            * 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;.
3298            *
3299            * @param entryId the primary key of the current bookmarks entry
3300            * @param groupId the group ID
3301            * @param userId the user ID
3302            * @param folderId the folder ID
3303            * @param status the status
3304            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3305            * @return the previous, current, and next bookmarks entry
3306            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3307            */
3308            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext(
3309                    long entryId, long groupId, long userId, long folderId, int status,
3310                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator)
3311                    throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3312                    return getPersistence()
3313                                       .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId,
3314                            folderId, status, orderByComparator);
3315            }
3316    
3317            /**
3318            * 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;.
3319            *
3320            * @param groupId the group ID
3321            * @param userId the user ID
3322            * @param folderIds the folder IDs
3323            * @param status the status
3324            * @return the matching bookmarks entries that the user has permission to view
3325            */
3326            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3327                    long groupId, long userId, long[] folderIds, int status) {
3328                    return getPersistence()
3329                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status);
3330            }
3331    
3332            /**
3333            * 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;.
3334            *
3335            * <p>
3336            * 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.
3337            * </p>
3338            *
3339            * @param groupId the group ID
3340            * @param userId the user ID
3341            * @param folderIds the folder IDs
3342            * @param status the status
3343            * @param start the lower bound of the range of bookmarks entries
3344            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3345            * @return the range of matching bookmarks entries that the user has permission to view
3346            */
3347            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3348                    long groupId, long userId, long[] folderIds, int status, int start,
3349                    int end) {
3350                    return getPersistence()
3351                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3352                            start, end);
3353            }
3354    
3355            /**
3356            * 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;.
3357            *
3358            * <p>
3359            * 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.
3360            * </p>
3361            *
3362            * @param groupId the group ID
3363            * @param userId the user ID
3364            * @param folderIds the folder IDs
3365            * @param status the status
3366            * @param start the lower bound of the range of bookmarks entries
3367            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3368            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3369            * @return the ordered range of matching bookmarks entries that the user has permission to view
3370            */
3371            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
3372                    long groupId, long userId, long[] folderIds, int status, int start,
3373                    int end,
3374                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3375                    return getPersistence()
3376                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
3377                            start, end, orderByComparator);
3378            }
3379    
3380            /**
3381            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3382            *
3383            * <p>
3384            * 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.
3385            * </p>
3386            *
3387            * @param groupId the group ID
3388            * @param userId the user ID
3389            * @param folderIds the folder IDs
3390            * @param status the status
3391            * @return the matching bookmarks entries
3392            */
3393            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3394                    long groupId, long userId, long[] folderIds, int status) {
3395                    return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status);
3396            }
3397    
3398            /**
3399            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3400            *
3401            * <p>
3402            * 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.
3403            * </p>
3404            *
3405            * @param groupId the group ID
3406            * @param userId the user ID
3407            * @param folderIds the folder IDs
3408            * @param status the status
3409            * @param start the lower bound of the range of bookmarks entries
3410            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3411            * @return the range of matching bookmarks entries
3412            */
3413            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3414                    long groupId, long userId, long[] folderIds, int status, int start,
3415                    int end) {
3416                    return getPersistence()
3417                                       .findByG_U_F_S(groupId, userId, folderIds, status, start, end);
3418            }
3419    
3420            /**
3421            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3422            *
3423            * <p>
3424            * 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.
3425            * </p>
3426            *
3427            * @param groupId the group ID
3428            * @param userId the user ID
3429            * @param folderIds the folder IDs
3430            * @param status the status
3431            * @param start the lower bound of the range of bookmarks entries
3432            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3433            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3434            * @return the ordered range of matching bookmarks entries
3435            */
3436            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
3437                    long groupId, long userId, long[] folderIds, int status, int start,
3438                    int end,
3439                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3440                    return getPersistence()
3441                                       .findByG_U_F_S(groupId, userId, folderIds, status, start,
3442                            end, orderByComparator);
3443            }
3444    
3445            /**
3446            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63; from the database.
3447            *
3448            * @param groupId the group ID
3449            * @param userId the user ID
3450            * @param folderId the folder ID
3451            * @param status the status
3452            */
3453            public static void removeByG_U_F_S(long groupId, long userId,
3454                    long folderId, int status) {
3455                    getPersistence().removeByG_U_F_S(groupId, userId, folderId, status);
3456            }
3457    
3458            /**
3459            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
3460            *
3461            * @param groupId the group ID
3462            * @param userId the user ID
3463            * @param folderId the folder ID
3464            * @param status the status
3465            * @return the number of matching bookmarks entries
3466            */
3467            public static int countByG_U_F_S(long groupId, long userId, long folderId,
3468                    int status) {
3469                    return getPersistence().countByG_U_F_S(groupId, userId, folderId, status);
3470            }
3471    
3472            /**
3473            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3474            *
3475            * @param groupId the group ID
3476            * @param userId the user ID
3477            * @param folderIds the folder IDs
3478            * @param status the status
3479            * @return the number of matching bookmarks entries
3480            */
3481            public static int countByG_U_F_S(long groupId, long userId,
3482                    long[] folderIds, int status) {
3483                    return getPersistence()
3484                                       .countByG_U_F_S(groupId, userId, folderIds, status);
3485            }
3486    
3487            /**
3488            * 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;.
3489            *
3490            * @param groupId the group ID
3491            * @param userId the user ID
3492            * @param folderId the folder ID
3493            * @param status the status
3494            * @return the number of matching bookmarks entries that the user has permission to view
3495            */
3496            public static int filterCountByG_U_F_S(long groupId, long userId,
3497                    long folderId, int status) {
3498                    return getPersistence()
3499                                       .filterCountByG_U_F_S(groupId, userId, folderId, status);
3500            }
3501    
3502            /**
3503            * 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;.
3504            *
3505            * @param groupId the group ID
3506            * @param userId the user ID
3507            * @param folderIds the folder IDs
3508            * @param status the status
3509            * @return the number of matching bookmarks entries that the user has permission to view
3510            */
3511            public static int filterCountByG_U_F_S(long groupId, long userId,
3512                    long[] folderIds, int status) {
3513                    return getPersistence()
3514                                       .filterCountByG_U_F_S(groupId, userId, folderIds, status);
3515            }
3516    
3517            /**
3518            * Caches the bookmarks entry in the entity cache if it is enabled.
3519            *
3520            * @param bookmarksEntry the bookmarks entry
3521            */
3522            public static void cacheResult(
3523                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
3524                    getPersistence().cacheResult(bookmarksEntry);
3525            }
3526    
3527            /**
3528            * Caches the bookmarks entries in the entity cache if it is enabled.
3529            *
3530            * @param bookmarksEntries the bookmarks entries
3531            */
3532            public static void cacheResult(
3533                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
3534                    getPersistence().cacheResult(bookmarksEntries);
3535            }
3536    
3537            /**
3538            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
3539            *
3540            * @param entryId the primary key for the new bookmarks entry
3541            * @return the new bookmarks entry
3542            */
3543            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
3544                    long entryId) {
3545                    return getPersistence().create(entryId);
3546            }
3547    
3548            /**
3549            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
3550            *
3551            * @param entryId the primary key of the bookmarks entry
3552            * @return the bookmarks entry that was removed
3553            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3554            */
3555            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
3556                    long entryId) throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3557                    return getPersistence().remove(entryId);
3558            }
3559    
3560            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
3561                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
3562                    return getPersistence().updateImpl(bookmarksEntry);
3563            }
3564    
3565            /**
3566            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
3567            *
3568            * @param entryId the primary key of the bookmarks entry
3569            * @return the bookmarks entry
3570            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3571            */
3572            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
3573                    long entryId) throws com.liferay.portlet.bookmarks.NoSuchEntryException {
3574                    return getPersistence().findByPrimaryKey(entryId);
3575            }
3576    
3577            /**
3578            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
3579            *
3580            * @param entryId the primary key of the bookmarks entry
3581            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
3582            */
3583            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
3584                    long entryId) {
3585                    return getPersistence().fetchByPrimaryKey(entryId);
3586            }
3587    
3588            public static java.util.Map<java.io.Serializable, com.liferay.portlet.bookmarks.model.BookmarksEntry> fetchByPrimaryKeys(
3589                    java.util.Set<java.io.Serializable> primaryKeys) {
3590                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
3591            }
3592    
3593            /**
3594            * Returns all the bookmarks entries.
3595            *
3596            * @return the bookmarks entries
3597            */
3598            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() {
3599                    return getPersistence().findAll();
3600            }
3601    
3602            /**
3603            * Returns a range of all the bookmarks entries.
3604            *
3605            * <p>
3606            * 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.
3607            * </p>
3608            *
3609            * @param start the lower bound of the range of bookmarks entries
3610            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3611            * @return the range of bookmarks entries
3612            */
3613            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3614                    int start, int end) {
3615                    return getPersistence().findAll(start, end);
3616            }
3617    
3618            /**
3619            * Returns an ordered range of all the bookmarks entries.
3620            *
3621            * <p>
3622            * 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.
3623            * </p>
3624            *
3625            * @param start the lower bound of the range of bookmarks entries
3626            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3627            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3628            * @return the ordered range of bookmarks entries
3629            */
3630            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3631                    int start, int end,
3632                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksEntry> orderByComparator) {
3633                    return getPersistence().findAll(start, end, orderByComparator);
3634            }
3635    
3636            /**
3637            * Removes all the bookmarks entries from the database.
3638            */
3639            public static void removeAll() {
3640                    getPersistence().removeAll();
3641            }
3642    
3643            /**
3644            * Returns the number of bookmarks entries.
3645            *
3646            * @return the number of bookmarks entries
3647            */
3648            public static int countAll() {
3649                    return getPersistence().countAll();
3650            }
3651    
3652            public static BookmarksEntryPersistence getPersistence() {
3653                    if (_persistence == null) {
3654                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
3655    
3656                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
3657                                    "_persistence");
3658                    }
3659    
3660                    return _persistence;
3661            }
3662    
3663            /**
3664             * @deprecated As of 6.2.0
3665             */
3666            @Deprecated
3667            public void setPersistence(BookmarksEntryPersistence persistence) {
3668            }
3669    
3670            private static BookmarksEntryPersistence _persistence;
3671    }