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