001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.bookmarks.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the bookmarks entry service. This utility wraps {@link BookmarksEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see BookmarksEntryPersistence
037     * @see BookmarksEntryPersistenceImpl
038     * @generated
039     */
040    public class BookmarksEntryUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(BookmarksEntry bookmarksEntry) {
058                    getPersistence().clearCache(bookmarksEntry);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BookmarksEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BookmarksEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BookmarksEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BookmarksEntry update(BookmarksEntry bookmarksEntry)
101                    throws SystemException {
102                    return getPersistence().update(bookmarksEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(bookmarksEntry, serviceContext);
111            }
112    
113            /**
114            * Returns all the bookmarks entries where resourceBlockId = &#63;.
115            *
116            * @param resourceBlockId the resource block ID
117            * @return the matching bookmarks entries
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
121                    long resourceBlockId)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByResourceBlockId(resourceBlockId);
124            }
125    
126            /**
127            * Returns a range of all the bookmarks entries where resourceBlockId = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param resourceBlockId the resource block ID
134            * @param start the lower bound of the range of bookmarks entries
135            * @param end the upper bound of the range of bookmarks entries (not inclusive)
136            * @return the range of matching bookmarks entries
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
140                    long resourceBlockId, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence()
143                                       .findByResourceBlockId(resourceBlockId, start, end);
144            }
145    
146            /**
147            * Returns an ordered range of all the bookmarks entries where resourceBlockId = &#63;.
148            *
149            * <p>
150            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
151            * </p>
152            *
153            * @param resourceBlockId the resource block ID
154            * @param start the lower bound of the range of bookmarks entries
155            * @param end the upper bound of the range of bookmarks entries (not inclusive)
156            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
157            * @return the ordered range of matching bookmarks entries
158            * @throws SystemException if a system exception occurred
159            */
160            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
161                    long resourceBlockId, int start, int end,
162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence()
165                                       .findByResourceBlockId(resourceBlockId, start, end,
166                            orderByComparator);
167            }
168    
169            /**
170            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
171            *
172            * @param resourceBlockId the resource block ID
173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
174            * @return the first matching bookmarks entry
175            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First(
179                    long resourceBlockId,
180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.bookmarks.NoSuchEntryException {
183                    return getPersistence()
184                                       .findByResourceBlockId_First(resourceBlockId,
185                            orderByComparator);
186            }
187    
188            /**
189            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
190            *
191            * @param resourceBlockId the resource block ID
192            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
193            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
194            * @throws SystemException if a system exception occurred
195            */
196            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First(
197                    long resourceBlockId,
198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
199                    throws com.liferay.portal.kernel.exception.SystemException {
200                    return getPersistence()
201                                       .fetchByResourceBlockId_First(resourceBlockId,
202                            orderByComparator);
203            }
204    
205            /**
206            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
207            *
208            * @param resourceBlockId the resource block ID
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching bookmarks entry
211            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
212            * @throws SystemException if a system exception occurred
213            */
214            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last(
215                    long resourceBlockId,
216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
217                    throws com.liferay.portal.kernel.exception.SystemException,
218                            com.liferay.portlet.bookmarks.NoSuchEntryException {
219                    return getPersistence()
220                                       .findByResourceBlockId_Last(resourceBlockId,
221                            orderByComparator);
222            }
223    
224            /**
225            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
226            *
227            * @param resourceBlockId the resource block ID
228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
229            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
230            * @throws SystemException if a system exception occurred
231            */
232            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last(
233                    long resourceBlockId,
234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
235                    throws com.liferay.portal.kernel.exception.SystemException {
236                    return getPersistence()
237                                       .fetchByResourceBlockId_Last(resourceBlockId,
238                            orderByComparator);
239            }
240    
241            /**
242            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = &#63;.
243            *
244            * @param entryId the primary key of the current bookmarks entry
245            * @param resourceBlockId the resource block ID
246            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
247            * @return the previous, current, and next bookmarks entry
248            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
249            * @throws SystemException if a system exception occurred
250            */
251            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext(
252                    long entryId, long resourceBlockId,
253                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
254                    throws com.liferay.portal.kernel.exception.SystemException,
255                            com.liferay.portlet.bookmarks.NoSuchEntryException {
256                    return getPersistence()
257                                       .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId,
258                            orderByComparator);
259            }
260    
261            /**
262            * Removes all the bookmarks entries where resourceBlockId = &#63; from the database.
263            *
264            * @param resourceBlockId the resource block ID
265            * @throws SystemException if a system exception occurred
266            */
267            public static void removeByResourceBlockId(long resourceBlockId)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    getPersistence().removeByResourceBlockId(resourceBlockId);
270            }
271    
272            /**
273            * Returns the number of bookmarks entries where resourceBlockId = &#63;.
274            *
275            * @param resourceBlockId the resource block ID
276            * @return the number of matching bookmarks entries
277            * @throws SystemException if a system exception occurred
278            */
279            public static int countByResourceBlockId(long resourceBlockId)
280                    throws com.liferay.portal.kernel.exception.SystemException {
281                    return getPersistence().countByResourceBlockId(resourceBlockId);
282            }
283    
284            /**
285            * Returns all the bookmarks entries where uuid = &#63;.
286            *
287            * @param uuid the uuid
288            * @return the matching bookmarks entries
289            * @throws SystemException if a system exception occurred
290            */
291            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
292                    java.lang.String uuid)
293                    throws com.liferay.portal.kernel.exception.SystemException {
294                    return getPersistence().findByUuid(uuid);
295            }
296    
297            /**
298            * Returns a range of all the bookmarks entries where uuid = &#63;.
299            *
300            * <p>
301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
302            * </p>
303            *
304            * @param uuid the uuid
305            * @param start the lower bound of the range of bookmarks entries
306            * @param end the upper bound of the range of bookmarks entries (not inclusive)
307            * @return the range of matching bookmarks entries
308            * @throws SystemException if a system exception occurred
309            */
310            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
311                    java.lang.String uuid, int start, int end)
312                    throws com.liferay.portal.kernel.exception.SystemException {
313                    return getPersistence().findByUuid(uuid, start, end);
314            }
315    
316            /**
317            * Returns an ordered range of all the bookmarks entries where uuid = &#63;.
318            *
319            * <p>
320            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
321            * </p>
322            *
323            * @param uuid the uuid
324            * @param start the lower bound of the range of bookmarks entries
325            * @param end the upper bound of the range of bookmarks entries (not inclusive)
326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
327            * @return the ordered range of matching bookmarks entries
328            * @throws SystemException if a system exception occurred
329            */
330            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
331                    java.lang.String uuid, int start, int end,
332                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
333                    throws com.liferay.portal.kernel.exception.SystemException {
334                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
335            }
336    
337            /**
338            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
339            *
340            * @param uuid the uuid
341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
342            * @return the first matching bookmarks entry
343            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
344            * @throws SystemException if a system exception occurred
345            */
346            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First(
347                    java.lang.String uuid,
348                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
349                    throws com.liferay.portal.kernel.exception.SystemException,
350                            com.liferay.portlet.bookmarks.NoSuchEntryException {
351                    return getPersistence().findByUuid_First(uuid, orderByComparator);
352            }
353    
354            /**
355            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
356            *
357            * @param uuid the uuid
358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
359            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
360            * @throws SystemException if a system exception occurred
361            */
362            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First(
363                    java.lang.String uuid,
364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
365                    throws com.liferay.portal.kernel.exception.SystemException {
366                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
367            }
368    
369            /**
370            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
371            *
372            * @param uuid the uuid
373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
374            * @return the last matching bookmarks entry
375            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
376            * @throws SystemException if a system exception occurred
377            */
378            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last(
379                    java.lang.String uuid,
380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
381                    throws com.liferay.portal.kernel.exception.SystemException,
382                            com.liferay.portlet.bookmarks.NoSuchEntryException {
383                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
384            }
385    
386            /**
387            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
388            *
389            * @param uuid the uuid
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
392            * @throws SystemException if a system exception occurred
393            */
394            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last(
395                    java.lang.String uuid,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
399            }
400    
401            /**
402            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63;.
403            *
404            * @param entryId the primary key of the current bookmarks entry
405            * @param uuid the uuid
406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
407            * @return the previous, current, and next bookmarks entry
408            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
409            * @throws SystemException if a system exception occurred
410            */
411            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext(
412                    long entryId, java.lang.String uuid,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException,
415                            com.liferay.portlet.bookmarks.NoSuchEntryException {
416                    return getPersistence()
417                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
418            }
419    
420            /**
421            * Removes all the bookmarks entries where uuid = &#63; from the database.
422            *
423            * @param uuid the uuid
424            * @throws SystemException if a system exception occurred
425            */
426            public static void removeByUuid(java.lang.String uuid)
427                    throws com.liferay.portal.kernel.exception.SystemException {
428                    getPersistence().removeByUuid(uuid);
429            }
430    
431            /**
432            * Returns the number of bookmarks entries where uuid = &#63;.
433            *
434            * @param uuid the uuid
435            * @return the number of matching bookmarks entries
436            * @throws SystemException if a system exception occurred
437            */
438            public static int countByUuid(java.lang.String uuid)
439                    throws com.liferay.portal.kernel.exception.SystemException {
440                    return getPersistence().countByUuid(uuid);
441            }
442    
443            /**
444            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
445            *
446            * @param uuid the uuid
447            * @param groupId the group ID
448            * @return the matching bookmarks entry
449            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
450            * @throws SystemException if a system exception occurred
451            */
452            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G(
453                    java.lang.String uuid, long groupId)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.bookmarks.NoSuchEntryException {
456                    return getPersistence().findByUUID_G(uuid, groupId);
457            }
458    
459            /**
460            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
461            *
462            * @param uuid the uuid
463            * @param groupId the group ID
464            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
468                    java.lang.String uuid, long groupId)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence().fetchByUUID_G(uuid, groupId);
471            }
472    
473            /**
474            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
475            *
476            * @param uuid the uuid
477            * @param groupId the group ID
478            * @param retrieveFromCache whether to use the finder cache
479            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
480            * @throws SystemException if a system exception occurred
481            */
482            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
483                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
484                    throws com.liferay.portal.kernel.exception.SystemException {
485                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
486            }
487    
488            /**
489            * Removes the bookmarks entry where uuid = &#63; and groupId = &#63; from the database.
490            *
491            * @param uuid the uuid
492            * @param groupId the group ID
493            * @return the bookmarks entry that was removed
494            * @throws SystemException if a system exception occurred
495            */
496            public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G(
497                    java.lang.String uuid, long groupId)
498                    throws com.liferay.portal.kernel.exception.SystemException,
499                            com.liferay.portlet.bookmarks.NoSuchEntryException {
500                    return getPersistence().removeByUUID_G(uuid, groupId);
501            }
502    
503            /**
504            * Returns the number of bookmarks entries where uuid = &#63; and groupId = &#63;.
505            *
506            * @param uuid the uuid
507            * @param groupId the group ID
508            * @return the number of matching bookmarks entries
509            * @throws SystemException if a system exception occurred
510            */
511            public static int countByUUID_G(java.lang.String uuid, long groupId)
512                    throws com.liferay.portal.kernel.exception.SystemException {
513                    return getPersistence().countByUUID_G(uuid, groupId);
514            }
515    
516            /**
517            * Returns all the bookmarks entries where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @return the matching bookmarks entries
522            * @throws SystemException if a system exception occurred
523            */
524            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
525                    java.lang.String uuid, long companyId)
526                    throws com.liferay.portal.kernel.exception.SystemException {
527                    return getPersistence().findByUuid_C(uuid, companyId);
528            }
529    
530            /**
531            * Returns a range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
532            *
533            * <p>
534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
535            * </p>
536            *
537            * @param uuid the uuid
538            * @param companyId the company ID
539            * @param start the lower bound of the range of bookmarks entries
540            * @param end the upper bound of the range of bookmarks entries (not inclusive)
541            * @return the range of matching bookmarks entries
542            * @throws SystemException if a system exception occurred
543            */
544            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
545                    java.lang.String uuid, long companyId, int start, int end)
546                    throws com.liferay.portal.kernel.exception.SystemException {
547                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
548            }
549    
550            /**
551            * Returns an ordered range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
552            *
553            * <p>
554            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
555            * </p>
556            *
557            * @param uuid the uuid
558            * @param companyId the company ID
559            * @param start the lower bound of the range of bookmarks entries
560            * @param end the upper bound of the range of bookmarks entries (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @return the ordered range of matching bookmarks entries
563            * @throws SystemException if a system exception occurred
564            */
565            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
566                    java.lang.String uuid, long companyId, int start, int end,
567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
568                    throws com.liferay.portal.kernel.exception.SystemException {
569                    return getPersistence()
570                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
571            }
572    
573            /**
574            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
575            *
576            * @param uuid the uuid
577            * @param companyId the company ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching bookmarks entry
580            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First(
584                    java.lang.String uuid, long companyId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.bookmarks.NoSuchEntryException {
588                    return getPersistence()
589                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
590            }
591    
592            /**
593            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
594            *
595            * @param uuid the uuid
596            * @param companyId the company ID
597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
598            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
599            * @throws SystemException if a system exception occurred
600            */
601            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First(
602                    java.lang.String uuid, long companyId,
603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    return getPersistence()
606                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
611            *
612            * @param uuid the uuid
613            * @param companyId the company ID
614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
615            * @return the last matching bookmarks entry
616            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
617            * @throws SystemException if a system exception occurred
618            */
619            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last(
620                    java.lang.String uuid, long companyId,
621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
622                    throws com.liferay.portal.kernel.exception.SystemException,
623                            com.liferay.portlet.bookmarks.NoSuchEntryException {
624                    return getPersistence()
625                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
626            }
627    
628            /**
629            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
630            *
631            * @param uuid the uuid
632            * @param companyId the company ID
633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
634            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
635            * @throws SystemException if a system exception occurred
636            */
637            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last(
638                    java.lang.String uuid, long companyId,
639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
640                    throws com.liferay.portal.kernel.exception.SystemException {
641                    return getPersistence()
642                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
643            }
644    
645            /**
646            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
647            *
648            * @param entryId the primary key of the current bookmarks entry
649            * @param uuid the uuid
650            * @param companyId the company ID
651            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
652            * @return the previous, current, and next bookmarks entry
653            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
654            * @throws SystemException if a system exception occurred
655            */
656            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext(
657                    long entryId, java.lang.String uuid, long companyId,
658                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
659                    throws com.liferay.portal.kernel.exception.SystemException,
660                            com.liferay.portlet.bookmarks.NoSuchEntryException {
661                    return getPersistence()
662                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
663                            orderByComparator);
664            }
665    
666            /**
667            * Removes all the bookmarks entries where uuid = &#63; and companyId = &#63; from the database.
668            *
669            * @param uuid the uuid
670            * @param companyId the company ID
671            * @throws SystemException if a system exception occurred
672            */
673            public static void removeByUuid_C(java.lang.String uuid, long companyId)
674                    throws com.liferay.portal.kernel.exception.SystemException {
675                    getPersistence().removeByUuid_C(uuid, companyId);
676            }
677    
678            /**
679            * Returns the number of bookmarks entries where uuid = &#63; and companyId = &#63;.
680            *
681            * @param uuid the uuid
682            * @param companyId the company ID
683            * @return the number of matching bookmarks entries
684            * @throws SystemException if a system exception occurred
685            */
686            public static int countByUuid_C(java.lang.String uuid, long companyId)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().countByUuid_C(uuid, companyId);
689            }
690    
691            /**
692            * Returns all the bookmarks entries where groupId = &#63;.
693            *
694            * @param groupId the group ID
695            * @return the matching bookmarks entries
696            * @throws SystemException if a system exception occurred
697            */
698            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
699                    long groupId)
700                    throws com.liferay.portal.kernel.exception.SystemException {
701                    return getPersistence().findByGroupId(groupId);
702            }
703    
704            /**
705            * Returns a range of all the bookmarks entries where groupId = &#63;.
706            *
707            * <p>
708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
709            * </p>
710            *
711            * @param groupId the group ID
712            * @param start the lower bound of the range of bookmarks entries
713            * @param end the upper bound of the range of bookmarks entries (not inclusive)
714            * @return the range of matching bookmarks entries
715            * @throws SystemException if a system exception occurred
716            */
717            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
718                    long groupId, int start, int end)
719                    throws com.liferay.portal.kernel.exception.SystemException {
720                    return getPersistence().findByGroupId(groupId, start, end);
721            }
722    
723            /**
724            * Returns an ordered range of all the bookmarks entries where groupId = &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
728            * </p>
729            *
730            * @param groupId the group ID
731            * @param start the lower bound of the range of bookmarks entries
732            * @param end the upper bound of the range of bookmarks entries (not inclusive)
733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
734            * @return the ordered range of matching bookmarks entries
735            * @throws SystemException if a system exception occurred
736            */
737            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
738                    long groupId, int start, int end,
739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence()
742                                       .findByGroupId(groupId, start, end, orderByComparator);
743            }
744    
745            /**
746            * Returns the first bookmarks entry in the ordered set where groupId = &#63;.
747            *
748            * @param groupId the group ID
749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
750            * @return the first matching bookmarks entry
751            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First(
755                    long groupId,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.bookmarks.NoSuchEntryException {
759                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
760            }
761    
762            /**
763            * Returns the first bookmarks entry in the ordered set where groupId = &#63;.
764            *
765            * @param groupId the group ID
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
768            * @throws SystemException if a system exception occurred
769            */
770            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_First(
771                    long groupId,
772                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
773                    throws com.liferay.portal.kernel.exception.SystemException {
774                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
775            }
776    
777            /**
778            * Returns the last bookmarks entry in the ordered set where groupId = &#63;.
779            *
780            * @param groupId the group ID
781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
782            * @return the last matching bookmarks entry
783            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
784            * @throws SystemException if a system exception occurred
785            */
786            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_Last(
787                    long groupId,
788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
789                    throws com.liferay.portal.kernel.exception.SystemException,
790                            com.liferay.portlet.bookmarks.NoSuchEntryException {
791                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
792            }
793    
794            /**
795            * Returns the last bookmarks entry in the ordered set where groupId = &#63;.
796            *
797            * @param groupId the group ID
798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
799            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
800            * @throws SystemException if a system exception occurred
801            */
802            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_Last(
803                    long groupId,
804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
807            }
808    
809            /**
810            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63;.
811            *
812            * @param entryId the primary key of the current bookmarks entry
813            * @param groupId the group ID
814            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
815            * @return the previous, current, and next bookmarks entry
816            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
817            * @throws SystemException if a system exception occurred
818            */
819            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext(
820                    long entryId, long groupId,
821                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
822                    throws com.liferay.portal.kernel.exception.SystemException,
823                            com.liferay.portlet.bookmarks.NoSuchEntryException {
824                    return getPersistence()
825                                       .findByGroupId_PrevAndNext(entryId, groupId,
826                            orderByComparator);
827            }
828    
829            /**
830            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63;.
831            *
832            * @param groupId the group ID
833            * @return the matching bookmarks entries that the user has permission to view
834            * @throws SystemException if a system exception occurred
835            */
836            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
837                    long groupId)
838                    throws com.liferay.portal.kernel.exception.SystemException {
839                    return getPersistence().filterFindByGroupId(groupId);
840            }
841    
842            /**
843            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63;.
844            *
845            * <p>
846            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.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.
847            * </p>
848            *
849            * @param groupId the group ID
850            * @param start the lower bound of the range of bookmarks entries
851            * @param end the upper bound of the range of bookmarks entries (not inclusive)
852            * @return the range of matching bookmarks entries that the user has permission to view
853            * @throws SystemException if a system exception occurred
854            */
855            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
856                    long groupId, int start, int end)
857                    throws com.liferay.portal.kernel.exception.SystemException {
858                    return getPersistence().filterFindByGroupId(groupId, start, end);
859            }
860    
861            /**
862            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63;.
863            *
864            * <p>
865            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.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.
866            * </p>
867            *
868            * @param groupId the group ID
869            * @param start the lower bound of the range of bookmarks entries
870            * @param end the upper bound of the range of bookmarks entries (not inclusive)
871            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
872            * @return the ordered range of matching bookmarks entries that the user has permission to view
873            * @throws SystemException if a system exception occurred
874            */
875            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
876                    long groupId, int start, int end,
877                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
878                    throws com.liferay.portal.kernel.exception.SystemException {
879                    return getPersistence()
880                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
881            }
882    
883            /**
884            * Returns the bookmarks 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;.
885            *
886            * @param entryId the primary key of the current bookmarks entry
887            * @param groupId the group ID
888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
889            * @return the previous, current, and next bookmarks entry
890            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
891            * @throws SystemException if a system exception occurred
892            */
893            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByGroupId_PrevAndNext(
894                    long entryId, long groupId,
895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
896                    throws com.liferay.portal.kernel.exception.SystemException,
897                            com.liferay.portlet.bookmarks.NoSuchEntryException {
898                    return getPersistence()
899                                       .filterFindByGroupId_PrevAndNext(entryId, groupId,
900                            orderByComparator);
901            }
902    
903            /**
904            * Removes all the bookmarks entries where groupId = &#63; from the database.
905            *
906            * @param groupId the group ID
907            * @throws SystemException if a system exception occurred
908            */
909            public static void removeByGroupId(long groupId)
910                    throws com.liferay.portal.kernel.exception.SystemException {
911                    getPersistence().removeByGroupId(groupId);
912            }
913    
914            /**
915            * Returns the number of bookmarks entries where groupId = &#63;.
916            *
917            * @param groupId the group ID
918            * @return the number of matching bookmarks entries
919            * @throws SystemException if a system exception occurred
920            */
921            public static int countByGroupId(long groupId)
922                    throws com.liferay.portal.kernel.exception.SystemException {
923                    return getPersistence().countByGroupId(groupId);
924            }
925    
926            /**
927            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63;.
928            *
929            * @param groupId the group ID
930            * @return the number of matching bookmarks entries that the user has permission to view
931            * @throws SystemException if a system exception occurred
932            */
933            public static int filterCountByGroupId(long groupId)
934                    throws com.liferay.portal.kernel.exception.SystemException {
935                    return getPersistence().filterCountByGroupId(groupId);
936            }
937    
938            /**
939            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63;.
940            *
941            * @param groupId the group ID
942            * @param userId the user ID
943            * @return the matching bookmarks entries
944            * @throws SystemException if a system exception occurred
945            */
946            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
947                    long groupId, long userId)
948                    throws com.liferay.portal.kernel.exception.SystemException {
949                    return getPersistence().findByG_U(groupId, userId);
950            }
951    
952            /**
953            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63;.
954            *
955            * <p>
956            * 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.
957            * </p>
958            *
959            * @param groupId the group ID
960            * @param userId the user ID
961            * @param start the lower bound of the range of bookmarks entries
962            * @param end the upper bound of the range of bookmarks entries (not inclusive)
963            * @return the range of matching bookmarks entries
964            * @throws SystemException if a system exception occurred
965            */
966            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
967                    long groupId, long userId, int start, int end)
968                    throws com.liferay.portal.kernel.exception.SystemException {
969                    return getPersistence().findByG_U(groupId, userId, start, end);
970            }
971    
972            /**
973            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63;.
974            *
975            * <p>
976            * 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.
977            * </p>
978            *
979            * @param groupId the group ID
980            * @param userId the user ID
981            * @param start the lower bound of the range of bookmarks entries
982            * @param end the upper bound of the range of bookmarks entries (not inclusive)
983            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
984            * @return the ordered range of matching bookmarks entries
985            * @throws SystemException if a system exception occurred
986            */
987            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
988                    long groupId, long userId, int start, int end,
989                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
990                    throws com.liferay.portal.kernel.exception.SystemException {
991                    return getPersistence()
992                                       .findByG_U(groupId, userId, start, end, orderByComparator);
993            }
994    
995            /**
996            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
997            *
998            * @param groupId the group ID
999            * @param userId the user ID
1000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1001            * @return the first matching bookmarks entry
1002            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1003            * @throws SystemException if a system exception occurred
1004            */
1005            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First(
1006                    long groupId, long userId,
1007                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1008                    throws com.liferay.portal.kernel.exception.SystemException,
1009                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1010                    return getPersistence()
1011                                       .findByG_U_First(groupId, userId, orderByComparator);
1012            }
1013    
1014            /**
1015            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
1016            *
1017            * @param groupId the group ID
1018            * @param userId the user ID
1019            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1020            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1021            * @throws SystemException if a system exception occurred
1022            */
1023            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_First(
1024                    long groupId, long userId,
1025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1026                    throws com.liferay.portal.kernel.exception.SystemException {
1027                    return getPersistence()
1028                                       .fetchByG_U_First(groupId, userId, orderByComparator);
1029            }
1030    
1031            /**
1032            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
1033            *
1034            * @param groupId the group ID
1035            * @param userId the user ID
1036            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1037            * @return the last matching bookmarks entry
1038            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1039            * @throws SystemException if a system exception occurred
1040            */
1041            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last(
1042                    long groupId, long userId,
1043                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1044                    throws com.liferay.portal.kernel.exception.SystemException,
1045                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1046                    return getPersistence()
1047                                       .findByG_U_Last(groupId, userId, orderByComparator);
1048            }
1049    
1050            /**
1051            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
1052            *
1053            * @param groupId the group ID
1054            * @param userId the user ID
1055            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1056            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1057            * @throws SystemException if a system exception occurred
1058            */
1059            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_Last(
1060                    long groupId, long userId,
1061                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1062                    throws com.liferay.portal.kernel.exception.SystemException {
1063                    return getPersistence()
1064                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
1065            }
1066    
1067            /**
1068            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
1069            *
1070            * @param entryId the primary key of the current bookmarks entry
1071            * @param groupId the group ID
1072            * @param userId the user ID
1073            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1074            * @return the previous, current, and next bookmarks entry
1075            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1076            * @throws SystemException if a system exception occurred
1077            */
1078            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext(
1079                    long entryId, long groupId, long userId,
1080                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1081                    throws com.liferay.portal.kernel.exception.SystemException,
1082                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1083                    return getPersistence()
1084                                       .findByG_U_PrevAndNext(entryId, groupId, userId,
1085                            orderByComparator);
1086            }
1087    
1088            /**
1089            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1090            *
1091            * @param groupId the group ID
1092            * @param userId the user ID
1093            * @return the matching bookmarks entries that the user has permission to view
1094            * @throws SystemException if a system exception occurred
1095            */
1096            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
1097                    long groupId, long userId)
1098                    throws com.liferay.portal.kernel.exception.SystemException {
1099                    return getPersistence().filterFindByG_U(groupId, userId);
1100            }
1101    
1102            /**
1103            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1104            *
1105            * <p>
1106            * 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.
1107            * </p>
1108            *
1109            * @param groupId the group ID
1110            * @param userId the user ID
1111            * @param start the lower bound of the range of bookmarks entries
1112            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1113            * @return the range of matching bookmarks entries that the user has permission to view
1114            * @throws SystemException if a system exception occurred
1115            */
1116            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
1117                    long groupId, long userId, int start, int end)
1118                    throws com.liferay.portal.kernel.exception.SystemException {
1119                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
1120            }
1121    
1122            /**
1123            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63;.
1124            *
1125            * <p>
1126            * 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.
1127            * </p>
1128            *
1129            * @param groupId the group ID
1130            * @param userId the user ID
1131            * @param start the lower bound of the range of bookmarks entries
1132            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1133            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1134            * @return the ordered range of matching bookmarks entries that the user has permission to view
1135            * @throws SystemException if a system exception occurred
1136            */
1137            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
1138                    long groupId, long userId, int start, int end,
1139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1140                    throws com.liferay.portal.kernel.exception.SystemException {
1141                    return getPersistence()
1142                                       .filterFindByG_U(groupId, userId, start, end,
1143                            orderByComparator);
1144            }
1145    
1146            /**
1147            * 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;.
1148            *
1149            * @param entryId the primary key of the current bookmarks entry
1150            * @param groupId the group ID
1151            * @param userId the user ID
1152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1153            * @return the previous, current, and next bookmarks entry
1154            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1155            * @throws SystemException if a system exception occurred
1156            */
1157            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_PrevAndNext(
1158                    long entryId, long groupId, long userId,
1159                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1160                    throws com.liferay.portal.kernel.exception.SystemException,
1161                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1162                    return getPersistence()
1163                                       .filterFindByG_U_PrevAndNext(entryId, groupId, userId,
1164                            orderByComparator);
1165            }
1166    
1167            /**
1168            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; from the database.
1169            *
1170            * @param groupId the group ID
1171            * @param userId the user ID
1172            * @throws SystemException if a system exception occurred
1173            */
1174            public static void removeByG_U(long groupId, long userId)
1175                    throws com.liferay.portal.kernel.exception.SystemException {
1176                    getPersistence().removeByG_U(groupId, userId);
1177            }
1178    
1179            /**
1180            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63;.
1181            *
1182            * @param groupId the group ID
1183            * @param userId the user ID
1184            * @return the number of matching bookmarks entries
1185            * @throws SystemException if a system exception occurred
1186            */
1187            public static int countByG_U(long groupId, long userId)
1188                    throws com.liferay.portal.kernel.exception.SystemException {
1189                    return getPersistence().countByG_U(groupId, userId);
1190            }
1191    
1192            /**
1193            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1194            *
1195            * @param groupId the group ID
1196            * @param userId the user ID
1197            * @return the number of matching bookmarks entries that the user has permission to view
1198            * @throws SystemException if a system exception occurred
1199            */
1200            public static int filterCountByG_U(long groupId, long userId)
1201                    throws com.liferay.portal.kernel.exception.SystemException {
1202                    return getPersistence().filterCountByG_U(groupId, userId);
1203            }
1204    
1205            /**
1206            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63;.
1207            *
1208            * @param groupId the group ID
1209            * @param folderId the folder ID
1210            * @return the matching bookmarks entries
1211            * @throws SystemException if a system exception occurred
1212            */
1213            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1214                    long groupId, long folderId)
1215                    throws com.liferay.portal.kernel.exception.SystemException {
1216                    return getPersistence().findByG_F(groupId, folderId);
1217            }
1218    
1219            /**
1220            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
1221            *
1222            * <p>
1223            * 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.
1224            * </p>
1225            *
1226            * @param groupId the group ID
1227            * @param folderId the folder ID
1228            * @param start the lower bound of the range of bookmarks entries
1229            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1230            * @return the range of matching bookmarks entries
1231            * @throws SystemException if a system exception occurred
1232            */
1233            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1234                    long groupId, long folderId, int start, int end)
1235                    throws com.liferay.portal.kernel.exception.SystemException {
1236                    return getPersistence().findByG_F(groupId, folderId, start, end);
1237            }
1238    
1239            /**
1240            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
1241            *
1242            * <p>
1243            * 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.
1244            * </p>
1245            *
1246            * @param groupId the group ID
1247            * @param folderId the folder ID
1248            * @param start the lower bound of the range of bookmarks entries
1249            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1250            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1251            * @return the ordered range of matching bookmarks entries
1252            * @throws SystemException if a system exception occurred
1253            */
1254            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1255                    long groupId, long folderId, int start, int end,
1256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1257                    throws com.liferay.portal.kernel.exception.SystemException {
1258                    return getPersistence()
1259                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
1260            }
1261    
1262            /**
1263            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1264            *
1265            * @param groupId the group ID
1266            * @param folderId the folder ID
1267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1268            * @return the first matching bookmarks entry
1269            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1270            * @throws SystemException if a system exception occurred
1271            */
1272            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
1273                    long groupId, long folderId,
1274                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1275                    throws com.liferay.portal.kernel.exception.SystemException,
1276                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1277                    return getPersistence()
1278                                       .findByG_F_First(groupId, folderId, orderByComparator);
1279            }
1280    
1281            /**
1282            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1283            *
1284            * @param groupId the group ID
1285            * @param folderId the folder ID
1286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1287            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1288            * @throws SystemException if a system exception occurred
1289            */
1290            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First(
1291                    long groupId, long folderId,
1292                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1293                    throws com.liferay.portal.kernel.exception.SystemException {
1294                    return getPersistence()
1295                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
1296            }
1297    
1298            /**
1299            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1300            *
1301            * @param groupId the group ID
1302            * @param folderId the folder ID
1303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1304            * @return the last matching bookmarks entry
1305            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1306            * @throws SystemException if a system exception occurred
1307            */
1308            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
1309                    long groupId, long folderId,
1310                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1311                    throws com.liferay.portal.kernel.exception.SystemException,
1312                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1313                    return getPersistence()
1314                                       .findByG_F_Last(groupId, folderId, orderByComparator);
1315            }
1316    
1317            /**
1318            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1319            *
1320            * @param groupId the group ID
1321            * @param folderId the folder ID
1322            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1323            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1324            * @throws SystemException if a system exception occurred
1325            */
1326            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last(
1327                    long groupId, long folderId,
1328                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1329                    throws com.liferay.portal.kernel.exception.SystemException {
1330                    return getPersistence()
1331                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
1332            }
1333    
1334            /**
1335            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1336            *
1337            * @param entryId the primary key of the current bookmarks entry
1338            * @param groupId the group ID
1339            * @param folderId the folder ID
1340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1341            * @return the previous, current, and next bookmarks entry
1342            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1343            * @throws SystemException if a system exception occurred
1344            */
1345            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
1346                    long entryId, long groupId, long folderId,
1347                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1348                    throws com.liferay.portal.kernel.exception.SystemException,
1349                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1350                    return getPersistence()
1351                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
1352                            orderByComparator);
1353            }
1354    
1355            /**
1356            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1357            *
1358            * @param groupId the group ID
1359            * @param folderId the folder ID
1360            * @return the matching bookmarks entries that the user has permission to view
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1364                    long groupId, long folderId)
1365                    throws com.liferay.portal.kernel.exception.SystemException {
1366                    return getPersistence().filterFindByG_F(groupId, folderId);
1367            }
1368    
1369            /**
1370            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1371            *
1372            * <p>
1373            * 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.
1374            * </p>
1375            *
1376            * @param groupId the group ID
1377            * @param folderId the folder ID
1378            * @param start the lower bound of the range of bookmarks entries
1379            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1380            * @return the range of matching bookmarks entries that the user has permission to view
1381            * @throws SystemException if a system exception occurred
1382            */
1383            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1384                    long groupId, long folderId, int start, int end)
1385                    throws com.liferay.portal.kernel.exception.SystemException {
1386                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
1387            }
1388    
1389            /**
1390            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
1391            *
1392            * <p>
1393            * 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.
1394            * </p>
1395            *
1396            * @param groupId the group ID
1397            * @param folderId the folder ID
1398            * @param start the lower bound of the range of bookmarks entries
1399            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1400            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1401            * @return the ordered range of matching bookmarks entries that the user has permission to view
1402            * @throws SystemException if a system exception occurred
1403            */
1404            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1405                    long groupId, long folderId, int start, int end,
1406                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1407                    throws com.liferay.portal.kernel.exception.SystemException {
1408                    return getPersistence()
1409                                       .filterFindByG_F(groupId, folderId, start, end,
1410                            orderByComparator);
1411            }
1412    
1413            /**
1414            * 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;.
1415            *
1416            * @param entryId the primary key of the current bookmarks entry
1417            * @param groupId the group ID
1418            * @param folderId the folder ID
1419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1420            * @return the previous, current, and next bookmarks entry
1421            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1422            * @throws SystemException if a system exception occurred
1423            */
1424            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
1425                    long entryId, long groupId, long folderId,
1426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1427                    throws com.liferay.portal.kernel.exception.SystemException,
1428                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1429                    return getPersistence()
1430                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
1431                            orderByComparator);
1432            }
1433    
1434            /**
1435            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1436            *
1437            * @param groupId the group ID
1438            * @param folderIds the folder IDs
1439            * @return the matching bookmarks entries that the user has permission to view
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1443                    long groupId, long[] folderIds)
1444                    throws com.liferay.portal.kernel.exception.SystemException {
1445                    return getPersistence().filterFindByG_F(groupId, folderIds);
1446            }
1447    
1448            /**
1449            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1450            *
1451            * <p>
1452            * 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.
1453            * </p>
1454            *
1455            * @param groupId the group ID
1456            * @param folderIds the folder IDs
1457            * @param start the lower bound of the range of bookmarks entries
1458            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1459            * @return the range of matching bookmarks entries that the user has permission to view
1460            * @throws SystemException if a system exception occurred
1461            */
1462            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1463                    long groupId, long[] folderIds, int start, int end)
1464                    throws com.liferay.portal.kernel.exception.SystemException {
1465                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
1466            }
1467    
1468            /**
1469            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1470            *
1471            * <p>
1472            * 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.
1473            * </p>
1474            *
1475            * @param groupId the group ID
1476            * @param folderIds the folder IDs
1477            * @param start the lower bound of the range of bookmarks entries
1478            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1479            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1480            * @return the ordered range of matching bookmarks entries that the user has permission to view
1481            * @throws SystemException if a system exception occurred
1482            */
1483            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1484                    long groupId, long[] folderIds, int start, int end,
1485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1486                    throws com.liferay.portal.kernel.exception.SystemException {
1487                    return getPersistence()
1488                                       .filterFindByG_F(groupId, folderIds, start, end,
1489                            orderByComparator);
1490            }
1491    
1492            /**
1493            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1494            *
1495            * <p>
1496            * 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.
1497            * </p>
1498            *
1499            * @param groupId the group ID
1500            * @param folderIds the folder IDs
1501            * @return the matching bookmarks entries
1502            * @throws SystemException if a system exception occurred
1503            */
1504            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1505                    long groupId, long[] folderIds)
1506                    throws com.liferay.portal.kernel.exception.SystemException {
1507                    return getPersistence().findByG_F(groupId, folderIds);
1508            }
1509    
1510            /**
1511            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1512            *
1513            * <p>
1514            * 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.
1515            * </p>
1516            *
1517            * @param groupId the group ID
1518            * @param folderIds the folder IDs
1519            * @param start the lower bound of the range of bookmarks entries
1520            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1521            * @return the range of matching bookmarks entries
1522            * @throws SystemException if a system exception occurred
1523            */
1524            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1525                    long groupId, long[] folderIds, int start, int end)
1526                    throws com.liferay.portal.kernel.exception.SystemException {
1527                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1528            }
1529    
1530            /**
1531            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1532            *
1533            * <p>
1534            * 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.
1535            * </p>
1536            *
1537            * @param groupId the group ID
1538            * @param folderIds the folder IDs
1539            * @param start the lower bound of the range of bookmarks entries
1540            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1541            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1542            * @return the ordered range of matching bookmarks entries
1543            * @throws SystemException if a system exception occurred
1544            */
1545            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1546                    long groupId, long[] folderIds, int start, int end,
1547                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1548                    throws com.liferay.portal.kernel.exception.SystemException {
1549                    return getPersistence()
1550                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1551            }
1552    
1553            /**
1554            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1555            *
1556            * @param groupId the group ID
1557            * @param folderId the folder ID
1558            * @throws SystemException if a system exception occurred
1559            */
1560            public static void removeByG_F(long groupId, long folderId)
1561                    throws com.liferay.portal.kernel.exception.SystemException {
1562                    getPersistence().removeByG_F(groupId, folderId);
1563            }
1564    
1565            /**
1566            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63;.
1567            *
1568            * @param groupId the group ID
1569            * @param folderId the folder ID
1570            * @return the number of matching bookmarks entries
1571            * @throws SystemException if a system exception occurred
1572            */
1573            public static int countByG_F(long groupId, long folderId)
1574                    throws com.liferay.portal.kernel.exception.SystemException {
1575                    return getPersistence().countByG_F(groupId, folderId);
1576            }
1577    
1578            /**
1579            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63;.
1580            *
1581            * @param groupId the group ID
1582            * @param folderIds the folder IDs
1583            * @return the number of matching bookmarks entries
1584            * @throws SystemException if a system exception occurred
1585            */
1586            public static int countByG_F(long groupId, long[] folderIds)
1587                    throws com.liferay.portal.kernel.exception.SystemException {
1588                    return getPersistence().countByG_F(groupId, folderIds);
1589            }
1590    
1591            /**
1592            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1593            *
1594            * @param groupId the group ID
1595            * @param folderId the folder ID
1596            * @return the number of matching bookmarks entries that the user has permission to view
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static int filterCountByG_F(long groupId, long folderId)
1600                    throws com.liferay.portal.kernel.exception.SystemException {
1601                    return getPersistence().filterCountByG_F(groupId, folderId);
1602            }
1603    
1604            /**
1605            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1606            *
1607            * @param groupId the group ID
1608            * @param folderIds the folder IDs
1609            * @return the number of matching bookmarks entries that the user has permission to view
1610            * @throws SystemException if a system exception occurred
1611            */
1612            public static int filterCountByG_F(long groupId, long[] folderIds)
1613                    throws com.liferay.portal.kernel.exception.SystemException {
1614                    return getPersistence().filterCountByG_F(groupId, folderIds);
1615            }
1616    
1617            /**
1618            * Caches the bookmarks entry in the entity cache if it is enabled.
1619            *
1620            * @param bookmarksEntry the bookmarks entry
1621            */
1622            public static void cacheResult(
1623                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
1624                    getPersistence().cacheResult(bookmarksEntry);
1625            }
1626    
1627            /**
1628            * Caches the bookmarks entries in the entity cache if it is enabled.
1629            *
1630            * @param bookmarksEntries the bookmarks entries
1631            */
1632            public static void cacheResult(
1633                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
1634                    getPersistence().cacheResult(bookmarksEntries);
1635            }
1636    
1637            /**
1638            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
1639            *
1640            * @param entryId the primary key for the new bookmarks entry
1641            * @return the new bookmarks entry
1642            */
1643            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
1644                    long entryId) {
1645                    return getPersistence().create(entryId);
1646            }
1647    
1648            /**
1649            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
1650            *
1651            * @param entryId the primary key of the bookmarks entry
1652            * @return the bookmarks entry that was removed
1653            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1654            * @throws SystemException if a system exception occurred
1655            */
1656            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
1657                    long entryId)
1658                    throws com.liferay.portal.kernel.exception.SystemException,
1659                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1660                    return getPersistence().remove(entryId);
1661            }
1662    
1663            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
1664                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry)
1665                    throws com.liferay.portal.kernel.exception.SystemException {
1666                    return getPersistence().updateImpl(bookmarksEntry);
1667            }
1668    
1669            /**
1670            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
1671            *
1672            * @param entryId the primary key of the bookmarks entry
1673            * @return the bookmarks entry
1674            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1675            * @throws SystemException if a system exception occurred
1676            */
1677            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
1678                    long entryId)
1679                    throws com.liferay.portal.kernel.exception.SystemException,
1680                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1681                    return getPersistence().findByPrimaryKey(entryId);
1682            }
1683    
1684            /**
1685            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
1686            *
1687            * @param entryId the primary key of the bookmarks entry
1688            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
1689            * @throws SystemException if a system exception occurred
1690            */
1691            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
1692                    long entryId)
1693                    throws com.liferay.portal.kernel.exception.SystemException {
1694                    return getPersistence().fetchByPrimaryKey(entryId);
1695            }
1696    
1697            /**
1698            * Returns all the bookmarks entries.
1699            *
1700            * @return the bookmarks entries
1701            * @throws SystemException if a system exception occurred
1702            */
1703            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
1704                    throws com.liferay.portal.kernel.exception.SystemException {
1705                    return getPersistence().findAll();
1706            }
1707    
1708            /**
1709            * Returns a range of all the bookmarks entries.
1710            *
1711            * <p>
1712            * 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.
1713            * </p>
1714            *
1715            * @param start the lower bound of the range of bookmarks entries
1716            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1717            * @return the range of bookmarks entries
1718            * @throws SystemException if a system exception occurred
1719            */
1720            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
1721                    int start, int end)
1722                    throws com.liferay.portal.kernel.exception.SystemException {
1723                    return getPersistence().findAll(start, end);
1724            }
1725    
1726            /**
1727            * Returns an ordered range of all the bookmarks entries.
1728            *
1729            * <p>
1730            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1731            * </p>
1732            *
1733            * @param start the lower bound of the range of bookmarks entries
1734            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1735            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1736            * @return the ordered range of bookmarks entries
1737            * @throws SystemException if a system exception occurred
1738            */
1739            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
1740                    int start, int end,
1741                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1742                    throws com.liferay.portal.kernel.exception.SystemException {
1743                    return getPersistence().findAll(start, end, orderByComparator);
1744            }
1745    
1746            /**
1747            * Removes all the bookmarks entries from the database.
1748            *
1749            * @throws SystemException if a system exception occurred
1750            */
1751            public static void removeAll()
1752                    throws com.liferay.portal.kernel.exception.SystemException {
1753                    getPersistence().removeAll();
1754            }
1755    
1756            /**
1757            * Returns the number of bookmarks entries.
1758            *
1759            * @return the number of bookmarks entries
1760            * @throws SystemException if a system exception occurred
1761            */
1762            public static int countAll()
1763                    throws com.liferay.portal.kernel.exception.SystemException {
1764                    return getPersistence().countAll();
1765            }
1766    
1767            public static BookmarksEntryPersistence getPersistence() {
1768                    if (_persistence == null) {
1769                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
1770    
1771                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
1772                                    "_persistence");
1773                    }
1774    
1775                    return _persistence;
1776            }
1777    
1778            /**
1779             * @deprecated
1780             */
1781            public void setPersistence(BookmarksEntryPersistence persistence) {
1782            }
1783    
1784            private static BookmarksEntryPersistence _persistence;
1785    }