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