001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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#remove(com.liferay.portal.model.BaseModel)
099             */
100            public static BookmarksEntry remove(BookmarksEntry bookmarksEntry)
101                    throws SystemException {
102                    return getPersistence().remove(bookmarksEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
107             */
108            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
109                    boolean merge) throws SystemException {
110                    return getPersistence().update(bookmarksEntry, merge);
111            }
112    
113            /**
114             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
115             */
116            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
117                    boolean merge, ServiceContext serviceContext) throws SystemException {
118                    return getPersistence().update(bookmarksEntry, merge, serviceContext);
119            }
120    
121            /**
122            * Caches the bookmarks entry in the entity cache if it is enabled.
123            *
124            * @param bookmarksEntry the bookmarks entry to cache
125            */
126            public static void cacheResult(
127                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
128                    getPersistence().cacheResult(bookmarksEntry);
129            }
130    
131            /**
132            * Caches the bookmarks entries in the entity cache if it is enabled.
133            *
134            * @param bookmarksEntries the bookmarks entries to cache
135            */
136            public static void cacheResult(
137                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
138                    getPersistence().cacheResult(bookmarksEntries);
139            }
140    
141            /**
142            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
143            *
144            * @param entryId the primary key for the new bookmarks entry
145            * @return the new bookmarks entry
146            */
147            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
148                    long entryId) {
149                    return getPersistence().create(entryId);
150            }
151    
152            /**
153            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
154            *
155            * @param entryId the primary key of the bookmarks entry to remove
156            * @return the bookmarks entry that was removed
157            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
158            * @throws SystemException if a system exception occurred
159            */
160            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
161                    long entryId)
162                    throws com.liferay.portal.kernel.exception.SystemException,
163                            com.liferay.portlet.bookmarks.NoSuchEntryException {
164                    return getPersistence().remove(entryId);
165            }
166    
167            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
168                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry,
169                    boolean merge)
170                    throws com.liferay.portal.kernel.exception.SystemException {
171                    return getPersistence().updateImpl(bookmarksEntry, merge);
172            }
173    
174            /**
175            * Finds the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
176            *
177            * @param entryId the primary key of the bookmarks entry to find
178            * @return the bookmarks entry
179            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
180            * @throws SystemException if a system exception occurred
181            */
182            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
183                    long entryId)
184                    throws com.liferay.portal.kernel.exception.SystemException,
185                            com.liferay.portlet.bookmarks.NoSuchEntryException {
186                    return getPersistence().findByPrimaryKey(entryId);
187            }
188    
189            /**
190            * Finds the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
191            *
192            * @param entryId the primary key of the bookmarks entry to find
193            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
194            * @throws SystemException if a system exception occurred
195            */
196            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
197                    long entryId)
198                    throws com.liferay.portal.kernel.exception.SystemException {
199                    return getPersistence().fetchByPrimaryKey(entryId);
200            }
201    
202            /**
203            * Finds all the bookmarks entries where uuid = &#63;.
204            *
205            * @param uuid the uuid to search with
206            * @return the matching bookmarks entries
207            * @throws SystemException if a system exception occurred
208            */
209            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
210                    java.lang.String uuid)
211                    throws com.liferay.portal.kernel.exception.SystemException {
212                    return getPersistence().findByUuid(uuid);
213            }
214    
215            /**
216            * Finds a range of all the bookmarks entries where uuid = &#63;.
217            *
218            * <p>
219            * 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.
220            * </p>
221            *
222            * @param uuid the uuid to search with
223            * @param start the lower bound of the range of bookmarks entries to return
224            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
225            * @return the range of matching bookmarks entries
226            * @throws SystemException if a system exception occurred
227            */
228            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
229                    java.lang.String uuid, int start, int end)
230                    throws com.liferay.portal.kernel.exception.SystemException {
231                    return getPersistence().findByUuid(uuid, start, end);
232            }
233    
234            /**
235            * Finds an ordered range of all the bookmarks entries where uuid = &#63;.
236            *
237            * <p>
238            * 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.
239            * </p>
240            *
241            * @param uuid the uuid to search with
242            * @param start the lower bound of the range of bookmarks entries to return
243            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
244            * @param orderByComparator the comparator to order the results by
245            * @return the ordered range of matching bookmarks entries
246            * @throws SystemException if a system exception occurred
247            */
248            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
249                    java.lang.String uuid, int start, int end,
250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
251                    throws com.liferay.portal.kernel.exception.SystemException {
252                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
253            }
254    
255            /**
256            * Finds the first bookmarks entry in the ordered set where uuid = &#63;.
257            *
258            * <p>
259            * 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.
260            * </p>
261            *
262            * @param uuid the uuid to search with
263            * @param orderByComparator the comparator to order the set by
264            * @return the first matching bookmarks entry
265            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
266            * @throws SystemException if a system exception occurred
267            */
268            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First(
269                    java.lang.String uuid,
270                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
271                    throws com.liferay.portal.kernel.exception.SystemException,
272                            com.liferay.portlet.bookmarks.NoSuchEntryException {
273                    return getPersistence().findByUuid_First(uuid, orderByComparator);
274            }
275    
276            /**
277            * Finds the last bookmarks entry in the ordered set where uuid = &#63;.
278            *
279            * <p>
280            * 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.
281            * </p>
282            *
283            * @param uuid the uuid to search with
284            * @param orderByComparator the comparator to order the set by
285            * @return the last matching bookmarks entry
286            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
287            * @throws SystemException if a system exception occurred
288            */
289            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last(
290                    java.lang.String uuid,
291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
292                    throws com.liferay.portal.kernel.exception.SystemException,
293                            com.liferay.portlet.bookmarks.NoSuchEntryException {
294                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
295            }
296    
297            /**
298            * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set 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.
302            * </p>
303            *
304            * @param entryId the primary key of the current bookmarks entry
305            * @param uuid the uuid to search with
306            * @param orderByComparator the comparator to order the set by
307            * @return the previous, current, and next bookmarks entry
308            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext(
312                    long entryId, java.lang.String uuid,
313                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
314                    throws com.liferay.portal.kernel.exception.SystemException,
315                            com.liferay.portlet.bookmarks.NoSuchEntryException {
316                    return getPersistence()
317                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
318            }
319    
320            /**
321            * Finds the bookmarks entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
322            *
323            * @param uuid the uuid to search with
324            * @param groupId the group ID to search with
325            * @return the matching bookmarks entry
326            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
327            * @throws SystemException if a system exception occurred
328            */
329            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G(
330                    java.lang.String uuid, long groupId)
331                    throws com.liferay.portal.kernel.exception.SystemException,
332                            com.liferay.portlet.bookmarks.NoSuchEntryException {
333                    return getPersistence().findByUUID_G(uuid, groupId);
334            }
335    
336            /**
337            * Finds the bookmarks entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
338            *
339            * @param uuid the uuid to search with
340            * @param groupId the group ID to search with
341            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
342            * @throws SystemException if a system exception occurred
343            */
344            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
345                    java.lang.String uuid, long groupId)
346                    throws com.liferay.portal.kernel.exception.SystemException {
347                    return getPersistence().fetchByUUID_G(uuid, groupId);
348            }
349    
350            /**
351            * Finds 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.
352            *
353            * @param uuid the uuid to search with
354            * @param groupId the group ID to search with
355            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
356            * @throws SystemException if a system exception occurred
357            */
358            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
359                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
360                    throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
362            }
363    
364            /**
365            * Finds all the bookmarks entries where groupId = &#63;.
366            *
367            * @param groupId the group ID to search with
368            * @return the matching bookmarks entries
369            * @throws SystemException if a system exception occurred
370            */
371            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
372                    long groupId)
373                    throws com.liferay.portal.kernel.exception.SystemException {
374                    return getPersistence().findByGroupId(groupId);
375            }
376    
377            /**
378            * Finds a range of all the bookmarks entries where groupId = &#63;.
379            *
380            * <p>
381            * 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.
382            * </p>
383            *
384            * @param groupId the group ID to search with
385            * @param start the lower bound of the range of bookmarks entries to return
386            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
387            * @return the range of matching bookmarks entries
388            * @throws SystemException if a system exception occurred
389            */
390            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
391                    long groupId, int start, int end)
392                    throws com.liferay.portal.kernel.exception.SystemException {
393                    return getPersistence().findByGroupId(groupId, start, end);
394            }
395    
396            /**
397            * Finds an ordered range of all the bookmarks entries where groupId = &#63;.
398            *
399            * <p>
400            * 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.
401            * </p>
402            *
403            * @param groupId the group ID to search with
404            * @param start the lower bound of the range of bookmarks entries to return
405            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
406            * @param orderByComparator the comparator to order the results by
407            * @return the ordered range of matching bookmarks entries
408            * @throws SystemException if a system exception occurred
409            */
410            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId(
411                    long groupId, int start, int end,
412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
413                    throws com.liferay.portal.kernel.exception.SystemException {
414                    return getPersistence()
415                                       .findByGroupId(groupId, start, end, orderByComparator);
416            }
417    
418            /**
419            * Finds the first bookmarks entry in the ordered set where groupId = &#63;.
420            *
421            * <p>
422            * 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.
423            * </p>
424            *
425            * @param groupId the group ID to search with
426            * @param orderByComparator the comparator to order the set by
427            * @return the first matching bookmarks entry
428            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
429            * @throws SystemException if a system exception occurred
430            */
431            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First(
432                    long groupId,
433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
434                    throws com.liferay.portal.kernel.exception.SystemException,
435                            com.liferay.portlet.bookmarks.NoSuchEntryException {
436                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
437            }
438    
439            /**
440            * Finds the last bookmarks entry in the ordered set where groupId = &#63;.
441            *
442            * <p>
443            * 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.
444            * </p>
445            *
446            * @param groupId the group ID to search with
447            * @param orderByComparator the comparator to order the set by
448            * @return the last 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 findByGroupId_Last(
453                    long groupId,
454                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
455                    throws com.liferay.portal.kernel.exception.SystemException,
456                            com.liferay.portlet.bookmarks.NoSuchEntryException {
457                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
458            }
459    
460            /**
461            * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63;.
462            *
463            * <p>
464            * 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.
465            * </p>
466            *
467            * @param entryId the primary key of the current bookmarks entry
468            * @param groupId the group ID to search with
469            * @param orderByComparator the comparator to order the set by
470            * @return the previous, current, and next bookmarks entry
471            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
472            * @throws SystemException if a system exception occurred
473            */
474            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext(
475                    long entryId, long groupId,
476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
477                    throws com.liferay.portal.kernel.exception.SystemException,
478                            com.liferay.portlet.bookmarks.NoSuchEntryException {
479                    return getPersistence()
480                                       .findByGroupId_PrevAndNext(entryId, groupId,
481                            orderByComparator);
482            }
483    
484            /**
485            * Filters by the user's permissions and finds all the bookmarks entries where groupId = &#63;.
486            *
487            * @param groupId the group ID to search with
488            * @return the matching bookmarks entries that the user has permission to view
489            * @throws SystemException if a system exception occurred
490            */
491            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
492                    long groupId)
493                    throws com.liferay.portal.kernel.exception.SystemException {
494                    return getPersistence().filterFindByGroupId(groupId);
495            }
496    
497            /**
498            * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = &#63;.
499            *
500            * <p>
501            * 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.
502            * </p>
503            *
504            * @param groupId the group ID to search with
505            * @param start the lower bound of the range of bookmarks entries to return
506            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
507            * @return the range of matching bookmarks entries that the user has permission to view
508            * @throws SystemException if a system exception occurred
509            */
510            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
511                    long groupId, int start, int end)
512                    throws com.liferay.portal.kernel.exception.SystemException {
513                    return getPersistence().filterFindByGroupId(groupId, start, end);
514            }
515    
516            /**
517            * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = &#63;.
518            *
519            * <p>
520            * 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.
521            * </p>
522            *
523            * @param groupId the group ID to search with
524            * @param start the lower bound of the range of bookmarks entries to return
525            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
526            * @param orderByComparator the comparator to order the results by
527            * @return the ordered range of matching bookmarks entries that the user has permission to view
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId(
531                    long groupId, int start, int end,
532                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
533                    throws com.liferay.portal.kernel.exception.SystemException {
534                    return getPersistence()
535                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
536            }
537    
538            /**
539            * Filters the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63;.
540            *
541            * <p>
542            * 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.
543            * </p>
544            *
545            * @param entryId the primary key of the current bookmarks entry
546            * @param groupId the group ID to search with
547            * @param orderByComparator the comparator to order the set by
548            * @return the previous, current, and next bookmarks entry
549            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
550            * @throws SystemException if a system exception occurred
551            */
552            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByGroupId_PrevAndNext(
553                    long entryId, long groupId,
554                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
555                    throws com.liferay.portal.kernel.exception.SystemException,
556                            com.liferay.portlet.bookmarks.NoSuchEntryException {
557                    return getPersistence()
558                                       .filterFindByGroupId_PrevAndNext(entryId, groupId,
559                            orderByComparator);
560            }
561    
562            /**
563            * Finds all the bookmarks entries where groupId = &#63; and userId = &#63;.
564            *
565            * @param groupId the group ID to search with
566            * @param userId the user ID to search with
567            * @return the matching bookmarks entries
568            * @throws SystemException if a system exception occurred
569            */
570            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
571                    long groupId, long userId)
572                    throws com.liferay.portal.kernel.exception.SystemException {
573                    return getPersistence().findByG_U(groupId, userId);
574            }
575    
576            /**
577            * Finds a range of all the bookmarks entries where groupId = &#63; and userId = &#63;.
578            *
579            * <p>
580            * 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.
581            * </p>
582            *
583            * @param groupId the group ID to search with
584            * @param userId the user ID to search with
585            * @param start the lower bound of the range of bookmarks entries to return
586            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
587            * @return the range of matching bookmarks entries
588            * @throws SystemException if a system exception occurred
589            */
590            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
591                    long groupId, long userId, int start, int end)
592                    throws com.liferay.portal.kernel.exception.SystemException {
593                    return getPersistence().findByG_U(groupId, userId, start, end);
594            }
595    
596            /**
597            * Finds an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63;.
598            *
599            * <p>
600            * 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.
601            * </p>
602            *
603            * @param groupId the group ID to search with
604            * @param userId the user ID to search with
605            * @param start the lower bound of the range of bookmarks entries to return
606            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
607            * @param orderByComparator the comparator to order the results by
608            * @return the ordered range of matching bookmarks entries
609            * @throws SystemException if a system exception occurred
610            */
611            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U(
612                    long groupId, long userId, int start, int end,
613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
614                    throws com.liferay.portal.kernel.exception.SystemException {
615                    return getPersistence()
616                                       .findByG_U(groupId, userId, start, end, orderByComparator);
617            }
618    
619            /**
620            * Finds the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
621            *
622            * <p>
623            * 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.
624            * </p>
625            *
626            * @param groupId the group ID to search with
627            * @param userId the user ID to search with
628            * @param orderByComparator the comparator to order the set by
629            * @return the first matching bookmarks entry
630            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
631            * @throws SystemException if a system exception occurred
632            */
633            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First(
634                    long groupId, long userId,
635                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
636                    throws com.liferay.portal.kernel.exception.SystemException,
637                            com.liferay.portlet.bookmarks.NoSuchEntryException {
638                    return getPersistence()
639                                       .findByG_U_First(groupId, userId, orderByComparator);
640            }
641    
642            /**
643            * Finds the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
644            *
645            * <p>
646            * 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.
647            * </p>
648            *
649            * @param groupId the group ID to search with
650            * @param userId the user ID to search with
651            * @param orderByComparator the comparator to order the set by
652            * @return the last matching bookmarks entry
653            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
654            * @throws SystemException if a system exception occurred
655            */
656            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last(
657                    long groupId, long userId,
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                                       .findByG_U_Last(groupId, userId, orderByComparator);
663            }
664    
665            /**
666            * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
667            *
668            * <p>
669            * 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.
670            * </p>
671            *
672            * @param entryId the primary key of the current bookmarks entry
673            * @param groupId the group ID to search with
674            * @param userId the user ID to search with
675            * @param orderByComparator the comparator to order the set by
676            * @return the previous, current, and next bookmarks entry
677            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
678            * @throws SystemException if a system exception occurred
679            */
680            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext(
681                    long entryId, long groupId, long userId,
682                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
683                    throws com.liferay.portal.kernel.exception.SystemException,
684                            com.liferay.portlet.bookmarks.NoSuchEntryException {
685                    return getPersistence()
686                                       .findByG_U_PrevAndNext(entryId, groupId, userId,
687                            orderByComparator);
688            }
689    
690            /**
691            * Filters by the user's permissions and finds all the bookmarks entries where groupId = &#63; and userId = &#63;.
692            *
693            * @param groupId the group ID to search with
694            * @param userId the user ID to search with
695            * @return the matching bookmarks entries that the user has permission to view
696            * @throws SystemException if a system exception occurred
697            */
698            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
699                    long groupId, long userId)
700                    throws com.liferay.portal.kernel.exception.SystemException {
701                    return getPersistence().filterFindByG_U(groupId, userId);
702            }
703    
704            /**
705            * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = &#63; and userId = &#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.
709            * </p>
710            *
711            * @param groupId the group ID to search with
712            * @param userId the user ID to search with
713            * @param start the lower bound of the range of bookmarks entries to return
714            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
715            * @return the range of matching bookmarks entries that the user has permission to view
716            * @throws SystemException if a system exception occurred
717            */
718            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
719                    long groupId, long userId, int start, int end)
720                    throws com.liferay.portal.kernel.exception.SystemException {
721                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
722            }
723    
724            /**
725            * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63;.
726            *
727            * <p>
728            * 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.
729            * </p>
730            *
731            * @param groupId the group ID to search with
732            * @param userId the user ID to search with
733            * @param start the lower bound of the range of bookmarks entries to return
734            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
735            * @param orderByComparator the comparator to order the results by
736            * @return the ordered range of matching bookmarks entries that the user has permission to view
737            * @throws SystemException if a system exception occurred
738            */
739            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U(
740                    long groupId, long userId, int start, int end,
741                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
742                    throws com.liferay.portal.kernel.exception.SystemException {
743                    return getPersistence()
744                                       .filterFindByG_U(groupId, userId, start, end,
745                            orderByComparator);
746            }
747    
748            /**
749            * Filters the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63;.
750            *
751            * <p>
752            * 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.
753            * </p>
754            *
755            * @param entryId the primary key of the current bookmarks entry
756            * @param groupId the group ID to search with
757            * @param userId the user ID to search with
758            * @param orderByComparator the comparator to order the set by
759            * @return the previous, current, and next bookmarks entry
760            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
761            * @throws SystemException if a system exception occurred
762            */
763            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_PrevAndNext(
764                    long entryId, long groupId, long userId,
765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
766                    throws com.liferay.portal.kernel.exception.SystemException,
767                            com.liferay.portlet.bookmarks.NoSuchEntryException {
768                    return getPersistence()
769                                       .filterFindByG_U_PrevAndNext(entryId, groupId, userId,
770                            orderByComparator);
771            }
772    
773            /**
774            * Finds all the bookmarks entries where groupId = &#63; and folderId = &#63;.
775            *
776            * @param groupId the group ID to search with
777            * @param folderId the folder ID to search with
778            * @return the matching bookmarks entries
779            * @throws SystemException if a system exception occurred
780            */
781            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
782                    long groupId, long folderId)
783                    throws com.liferay.portal.kernel.exception.SystemException {
784                    return getPersistence().findByG_F(groupId, folderId);
785            }
786    
787            /**
788            * Finds a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
789            *
790            * <p>
791            * 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.
792            * </p>
793            *
794            * @param groupId the group ID to search with
795            * @param folderId the folder ID to search with
796            * @param start the lower bound of the range of bookmarks entries to return
797            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
798            * @return the range of matching bookmarks entries
799            * @throws SystemException if a system exception occurred
800            */
801            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
802                    long groupId, long folderId, int start, int end)
803                    throws com.liferay.portal.kernel.exception.SystemException {
804                    return getPersistence().findByG_F(groupId, folderId, start, end);
805            }
806    
807            /**
808            * Finds an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
809            *
810            * <p>
811            * 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.
812            * </p>
813            *
814            * @param groupId the group ID to search with
815            * @param folderId the folder ID to search with
816            * @param start the lower bound of the range of bookmarks entries to return
817            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
818            * @param orderByComparator the comparator to order the results by
819            * @return the ordered range of matching bookmarks entries
820            * @throws SystemException if a system exception occurred
821            */
822            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
823                    long groupId, long folderId, int start, int end,
824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
825                    throws com.liferay.portal.kernel.exception.SystemException {
826                    return getPersistence()
827                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
828            }
829    
830            /**
831            * Finds the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
832            *
833            * <p>
834            * 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.
835            * </p>
836            *
837            * @param groupId the group ID to search with
838            * @param folderId the folder ID to search with
839            * @param orderByComparator the comparator to order the set by
840            * @return the first matching bookmarks entry
841            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
842            * @throws SystemException if a system exception occurred
843            */
844            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
845                    long groupId, long folderId,
846                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
847                    throws com.liferay.portal.kernel.exception.SystemException,
848                            com.liferay.portlet.bookmarks.NoSuchEntryException {
849                    return getPersistence()
850                                       .findByG_F_First(groupId, folderId, orderByComparator);
851            }
852    
853            /**
854            * Finds the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
855            *
856            * <p>
857            * 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.
858            * </p>
859            *
860            * @param groupId the group ID to search with
861            * @param folderId the folder ID to search with
862            * @param orderByComparator the comparator to order the set by
863            * @return the last matching bookmarks entry
864            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
865            * @throws SystemException if a system exception occurred
866            */
867            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
868                    long groupId, long folderId,
869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
870                    throws com.liferay.portal.kernel.exception.SystemException,
871                            com.liferay.portlet.bookmarks.NoSuchEntryException {
872                    return getPersistence()
873                                       .findByG_F_Last(groupId, folderId, orderByComparator);
874            }
875    
876            /**
877            * Finds the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
878            *
879            * <p>
880            * 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.
881            * </p>
882            *
883            * @param entryId the primary key of the current bookmarks entry
884            * @param groupId the group ID to search with
885            * @param folderId the folder ID to search with
886            * @param orderByComparator the comparator to order the set by
887            * @return the previous, current, and next bookmarks entry
888            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
889            * @throws SystemException if a system exception occurred
890            */
891            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
892                    long entryId, long groupId, long folderId,
893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
894                    throws com.liferay.portal.kernel.exception.SystemException,
895                            com.liferay.portlet.bookmarks.NoSuchEntryException {
896                    return getPersistence()
897                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
898                            orderByComparator);
899            }
900    
901            /**
902            * Finds all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
903            *
904            * <p>
905            * 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.
906            * </p>
907            *
908            * @param groupId the group ID to search with
909            * @param folderIds the folder IDs to search with
910            * @return the matching bookmarks entries
911            * @throws SystemException if a system exception occurred
912            */
913            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
914                    long groupId, long[] folderIds)
915                    throws com.liferay.portal.kernel.exception.SystemException {
916                    return getPersistence().findByG_F(groupId, folderIds);
917            }
918    
919            /**
920            * Finds a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
921            *
922            * <p>
923            * 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.
924            * </p>
925            *
926            * @param groupId the group ID to search with
927            * @param folderIds the folder IDs to search with
928            * @param start the lower bound of the range of bookmarks entries to return
929            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
930            * @return the range of matching bookmarks entries
931            * @throws SystemException if a system exception occurred
932            */
933            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
934                    long groupId, long[] folderIds, int start, int end)
935                    throws com.liferay.portal.kernel.exception.SystemException {
936                    return getPersistence().findByG_F(groupId, folderIds, start, end);
937            }
938    
939            /**
940            * Finds an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
941            *
942            * <p>
943            * 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.
944            * </p>
945            *
946            * @param groupId the group ID to search with
947            * @param folderIds the folder IDs to search with
948            * @param start the lower bound of the range of bookmarks entries to return
949            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
950            * @param orderByComparator the comparator to order the results by
951            * @return the ordered range of matching bookmarks entries
952            * @throws SystemException if a system exception occurred
953            */
954            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
955                    long groupId, long[] folderIds, int start, int end,
956                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence()
959                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
960            }
961    
962            /**
963            * Filters by the user's permissions and finds all the bookmarks entries where groupId = &#63; and folderId = &#63;.
964            *
965            * @param groupId the group ID to search with
966            * @param folderId the folder ID to search with
967            * @return the matching bookmarks entries that the user has permission to view
968            * @throws SystemException if a system exception occurred
969            */
970            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
971                    long groupId, long folderId)
972                    throws com.liferay.portal.kernel.exception.SystemException {
973                    return getPersistence().filterFindByG_F(groupId, folderId);
974            }
975    
976            /**
977            * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
978            *
979            * <p>
980            * 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.
981            * </p>
982            *
983            * @param groupId the group ID to search with
984            * @param folderId the folder ID to search with
985            * @param start the lower bound of the range of bookmarks entries to return
986            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
987            * @return the range of matching bookmarks entries that the user has permission to view
988            * @throws SystemException if a system exception occurred
989            */
990            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
991                    long groupId, long folderId, int start, int end)
992                    throws com.liferay.portal.kernel.exception.SystemException {
993                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
994            }
995    
996            /**
997            * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
998            *
999            * <p>
1000            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1001            * </p>
1002            *
1003            * @param groupId the group ID to search with
1004            * @param folderId the folder ID to search with
1005            * @param start the lower bound of the range of bookmarks entries to return
1006            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
1007            * @param orderByComparator the comparator to order the results by
1008            * @return the ordered range of matching bookmarks entries that the user has permission to view
1009            * @throws SystemException if a system exception occurred
1010            */
1011            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1012                    long groupId, long folderId, int start, int end,
1013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1014                    throws com.liferay.portal.kernel.exception.SystemException {
1015                    return getPersistence()
1016                                       .filterFindByG_F(groupId, folderId, start, end,
1017                            orderByComparator);
1018            }
1019    
1020            /**
1021            * Filters the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
1022            *
1023            * <p>
1024            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1025            * </p>
1026            *
1027            * @param entryId the primary key of the current bookmarks entry
1028            * @param groupId the group ID to search with
1029            * @param folderId the folder ID to search with
1030            * @param orderByComparator the comparator to order the set by
1031            * @return the previous, current, and next bookmarks entry
1032            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
1036                    long entryId, long groupId, long folderId,
1037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.SystemException,
1039                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1040                    return getPersistence()
1041                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
1042                            orderByComparator);
1043            }
1044    
1045            /**
1046            * Filters by the user's permissions and finds all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1047            *
1048            * <p>
1049            * 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.
1050            * </p>
1051            *
1052            * @param groupId the group ID to search with
1053            * @param folderIds the folder IDs to search with
1054            * @return the matching bookmarks entries that the user has permission to view
1055            * @throws SystemException if a system exception occurred
1056            */
1057            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1058                    long groupId, long[] folderIds)
1059                    throws com.liferay.portal.kernel.exception.SystemException {
1060                    return getPersistence().filterFindByG_F(groupId, folderIds);
1061            }
1062    
1063            /**
1064            * Filters by the user's permissions and finds a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1065            *
1066            * <p>
1067            * 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.
1068            * </p>
1069            *
1070            * @param groupId the group ID to search with
1071            * @param folderIds the folder IDs to search with
1072            * @param start the lower bound of the range of bookmarks entries to return
1073            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
1074            * @return the range of matching bookmarks entries that the user has permission to view
1075            * @throws SystemException if a system exception occurred
1076            */
1077            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1078                    long groupId, long[] folderIds, int start, int end)
1079                    throws com.liferay.portal.kernel.exception.SystemException {
1080                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
1081            }
1082    
1083            /**
1084            * Filters by the user's permissions and finds an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1085            *
1086            * <p>
1087            * 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.
1088            * </p>
1089            *
1090            * @param groupId the group ID to search with
1091            * @param folderIds the folder IDs to search with
1092            * @param start the lower bound of the range of bookmarks entries to return
1093            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
1094            * @param orderByComparator the comparator to order the results by
1095            * @return the ordered range of matching bookmarks entries that the user has permission to view
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
1099                    long groupId, long[] folderIds, int start, int end,
1100                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1101                    throws com.liferay.portal.kernel.exception.SystemException {
1102                    return getPersistence()
1103                                       .filterFindByG_F(groupId, folderIds, start, end,
1104                            orderByComparator);
1105            }
1106    
1107            /**
1108            * Finds all the bookmarks entries.
1109            *
1110            * @return the bookmarks entries
1111            * @throws SystemException if a system exception occurred
1112            */
1113            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
1114                    throws com.liferay.portal.kernel.exception.SystemException {
1115                    return getPersistence().findAll();
1116            }
1117    
1118            /**
1119            * Finds a range of all the bookmarks entries.
1120            *
1121            * <p>
1122            * 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.
1123            * </p>
1124            *
1125            * @param start the lower bound of the range of bookmarks entries to return
1126            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
1127            * @return the range of bookmarks entries
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
1131                    int start, int end)
1132                    throws com.liferay.portal.kernel.exception.SystemException {
1133                    return getPersistence().findAll(start, end);
1134            }
1135    
1136            /**
1137            * Finds an ordered range of all the bookmarks entries.
1138            *
1139            * <p>
1140            * 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.
1141            * </p>
1142            *
1143            * @param start the lower bound of the range of bookmarks entries to return
1144            * @param end the upper bound of the range of bookmarks entries to return (not inclusive)
1145            * @param orderByComparator the comparator to order the results by
1146            * @return the ordered range of bookmarks entries
1147            * @throws SystemException if a system exception occurred
1148            */
1149            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
1150                    int start, int end,
1151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1152                    throws com.liferay.portal.kernel.exception.SystemException {
1153                    return getPersistence().findAll(start, end, orderByComparator);
1154            }
1155    
1156            /**
1157            * Removes all the bookmarks entries where uuid = &#63; from the database.
1158            *
1159            * @param uuid the uuid to search with
1160            * @throws SystemException if a system exception occurred
1161            */
1162            public static void removeByUuid(java.lang.String uuid)
1163                    throws com.liferay.portal.kernel.exception.SystemException {
1164                    getPersistence().removeByUuid(uuid);
1165            }
1166    
1167            /**
1168            * Removes the bookmarks entry where uuid = &#63; and groupId = &#63; from the database.
1169            *
1170            * @param uuid the uuid to search with
1171            * @param groupId the group ID to search with
1172            * @throws SystemException if a system exception occurred
1173            */
1174            public static void removeByUUID_G(java.lang.String uuid, long groupId)
1175                    throws com.liferay.portal.kernel.exception.SystemException,
1176                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1177                    getPersistence().removeByUUID_G(uuid, groupId);
1178            }
1179    
1180            /**
1181            * Removes all the bookmarks entries where groupId = &#63; from the database.
1182            *
1183            * @param groupId the group ID to search with
1184            * @throws SystemException if a system exception occurred
1185            */
1186            public static void removeByGroupId(long groupId)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    getPersistence().removeByGroupId(groupId);
1189            }
1190    
1191            /**
1192            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; from the database.
1193            *
1194            * @param groupId the group ID to search with
1195            * @param userId the user ID to search with
1196            * @throws SystemException if a system exception occurred
1197            */
1198            public static void removeByG_U(long groupId, long userId)
1199                    throws com.liferay.portal.kernel.exception.SystemException {
1200                    getPersistence().removeByG_U(groupId, userId);
1201            }
1202    
1203            /**
1204            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1205            *
1206            * @param groupId the group ID to search with
1207            * @param folderId the folder ID to search with
1208            * @throws SystemException if a system exception occurred
1209            */
1210            public static void removeByG_F(long groupId, long folderId)
1211                    throws com.liferay.portal.kernel.exception.SystemException {
1212                    getPersistence().removeByG_F(groupId, folderId);
1213            }
1214    
1215            /**
1216            * Removes all the bookmarks entries from the database.
1217            *
1218            * @throws SystemException if a system exception occurred
1219            */
1220            public static void removeAll()
1221                    throws com.liferay.portal.kernel.exception.SystemException {
1222                    getPersistence().removeAll();
1223            }
1224    
1225            /**
1226            * Counts all the bookmarks entries where uuid = &#63;.
1227            *
1228            * @param uuid the uuid to search with
1229            * @return the number of matching bookmarks entries
1230            * @throws SystemException if a system exception occurred
1231            */
1232            public static int countByUuid(java.lang.String uuid)
1233                    throws com.liferay.portal.kernel.exception.SystemException {
1234                    return getPersistence().countByUuid(uuid);
1235            }
1236    
1237            /**
1238            * Counts all the bookmarks entries where uuid = &#63; and groupId = &#63;.
1239            *
1240            * @param uuid the uuid to search with
1241            * @param groupId the group ID to search with
1242            * @return the number of matching bookmarks entries
1243            * @throws SystemException if a system exception occurred
1244            */
1245            public static int countByUUID_G(java.lang.String uuid, long groupId)
1246                    throws com.liferay.portal.kernel.exception.SystemException {
1247                    return getPersistence().countByUUID_G(uuid, groupId);
1248            }
1249    
1250            /**
1251            * Counts all the bookmarks entries where groupId = &#63;.
1252            *
1253            * @param groupId the group ID to search with
1254            * @return the number of matching bookmarks entries
1255            * @throws SystemException if a system exception occurred
1256            */
1257            public static int countByGroupId(long groupId)
1258                    throws com.liferay.portal.kernel.exception.SystemException {
1259                    return getPersistence().countByGroupId(groupId);
1260            }
1261    
1262            /**
1263            * Filters by the user's permissions and counts all the bookmarks entries where groupId = &#63;.
1264            *
1265            * @param groupId the group ID to search with
1266            * @return the number of matching bookmarks entries that the user has permission to view
1267            * @throws SystemException if a system exception occurred
1268            */
1269            public static int filterCountByGroupId(long groupId)
1270                    throws com.liferay.portal.kernel.exception.SystemException {
1271                    return getPersistence().filterCountByGroupId(groupId);
1272            }
1273    
1274            /**
1275            * Counts all the bookmarks entries where groupId = &#63; and userId = &#63;.
1276            *
1277            * @param groupId the group ID to search with
1278            * @param userId the user ID to search with
1279            * @return the number of matching bookmarks entries
1280            * @throws SystemException if a system exception occurred
1281            */
1282            public static int countByG_U(long groupId, long userId)
1283                    throws com.liferay.portal.kernel.exception.SystemException {
1284                    return getPersistence().countByG_U(groupId, userId);
1285            }
1286    
1287            /**
1288            * Filters by the user's permissions and counts all the bookmarks entries where groupId = &#63; and userId = &#63;.
1289            *
1290            * @param groupId the group ID to search with
1291            * @param userId the user ID to search with
1292            * @return the number of matching bookmarks entries that the user has permission to view
1293            * @throws SystemException if a system exception occurred
1294            */
1295            public static int filterCountByG_U(long groupId, long userId)
1296                    throws com.liferay.portal.kernel.exception.SystemException {
1297                    return getPersistence().filterCountByG_U(groupId, userId);
1298            }
1299    
1300            /**
1301            * Counts all the bookmarks entries where groupId = &#63; and folderId = &#63;.
1302            *
1303            * @param groupId the group ID to search with
1304            * @param folderId the folder ID to search with
1305            * @return the number of matching bookmarks entries
1306            * @throws SystemException if a system exception occurred
1307            */
1308            public static int countByG_F(long groupId, long folderId)
1309                    throws com.liferay.portal.kernel.exception.SystemException {
1310                    return getPersistence().countByG_F(groupId, folderId);
1311            }
1312    
1313            /**
1314            * Counts all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1315            *
1316            * @param groupId the group ID to search with
1317            * @param folderIds the folder IDs to search with
1318            * @return the number of matching bookmarks entries
1319            * @throws SystemException if a system exception occurred
1320            */
1321            public static int countByG_F(long groupId, long[] folderIds)
1322                    throws com.liferay.portal.kernel.exception.SystemException {
1323                    return getPersistence().countByG_F(groupId, folderIds);
1324            }
1325    
1326            /**
1327            * Filters by the user's permissions and counts all the bookmarks entries where groupId = &#63; and folderId = &#63;.
1328            *
1329            * @param groupId the group ID to search with
1330            * @param folderId the folder ID to search with
1331            * @return the number of matching bookmarks entries that the user has permission to view
1332            * @throws SystemException if a system exception occurred
1333            */
1334            public static int filterCountByG_F(long groupId, long folderId)
1335                    throws com.liferay.portal.kernel.exception.SystemException {
1336                    return getPersistence().filterCountByG_F(groupId, folderId);
1337            }
1338    
1339            /**
1340            * Filters by the user's permissions and counts all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1341            *
1342            * @param groupId the group ID to search with
1343            * @param folderIds the folder IDs to search with
1344            * @return the number of matching bookmarks entries that the user has permission to view
1345            * @throws SystemException if a system exception occurred
1346            */
1347            public static int filterCountByG_F(long groupId, long[] folderIds)
1348                    throws com.liferay.portal.kernel.exception.SystemException {
1349                    return getPersistence().filterCountByG_F(groupId, folderIds);
1350            }
1351    
1352            /**
1353            * Counts all the bookmarks entries.
1354            *
1355            * @return the number of bookmarks entries
1356            * @throws SystemException if a system exception occurred
1357            */
1358            public static int countAll()
1359                    throws com.liferay.portal.kernel.exception.SystemException {
1360                    return getPersistence().countAll();
1361            }
1362    
1363            public static BookmarksEntryPersistence getPersistence() {
1364                    if (_persistence == null) {
1365                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
1366    
1367                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
1368                                    "_persistence");
1369                    }
1370    
1371                    return _persistence;
1372            }
1373    
1374            public void setPersistence(BookmarksEntryPersistence persistence) {
1375                    _persistence = persistence;
1376    
1377                    ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
1378                            "_persistence");
1379            }
1380    
1381            private static BookmarksEntryPersistence _persistence;
1382    }