001    /**
002     * Copyright (c) 2000-2010 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.service.ServiceContext;
022    
023    import com.liferay.portlet.bookmarks.model.BookmarksFolder;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the bookmarks folder service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see BookmarksFolderPersistence
036     * @see BookmarksFolderPersistenceImpl
037     * @generated
038     */
039    public class BookmarksFolderUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(BookmarksFolder bookmarksFolder) {
051                    getPersistence().clearCache(bookmarksFolder);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<BookmarksFolder> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<BookmarksFolder> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<BookmarksFolder> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static BookmarksFolder remove(BookmarksFolder bookmarksFolder)
094                    throws SystemException {
095                    return getPersistence().remove(bookmarksFolder);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static BookmarksFolder update(BookmarksFolder bookmarksFolder,
102                    boolean merge) throws SystemException {
103                    return getPersistence().update(bookmarksFolder, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static BookmarksFolder update(BookmarksFolder bookmarksFolder,
110                    boolean merge, ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(bookmarksFolder, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the bookmarks folder in the entity cache if it is enabled.
116            *
117            * @param bookmarksFolder the bookmarks folder to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) {
121                    getPersistence().cacheResult(bookmarksFolder);
122            }
123    
124            /**
125            * Caches the bookmarks folders in the entity cache if it is enabled.
126            *
127            * @param bookmarksFolders the bookmarks folders to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) {
131                    getPersistence().cacheResult(bookmarksFolders);
132            }
133    
134            /**
135            * Creates a new bookmarks folder with the primary key.
136            *
137            * @param folderId the primary key for the new bookmarks folder
138            * @return the new bookmarks folder
139            */
140            public static com.liferay.portlet.bookmarks.model.BookmarksFolder create(
141                    long folderId) {
142                    return getPersistence().create(folderId);
143            }
144    
145            /**
146            * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param folderId the primary key of the bookmarks folder to remove
149            * @return the bookmarks folder that was removed
150            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove(
154                    long folderId)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.bookmarks.NoSuchFolderException {
157                    return getPersistence().remove(folderId);
158            }
159    
160            public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl(
161                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder,
162                    boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(bookmarksFolder, merge);
165            }
166    
167            /**
168            * Finds the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found.
169            *
170            * @param folderId the primary key of the bookmarks folder to find
171            * @return the bookmarks folder
172            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey(
176                    long folderId)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.bookmarks.NoSuchFolderException {
179                    return getPersistence().findByPrimaryKey(folderId);
180            }
181    
182            /**
183            * Finds the bookmarks folder with the primary key or returns <code>null</code> if it could not be found.
184            *
185            * @param folderId the primary key of the bookmarks folder to find
186            * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found
187            * @throws SystemException if a system exception occurred
188            */
189            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey(
190                    long folderId)
191                    throws com.liferay.portal.kernel.exception.SystemException {
192                    return getPersistence().fetchByPrimaryKey(folderId);
193            }
194    
195            /**
196            * Finds all the bookmarks folders where uuid = &#63;.
197            *
198            * @param uuid the uuid to search with
199            * @return the matching bookmarks folders
200            * @throws SystemException if a system exception occurred
201            */
202            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
203                    java.lang.String uuid)
204                    throws com.liferay.portal.kernel.exception.SystemException {
205                    return getPersistence().findByUuid(uuid);
206            }
207    
208            /**
209            * Finds a range of all the bookmarks folders where uuid = &#63;.
210            *
211            * <p>
212            * 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.
213            * </p>
214            *
215            * @param uuid the uuid to search with
216            * @param start the lower bound of the range of bookmarks folders to return
217            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
218            * @return the range of matching bookmarks folders
219            * @throws SystemException if a system exception occurred
220            */
221            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
222                    java.lang.String uuid, int start, int end)
223                    throws com.liferay.portal.kernel.exception.SystemException {
224                    return getPersistence().findByUuid(uuid, start, end);
225            }
226    
227            /**
228            * Finds an ordered range of all the bookmarks folders where uuid = &#63;.
229            *
230            * <p>
231            * 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.
232            * </p>
233            *
234            * @param uuid the uuid to search with
235            * @param start the lower bound of the range of bookmarks folders to return
236            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
237            * @param orderByComparator the comparator to order the results by
238            * @return the ordered range of matching bookmarks folders
239            * @throws SystemException if a system exception occurred
240            */
241            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
242                    java.lang.String uuid, int start, int end,
243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
244                    throws com.liferay.portal.kernel.exception.SystemException {
245                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
246            }
247    
248            /**
249            * Finds the first bookmarks folder in the ordered set where uuid = &#63;.
250            *
251            * <p>
252            * 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.
253            * </p>
254            *
255            * @param uuid the uuid to search with
256            * @param orderByComparator the comparator to order the set by
257            * @return the first matching bookmarks folder
258            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
259            * @throws SystemException if a system exception occurred
260            */
261            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First(
262                    java.lang.String uuid,
263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
264                    throws com.liferay.portal.kernel.exception.SystemException,
265                            com.liferay.portlet.bookmarks.NoSuchFolderException {
266                    return getPersistence().findByUuid_First(uuid, orderByComparator);
267            }
268    
269            /**
270            * Finds the last bookmarks folder in the ordered set where uuid = &#63;.
271            *
272            * <p>
273            * 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.
274            * </p>
275            *
276            * @param uuid the uuid to search with
277            * @param orderByComparator the comparator to order the set by
278            * @return the last matching bookmarks folder
279            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
280            * @throws SystemException if a system exception occurred
281            */
282            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last(
283                    java.lang.String uuid,
284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
285                    throws com.liferay.portal.kernel.exception.SystemException,
286                            com.liferay.portlet.bookmarks.NoSuchFolderException {
287                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
288            }
289    
290            /**
291            * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = &#63;.
292            *
293            * <p>
294            * 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.
295            * </p>
296            *
297            * @param folderId the primary key of the current bookmarks folder
298            * @param uuid the uuid to search with
299            * @param orderByComparator the comparator to order the set by
300            * @return the previous, current, and next bookmarks folder
301            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
302            * @throws SystemException if a system exception occurred
303            */
304            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext(
305                    long folderId, java.lang.String uuid,
306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
307                    throws com.liferay.portal.kernel.exception.SystemException,
308                            com.liferay.portlet.bookmarks.NoSuchFolderException {
309                    return getPersistence()
310                                       .findByUuid_PrevAndNext(folderId, uuid, orderByComparator);
311            }
312    
313            /**
314            * Finds the bookmarks folder where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found.
315            *
316            * @param uuid the uuid to search with
317            * @param groupId the group id to search with
318            * @return the matching bookmarks folder
319            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
320            * @throws SystemException if a system exception occurred
321            */
322            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G(
323                    java.lang.String uuid, long groupId)
324                    throws com.liferay.portal.kernel.exception.SystemException,
325                            com.liferay.portlet.bookmarks.NoSuchFolderException {
326                    return getPersistence().findByUUID_G(uuid, groupId);
327            }
328    
329            /**
330            * Finds the bookmarks folder where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
331            *
332            * @param uuid the uuid to search with
333            * @param groupId the group id to search with
334            * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
335            * @throws SystemException if a system exception occurred
336            */
337            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G(
338                    java.lang.String uuid, long groupId)
339                    throws com.liferay.portal.kernel.exception.SystemException {
340                    return getPersistence().fetchByUUID_G(uuid, groupId);
341            }
342    
343            /**
344            * Finds 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.
345            *
346            * @param uuid the uuid to search with
347            * @param groupId the group id to search with
348            * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
349            * @throws SystemException if a system exception occurred
350            */
351            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G(
352                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
353                    throws com.liferay.portal.kernel.exception.SystemException {
354                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
355            }
356    
357            /**
358            * Finds all the bookmarks folders where groupId = &#63;.
359            *
360            * @param groupId the group id to search with
361            * @return the matching bookmarks folders
362            * @throws SystemException if a system exception occurred
363            */
364            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
365                    long groupId)
366                    throws com.liferay.portal.kernel.exception.SystemException {
367                    return getPersistence().findByGroupId(groupId);
368            }
369    
370            /**
371            * Finds a range of all the bookmarks folders where groupId = &#63;.
372            *
373            * <p>
374            * 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.
375            * </p>
376            *
377            * @param groupId the group id to search with
378            * @param start the lower bound of the range of bookmarks folders to return
379            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
380            * @return the range of matching bookmarks folders
381            * @throws SystemException if a system exception occurred
382            */
383            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
384                    long groupId, int start, int end)
385                    throws com.liferay.portal.kernel.exception.SystemException {
386                    return getPersistence().findByGroupId(groupId, start, end);
387            }
388    
389            /**
390            * Finds an ordered range of all the bookmarks folders where groupId = &#63;.
391            *
392            * <p>
393            * 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.
394            * </p>
395            *
396            * @param groupId the group id to search with
397            * @param start the lower bound of the range of bookmarks folders to return
398            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
399            * @param orderByComparator the comparator to order the results by
400            * @return the ordered range of matching bookmarks folders
401            * @throws SystemException if a system exception occurred
402            */
403            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
404                    long groupId, int start, int end,
405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
406                    throws com.liferay.portal.kernel.exception.SystemException {
407                    return getPersistence()
408                                       .findByGroupId(groupId, start, end, orderByComparator);
409            }
410    
411            /**
412            * Finds the first bookmarks folder in the ordered set where groupId = &#63;.
413            *
414            * <p>
415            * 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.
416            * </p>
417            *
418            * @param groupId the group id to search with
419            * @param orderByComparator the comparator to order the set by
420            * @return the first matching bookmarks folder
421            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
422            * @throws SystemException if a system exception occurred
423            */
424            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First(
425                    long groupId,
426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
427                    throws com.liferay.portal.kernel.exception.SystemException,
428                            com.liferay.portlet.bookmarks.NoSuchFolderException {
429                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
430            }
431    
432            /**
433            * Finds the last bookmarks folder in the ordered set where groupId = &#63;.
434            *
435            * <p>
436            * 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.
437            * </p>
438            *
439            * @param groupId the group id to search with
440            * @param orderByComparator the comparator to order the set by
441            * @return the last matching bookmarks folder
442            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
443            * @throws SystemException if a system exception occurred
444            */
445            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last(
446                    long groupId,
447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
448                    throws com.liferay.portal.kernel.exception.SystemException,
449                            com.liferay.portlet.bookmarks.NoSuchFolderException {
450                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
451            }
452    
453            /**
454            * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63;.
455            *
456            * <p>
457            * 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.
458            * </p>
459            *
460            * @param folderId the primary key of the current bookmarks folder
461            * @param groupId the group id to search with
462            * @param orderByComparator the comparator to order the set by
463            * @return the previous, current, and next bookmarks folder
464            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext(
468                    long folderId, long groupId,
469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
470                    throws com.liferay.portal.kernel.exception.SystemException,
471                            com.liferay.portlet.bookmarks.NoSuchFolderException {
472                    return getPersistence()
473                                       .findByGroupId_PrevAndNext(folderId, groupId,
474                            orderByComparator);
475            }
476    
477            /**
478            * Filters by the user's permissions and finds all the bookmarks folders where groupId = &#63;.
479            *
480            * @param groupId the group id to search with
481            * @return the matching bookmarks folders that the user has permission to view
482            * @throws SystemException if a system exception occurred
483            */
484            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
485                    long groupId)
486                    throws com.liferay.portal.kernel.exception.SystemException {
487                    return getPersistence().filterFindByGroupId(groupId);
488            }
489    
490            /**
491            * Filters by the user's permissions and finds a range of all the bookmarks folders where groupId = &#63;.
492            *
493            * <p>
494            * 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.
495            * </p>
496            *
497            * @param groupId the group id to search with
498            * @param start the lower bound of the range of bookmarks folders to return
499            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
500            * @return the range of matching bookmarks folders that the user has permission to view
501            * @throws SystemException if a system exception occurred
502            */
503            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
504                    long groupId, int start, int end)
505                    throws com.liferay.portal.kernel.exception.SystemException {
506                    return getPersistence().filterFindByGroupId(groupId, start, end);
507            }
508    
509            /**
510            * Filters by the user's permissions and finds an ordered range of all the bookmarks folders where groupId = &#63;.
511            *
512            * <p>
513            * 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.
514            * </p>
515            *
516            * @param groupId the group id to search with
517            * @param start the lower bound of the range of bookmarks folders to return
518            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
519            * @param orderByComparator the comparator to order the results by
520            * @return the ordered range of matching bookmarks folders that the user has permission to view
521            * @throws SystemException if a system exception occurred
522            */
523            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
524                    long groupId, int start, int end,
525                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
526                    throws com.liferay.portal.kernel.exception.SystemException {
527                    return getPersistence()
528                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
529            }
530    
531            /**
532            * Finds all the bookmarks folders where companyId = &#63;.
533            *
534            * @param companyId the company id to search with
535            * @return the matching bookmarks folders
536            * @throws SystemException if a system exception occurred
537            */
538            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
539                    long companyId)
540                    throws com.liferay.portal.kernel.exception.SystemException {
541                    return getPersistence().findByCompanyId(companyId);
542            }
543    
544            /**
545            * Finds a range of all the bookmarks folders where companyId = &#63;.
546            *
547            * <p>
548            * 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.
549            * </p>
550            *
551            * @param companyId the company id to search with
552            * @param start the lower bound of the range of bookmarks folders to return
553            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
554            * @return the range of matching bookmarks folders
555            * @throws SystemException if a system exception occurred
556            */
557            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
558                    long companyId, int start, int end)
559                    throws com.liferay.portal.kernel.exception.SystemException {
560                    return getPersistence().findByCompanyId(companyId, start, end);
561            }
562    
563            /**
564            * Finds an ordered range of all the bookmarks folders where companyId = &#63;.
565            *
566            * <p>
567            * 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.
568            * </p>
569            *
570            * @param companyId the company id to search with
571            * @param start the lower bound of the range of bookmarks folders to return
572            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
573            * @param orderByComparator the comparator to order the results by
574            * @return the ordered range of matching bookmarks folders
575            * @throws SystemException if a system exception occurred
576            */
577            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
578                    long companyId, int start, int end,
579                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
580                    throws com.liferay.portal.kernel.exception.SystemException {
581                    return getPersistence()
582                                       .findByCompanyId(companyId, start, end, orderByComparator);
583            }
584    
585            /**
586            * Finds the first bookmarks folder in the ordered set where companyId = &#63;.
587            *
588            * <p>
589            * 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.
590            * </p>
591            *
592            * @param companyId the company id to search with
593            * @param orderByComparator the comparator to order the set by
594            * @return the first matching bookmarks folder
595            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
596            * @throws SystemException if a system exception occurred
597            */
598            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First(
599                    long companyId,
600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
601                    throws com.liferay.portal.kernel.exception.SystemException,
602                            com.liferay.portlet.bookmarks.NoSuchFolderException {
603                    return getPersistence()
604                                       .findByCompanyId_First(companyId, orderByComparator);
605            }
606    
607            /**
608            * Finds the last bookmarks folder in the ordered set where companyId = &#63;.
609            *
610            * <p>
611            * 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.
612            * </p>
613            *
614            * @param companyId the company id to search with
615            * @param orderByComparator the comparator to order the set by
616            * @return the last matching bookmarks folder
617            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
618            * @throws SystemException if a system exception occurred
619            */
620            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last(
621                    long companyId,
622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
623                    throws com.liferay.portal.kernel.exception.SystemException,
624                            com.liferay.portlet.bookmarks.NoSuchFolderException {
625                    return getPersistence()
626                                       .findByCompanyId_Last(companyId, orderByComparator);
627            }
628    
629            /**
630            * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = &#63;.
631            *
632            * <p>
633            * 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.
634            * </p>
635            *
636            * @param folderId the primary key of the current bookmarks folder
637            * @param companyId the company id to search with
638            * @param orderByComparator the comparator to order the set by
639            * @return the previous, current, and next bookmarks folder
640            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
641            * @throws SystemException if a system exception occurred
642            */
643            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext(
644                    long folderId, long companyId,
645                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
646                    throws com.liferay.portal.kernel.exception.SystemException,
647                            com.liferay.portlet.bookmarks.NoSuchFolderException {
648                    return getPersistence()
649                                       .findByCompanyId_PrevAndNext(folderId, companyId,
650                            orderByComparator);
651            }
652    
653            /**
654            * Finds all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
655            *
656            * @param groupId the group id to search with
657            * @param parentFolderId the parent folder id to search with
658            * @return the matching bookmarks folders
659            * @throws SystemException if a system exception occurred
660            */
661            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
662                    long groupId, long parentFolderId)
663                    throws com.liferay.portal.kernel.exception.SystemException {
664                    return getPersistence().findByG_P(groupId, parentFolderId);
665            }
666    
667            /**
668            * Finds a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
669            *
670            * <p>
671            * 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.
672            * </p>
673            *
674            * @param groupId the group id to search with
675            * @param parentFolderId the parent folder id to search with
676            * @param start the lower bound of the range of bookmarks folders to return
677            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
678            * @return the range of matching bookmarks folders
679            * @throws SystemException if a system exception occurred
680            */
681            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
682                    long groupId, long parentFolderId, int start, int end)
683                    throws com.liferay.portal.kernel.exception.SystemException {
684                    return getPersistence().findByG_P(groupId, parentFolderId, start, end);
685            }
686    
687            /**
688            * Finds an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
689            *
690            * <p>
691            * 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.
692            * </p>
693            *
694            * @param groupId the group id to search with
695            * @param parentFolderId the parent folder id to search with
696            * @param start the lower bound of the range of bookmarks folders to return
697            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
698            * @param orderByComparator the comparator to order the results by
699            * @return the ordered range of matching bookmarks folders
700            * @throws SystemException if a system exception occurred
701            */
702            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
703                    long groupId, long parentFolderId, int start, int end,
704                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
705                    throws com.liferay.portal.kernel.exception.SystemException {
706                    return getPersistence()
707                                       .findByG_P(groupId, parentFolderId, start, end,
708                            orderByComparator);
709            }
710    
711            /**
712            * Finds the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
713            *
714            * <p>
715            * 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.
716            * </p>
717            *
718            * @param groupId the group id to search with
719            * @param parentFolderId the parent folder id to search with
720            * @param orderByComparator the comparator to order the set by
721            * @return the first matching bookmarks folder
722            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
723            * @throws SystemException if a system exception occurred
724            */
725            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First(
726                    long groupId, long parentFolderId,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.kernel.exception.SystemException,
729                            com.liferay.portlet.bookmarks.NoSuchFolderException {
730                    return getPersistence()
731                                       .findByG_P_First(groupId, parentFolderId, orderByComparator);
732            }
733    
734            /**
735            * Finds the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
736            *
737            * <p>
738            * 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.
739            * </p>
740            *
741            * @param groupId the group id to search with
742            * @param parentFolderId the parent folder id to search with
743            * @param orderByComparator the comparator to order the set by
744            * @return the last matching bookmarks folder
745            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
746            * @throws SystemException if a system exception occurred
747            */
748            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last(
749                    long groupId, long parentFolderId,
750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
751                    throws com.liferay.portal.kernel.exception.SystemException,
752                            com.liferay.portlet.bookmarks.NoSuchFolderException {
753                    return getPersistence()
754                                       .findByG_P_Last(groupId, parentFolderId, orderByComparator);
755            }
756    
757            /**
758            * Finds the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
759            *
760            * <p>
761            * 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.
762            * </p>
763            *
764            * @param folderId the primary key of the current bookmarks folder
765            * @param groupId the group id to search with
766            * @param parentFolderId the parent folder id to search with
767            * @param orderByComparator the comparator to order the set by
768            * @return the previous, current, and next bookmarks folder
769            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
770            * @throws SystemException if a system exception occurred
771            */
772            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext(
773                    long folderId, long groupId, long parentFolderId,
774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
775                    throws com.liferay.portal.kernel.exception.SystemException,
776                            com.liferay.portlet.bookmarks.NoSuchFolderException {
777                    return getPersistence()
778                                       .findByG_P_PrevAndNext(folderId, groupId, parentFolderId,
779                            orderByComparator);
780            }
781    
782            /**
783            * Filters by the user's permissions and finds all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
784            *
785            * @param groupId the group id to search with
786            * @param parentFolderId the parent folder id to search with
787            * @return the matching bookmarks folders that the user has permission to view
788            * @throws SystemException if a system exception occurred
789            */
790            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
791                    long groupId, long parentFolderId)
792                    throws com.liferay.portal.kernel.exception.SystemException {
793                    return getPersistence().filterFindByG_P(groupId, parentFolderId);
794            }
795    
796            /**
797            * Filters by the user's permissions and finds a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
798            *
799            * <p>
800            * 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.
801            * </p>
802            *
803            * @param groupId the group id to search with
804            * @param parentFolderId the parent folder id to search with
805            * @param start the lower bound of the range of bookmarks folders to return
806            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
807            * @return the range of matching bookmarks folders that the user has permission to view
808            * @throws SystemException if a system exception occurred
809            */
810            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
811                    long groupId, long parentFolderId, int start, int end)
812                    throws com.liferay.portal.kernel.exception.SystemException {
813                    return getPersistence()
814                                       .filterFindByG_P(groupId, parentFolderId, start, end);
815            }
816    
817            /**
818            * Filters by the user's permissions and finds an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
819            *
820            * <p>
821            * 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.
822            * </p>
823            *
824            * @param groupId the group id to search with
825            * @param parentFolderId the parent folder id to search with
826            * @param start the lower bound of the range of bookmarks folders to return
827            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
828            * @param orderByComparator the comparator to order the results by
829            * @return the ordered range of matching bookmarks folders that the user has permission to view
830            * @throws SystemException if a system exception occurred
831            */
832            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
833                    long groupId, long parentFolderId, int start, int end,
834                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
835                    throws com.liferay.portal.kernel.exception.SystemException {
836                    return getPersistence()
837                                       .filterFindByG_P(groupId, parentFolderId, start, end,
838                            orderByComparator);
839            }
840    
841            /**
842            * Finds all the bookmarks folders.
843            *
844            * @return the bookmarks folders
845            * @throws SystemException if a system exception occurred
846            */
847            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll()
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    return getPersistence().findAll();
850            }
851    
852            /**
853            * Finds a range of all the bookmarks folders.
854            *
855            * <p>
856            * 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.
857            * </p>
858            *
859            * @param start the lower bound of the range of bookmarks folders to return
860            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
861            * @return the range of bookmarks folders
862            * @throws SystemException if a system exception occurred
863            */
864            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
865                    int start, int end)
866                    throws com.liferay.portal.kernel.exception.SystemException {
867                    return getPersistence().findAll(start, end);
868            }
869    
870            /**
871            * Finds an ordered range of all the bookmarks folders.
872            *
873            * <p>
874            * 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.
875            * </p>
876            *
877            * @param start the lower bound of the range of bookmarks folders to return
878            * @param end the upper bound of the range of bookmarks folders to return (not inclusive)
879            * @param orderByComparator the comparator to order the results by
880            * @return the ordered range of bookmarks folders
881            * @throws SystemException if a system exception occurred
882            */
883            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
884                    int start, int end,
885                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence().findAll(start, end, orderByComparator);
888            }
889    
890            /**
891            * Removes all the bookmarks folders where uuid = &#63; from the database.
892            *
893            * @param uuid the uuid to search with
894            * @throws SystemException if a system exception occurred
895            */
896            public static void removeByUuid(java.lang.String uuid)
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    getPersistence().removeByUuid(uuid);
899            }
900    
901            /**
902            * Removes the bookmarks folder where uuid = &#63; and groupId = &#63; from the database.
903            *
904            * @param uuid the uuid to search with
905            * @param groupId the group id to search with
906            * @throws SystemException if a system exception occurred
907            */
908            public static void removeByUUID_G(java.lang.String uuid, long groupId)
909                    throws com.liferay.portal.kernel.exception.SystemException,
910                            com.liferay.portlet.bookmarks.NoSuchFolderException {
911                    getPersistence().removeByUUID_G(uuid, groupId);
912            }
913    
914            /**
915            * Removes all the bookmarks folders where groupId = &#63; from the database.
916            *
917            * @param groupId the group id to search with
918            * @throws SystemException if a system exception occurred
919            */
920            public static void removeByGroupId(long groupId)
921                    throws com.liferay.portal.kernel.exception.SystemException {
922                    getPersistence().removeByGroupId(groupId);
923            }
924    
925            /**
926            * Removes all the bookmarks folders where companyId = &#63; from the database.
927            *
928            * @param companyId the company id to search with
929            * @throws SystemException if a system exception occurred
930            */
931            public static void removeByCompanyId(long companyId)
932                    throws com.liferay.portal.kernel.exception.SystemException {
933                    getPersistence().removeByCompanyId(companyId);
934            }
935    
936            /**
937            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; from the database.
938            *
939            * @param groupId the group id to search with
940            * @param parentFolderId the parent folder id to search with
941            * @throws SystemException if a system exception occurred
942            */
943            public static void removeByG_P(long groupId, long parentFolderId)
944                    throws com.liferay.portal.kernel.exception.SystemException {
945                    getPersistence().removeByG_P(groupId, parentFolderId);
946            }
947    
948            /**
949            * Removes all the bookmarks folders from the database.
950            *
951            * @throws SystemException if a system exception occurred
952            */
953            public static void removeAll()
954                    throws com.liferay.portal.kernel.exception.SystemException {
955                    getPersistence().removeAll();
956            }
957    
958            /**
959            * Counts all the bookmarks folders where uuid = &#63;.
960            *
961            * @param uuid the uuid to search with
962            * @return the number of matching bookmarks folders
963            * @throws SystemException if a system exception occurred
964            */
965            public static int countByUuid(java.lang.String uuid)
966                    throws com.liferay.portal.kernel.exception.SystemException {
967                    return getPersistence().countByUuid(uuid);
968            }
969    
970            /**
971            * Counts all the bookmarks folders where uuid = &#63; and groupId = &#63;.
972            *
973            * @param uuid the uuid to search with
974            * @param groupId the group id to search with
975            * @return the number of matching bookmarks folders
976            * @throws SystemException if a system exception occurred
977            */
978            public static int countByUUID_G(java.lang.String uuid, long groupId)
979                    throws com.liferay.portal.kernel.exception.SystemException {
980                    return getPersistence().countByUUID_G(uuid, groupId);
981            }
982    
983            /**
984            * Counts all the bookmarks folders where groupId = &#63;.
985            *
986            * @param groupId the group id to search with
987            * @return the number of matching bookmarks folders
988            * @throws SystemException if a system exception occurred
989            */
990            public static int countByGroupId(long groupId)
991                    throws com.liferay.portal.kernel.exception.SystemException {
992                    return getPersistence().countByGroupId(groupId);
993            }
994    
995            /**
996            * Filters by the user's permissions and counts all the bookmarks folders where groupId = &#63;.
997            *
998            * @param groupId the group id to search with
999            * @return the number of matching bookmarks folders that the user has permission to view
1000            * @throws SystemException if a system exception occurred
1001            */
1002            public static int filterCountByGroupId(long groupId)
1003                    throws com.liferay.portal.kernel.exception.SystemException {
1004                    return getPersistence().filterCountByGroupId(groupId);
1005            }
1006    
1007            /**
1008            * Counts all the bookmarks folders where companyId = &#63;.
1009            *
1010            * @param companyId the company id to search with
1011            * @return the number of matching bookmarks folders
1012            * @throws SystemException if a system exception occurred
1013            */
1014            public static int countByCompanyId(long companyId)
1015                    throws com.liferay.portal.kernel.exception.SystemException {
1016                    return getPersistence().countByCompanyId(companyId);
1017            }
1018    
1019            /**
1020            * Counts all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
1021            *
1022            * @param groupId the group id to search with
1023            * @param parentFolderId the parent folder id to search with
1024            * @return the number of matching bookmarks folders
1025            * @throws SystemException if a system exception occurred
1026            */
1027            public static int countByG_P(long groupId, long parentFolderId)
1028                    throws com.liferay.portal.kernel.exception.SystemException {
1029                    return getPersistence().countByG_P(groupId, parentFolderId);
1030            }
1031    
1032            /**
1033            * Filters by the user's permissions and counts all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
1034            *
1035            * @param groupId the group id to search with
1036            * @param parentFolderId the parent folder id to search with
1037            * @return the number of matching bookmarks folders that the user has permission to view
1038            * @throws SystemException if a system exception occurred
1039            */
1040            public static int filterCountByG_P(long groupId, long parentFolderId)
1041                    throws com.liferay.portal.kernel.exception.SystemException {
1042                    return getPersistence().filterCountByG_P(groupId, parentFolderId);
1043            }
1044    
1045            /**
1046            * Counts all the bookmarks folders.
1047            *
1048            * @return the number of bookmarks folders
1049            * @throws SystemException if a system exception occurred
1050            */
1051            public static int countAll()
1052                    throws com.liferay.portal.kernel.exception.SystemException {
1053                    return getPersistence().countAll();
1054            }
1055    
1056            public static BookmarksFolderPersistence getPersistence() {
1057                    if (_persistence == null) {
1058                            _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName());
1059                    }
1060    
1061                    return _persistence;
1062            }
1063    
1064            public void setPersistence(BookmarksFolderPersistence persistence) {
1065                    _persistence = persistence;
1066            }
1067    
1068            private static BookmarksFolderPersistence _persistence;
1069    }