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