001    /**
002     * Copyright (c) 2000-present 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 aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.bookmarks.model.BookmarksFolder;
026    
027    import java.util.List;
028    
029    /**
030     * 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see BookmarksFolderPersistence
038     * @see BookmarksFolderPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class BookmarksFolderUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(BookmarksFolder bookmarksFolder) {
060                    getPersistence().clearCache(bookmarksFolder);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<BookmarksFolder> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<BookmarksFolder> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
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<BookmarksFolder> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BookmarksFolder update(BookmarksFolder bookmarksFolder) {
101                    return getPersistence().update(bookmarksFolder);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static BookmarksFolder update(BookmarksFolder bookmarksFolder,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(bookmarksFolder, serviceContext);
110            }
111    
112            /**
113            * Returns all the bookmarks folders where resourceBlockId = &#63;.
114            *
115            * @param resourceBlockId the resource block ID
116            * @return the matching bookmarks folders
117            */
118            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId(
119                    long resourceBlockId) {
120                    return getPersistence().findByResourceBlockId(resourceBlockId);
121            }
122    
123            /**
124            * Returns a range of all the bookmarks folders where resourceBlockId = &#63;.
125            *
126            * <p>
127            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
128            * </p>
129            *
130            * @param resourceBlockId the resource block ID
131            * @param start the lower bound of the range of bookmarks folders
132            * @param end the upper bound of the range of bookmarks folders (not inclusive)
133            * @return the range of matching bookmarks folders
134            */
135            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId(
136                    long resourceBlockId, int start, int end) {
137                    return getPersistence()
138                                       .findByResourceBlockId(resourceBlockId, start, end);
139            }
140    
141            /**
142            * Returns an ordered range of all the bookmarks folders where resourceBlockId = &#63;.
143            *
144            * <p>
145            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
146            * </p>
147            *
148            * @param resourceBlockId the resource block ID
149            * @param start the lower bound of the range of bookmarks folders
150            * @param end the upper bound of the range of bookmarks folders (not inclusive)
151            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
152            * @return the ordered range of matching bookmarks folders
153            */
154            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId(
155                    long resourceBlockId, int start, int end,
156                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
157                    return getPersistence()
158                                       .findByResourceBlockId(resourceBlockId, start, end,
159                            orderByComparator);
160            }
161    
162            /**
163            * Returns the first bookmarks folder in the ordered set where resourceBlockId = &#63;.
164            *
165            * @param resourceBlockId the resource block ID
166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
167            * @return the first matching bookmarks folder
168            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
169            */
170            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_First(
171                    long resourceBlockId,
172                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
173                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
174                    return getPersistence()
175                                       .findByResourceBlockId_First(resourceBlockId,
176                            orderByComparator);
177            }
178    
179            /**
180            * Returns the first bookmarks folder in the ordered set where resourceBlockId = &#63;.
181            *
182            * @param resourceBlockId the resource block ID
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
185            */
186            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_First(
187                    long resourceBlockId,
188                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
189                    return getPersistence()
190                                       .fetchByResourceBlockId_First(resourceBlockId,
191                            orderByComparator);
192            }
193    
194            /**
195            * Returns the last bookmarks folder in the ordered set where resourceBlockId = &#63;.
196            *
197            * @param resourceBlockId the resource block ID
198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
199            * @return the last matching bookmarks folder
200            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
201            */
202            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_Last(
203                    long resourceBlockId,
204                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
205                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
206                    return getPersistence()
207                                       .findByResourceBlockId_Last(resourceBlockId,
208                            orderByComparator);
209            }
210    
211            /**
212            * Returns the last bookmarks folder in the ordered set where resourceBlockId = &#63;.
213            *
214            * @param resourceBlockId the resource block ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
217            */
218            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_Last(
219                    long resourceBlockId,
220                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
221                    return getPersistence()
222                                       .fetchByResourceBlockId_Last(resourceBlockId,
223                            orderByComparator);
224            }
225    
226            /**
227            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where resourceBlockId = &#63;.
228            *
229            * @param folderId the primary key of the current bookmarks folder
230            * @param resourceBlockId the resource block ID
231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
232            * @return the previous, current, and next bookmarks folder
233            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
234            */
235            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByResourceBlockId_PrevAndNext(
236                    long folderId, long resourceBlockId,
237                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
238                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
239                    return getPersistence()
240                                       .findByResourceBlockId_PrevAndNext(folderId,
241                            resourceBlockId, orderByComparator);
242            }
243    
244            /**
245            * Removes all the bookmarks folders where resourceBlockId = &#63; from the database.
246            *
247            * @param resourceBlockId the resource block ID
248            */
249            public static void removeByResourceBlockId(long resourceBlockId) {
250                    getPersistence().removeByResourceBlockId(resourceBlockId);
251            }
252    
253            /**
254            * Returns the number of bookmarks folders where resourceBlockId = &#63;.
255            *
256            * @param resourceBlockId the resource block ID
257            * @return the number of matching bookmarks folders
258            */
259            public static int countByResourceBlockId(long resourceBlockId) {
260                    return getPersistence().countByResourceBlockId(resourceBlockId);
261            }
262    
263            /**
264            * Returns all the bookmarks folders where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @return the matching bookmarks folders
268            */
269            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
270                    java.lang.String uuid) {
271                    return getPersistence().findByUuid(uuid);
272            }
273    
274            /**
275            * Returns a range of all the bookmarks folders where uuid = &#63;.
276            *
277            * <p>
278            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
279            * </p>
280            *
281            * @param uuid the uuid
282            * @param start the lower bound of the range of bookmarks folders
283            * @param end the upper bound of the range of bookmarks folders (not inclusive)
284            * @return the range of matching bookmarks folders
285            */
286            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
287                    java.lang.String uuid, int start, int end) {
288                    return getPersistence().findByUuid(uuid, start, end);
289            }
290    
291            /**
292            * Returns an ordered range of all the bookmarks folders where uuid = &#63;.
293            *
294            * <p>
295            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
296            * </p>
297            *
298            * @param uuid the uuid
299            * @param start the lower bound of the range of bookmarks folders
300            * @param end the upper bound of the range of bookmarks folders (not inclusive)
301            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
302            * @return the ordered range of matching bookmarks folders
303            */
304            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid(
305                    java.lang.String uuid, int start, int end,
306                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
307                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
308            }
309    
310            /**
311            * Returns the first bookmarks folder in the ordered set where uuid = &#63;.
312            *
313            * @param uuid the uuid
314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
315            * @return the first matching bookmarks folder
316            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
317            */
318            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First(
319                    java.lang.String uuid,
320                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
321                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
322                    return getPersistence().findByUuid_First(uuid, orderByComparator);
323            }
324    
325            /**
326            * Returns the first bookmarks folder in the ordered set where uuid = &#63;.
327            *
328            * @param uuid the uuid
329            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
330            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
331            */
332            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_First(
333                    java.lang.String uuid,
334                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
335                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
336            }
337    
338            /**
339            * Returns the last bookmarks folder in the ordered set where uuid = &#63;.
340            *
341            * @param uuid the uuid
342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
343            * @return the last matching bookmarks folder
344            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
345            */
346            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last(
347                    java.lang.String uuid,
348                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
349                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
350                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
351            }
352    
353            /**
354            * Returns the last bookmarks folder in the ordered set where uuid = &#63;.
355            *
356            * @param uuid the uuid
357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
358            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
359            */
360            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_Last(
361                    java.lang.String uuid,
362                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
363                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
364            }
365    
366            /**
367            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = &#63;.
368            *
369            * @param folderId the primary key of the current bookmarks folder
370            * @param uuid the uuid
371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
372            * @return the previous, current, and next bookmarks folder
373            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
374            */
375            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext(
376                    long folderId, java.lang.String uuid,
377                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
378                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
379                    return getPersistence()
380                                       .findByUuid_PrevAndNext(folderId, uuid, orderByComparator);
381            }
382    
383            /**
384            * Removes all the bookmarks folders where uuid = &#63; from the database.
385            *
386            * @param uuid the uuid
387            */
388            public static void removeByUuid(java.lang.String uuid) {
389                    getPersistence().removeByUuid(uuid);
390            }
391    
392            /**
393            * Returns the number of bookmarks folders where uuid = &#63;.
394            *
395            * @param uuid the uuid
396            * @return the number of matching bookmarks folders
397            */
398            public static int countByUuid(java.lang.String uuid) {
399                    return getPersistence().countByUuid(uuid);
400            }
401    
402            /**
403            * 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.
404            *
405            * @param uuid the uuid
406            * @param groupId the group ID
407            * @return the matching bookmarks folder
408            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
409            */
410            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G(
411                    java.lang.String uuid, long groupId)
412                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
413                    return getPersistence().findByUUID_G(uuid, groupId);
414            }
415    
416            /**
417            * 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.
418            *
419            * @param uuid the uuid
420            * @param groupId the group ID
421            * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
422            */
423            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G(
424                    java.lang.String uuid, long groupId) {
425                    return getPersistence().fetchByUUID_G(uuid, groupId);
426            }
427    
428            /**
429            * 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.
430            *
431            * @param uuid the uuid
432            * @param groupId the group ID
433            * @param retrieveFromCache whether to use the finder cache
434            * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
435            */
436            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G(
437                    java.lang.String uuid, long groupId, boolean retrieveFromCache) {
438                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
439            }
440    
441            /**
442            * Removes the bookmarks folder where uuid = &#63; and groupId = &#63; from the database.
443            *
444            * @param uuid the uuid
445            * @param groupId the group ID
446            * @return the bookmarks folder that was removed
447            */
448            public static com.liferay.portlet.bookmarks.model.BookmarksFolder removeByUUID_G(
449                    java.lang.String uuid, long groupId)
450                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
451                    return getPersistence().removeByUUID_G(uuid, groupId);
452            }
453    
454            /**
455            * Returns the number of bookmarks folders where uuid = &#63; and groupId = &#63;.
456            *
457            * @param uuid the uuid
458            * @param groupId the group ID
459            * @return the number of matching bookmarks folders
460            */
461            public static int countByUUID_G(java.lang.String uuid, long groupId) {
462                    return getPersistence().countByUUID_G(uuid, groupId);
463            }
464    
465            /**
466            * Returns all the bookmarks folders where uuid = &#63; and companyId = &#63;.
467            *
468            * @param uuid the uuid
469            * @param companyId the company ID
470            * @return the matching bookmarks folders
471            */
472            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C(
473                    java.lang.String uuid, long companyId) {
474                    return getPersistence().findByUuid_C(uuid, companyId);
475            }
476    
477            /**
478            * Returns a range of all the bookmarks folders where uuid = &#63; and companyId = &#63;.
479            *
480            * <p>
481            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
482            * </p>
483            *
484            * @param uuid the uuid
485            * @param companyId the company ID
486            * @param start the lower bound of the range of bookmarks folders
487            * @param end the upper bound of the range of bookmarks folders (not inclusive)
488            * @return the range of matching bookmarks folders
489            */
490            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C(
491                    java.lang.String uuid, long companyId, int start, int end) {
492                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
493            }
494    
495            /**
496            * Returns an ordered range of all the bookmarks folders where uuid = &#63; and companyId = &#63;.
497            *
498            * <p>
499            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
500            * </p>
501            *
502            * @param uuid the uuid
503            * @param companyId the company 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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
507            * @return the ordered range of matching bookmarks folders
508            */
509            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C(
510                    java.lang.String uuid, long companyId, int start, int end,
511                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
512                    return getPersistence()
513                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
514            }
515    
516            /**
517            * Returns the first bookmarks folder in the ordered set where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
522            * @return the first matching bookmarks folder
523            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
524            */
525            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_First(
526                    java.lang.String uuid, long companyId,
527                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
528                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
529                    return getPersistence()
530                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
531            }
532    
533            /**
534            * Returns the first bookmarks folder in the ordered set where uuid = &#63; and companyId = &#63;.
535            *
536            * @param uuid the uuid
537            * @param companyId the company ID
538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
539            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
540            */
541            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_First(
542                    java.lang.String uuid, long companyId,
543                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
544                    return getPersistence()
545                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
546            }
547    
548            /**
549            * Returns the last bookmarks folder in the ordered set where uuid = &#63; and companyId = &#63;.
550            *
551            * @param uuid the uuid
552            * @param companyId the company ID
553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
554            * @return the last matching bookmarks folder
555            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
556            */
557            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_Last(
558                    java.lang.String uuid, long companyId,
559                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
560                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
561                    return getPersistence()
562                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
563            }
564    
565            /**
566            * Returns the last bookmarks folder in the ordered set where uuid = &#63; and companyId = &#63;.
567            *
568            * @param uuid the uuid
569            * @param companyId the company ID
570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
571            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
572            */
573            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_Last(
574                    java.lang.String uuid, long companyId,
575                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
576                    return getPersistence()
577                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
578            }
579    
580            /**
581            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = &#63; and companyId = &#63;.
582            *
583            * @param folderId the primary key of the current bookmarks folder
584            * @param uuid the uuid
585            * @param companyId the company ID
586            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
587            * @return the previous, current, and next bookmarks folder
588            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
589            */
590            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_C_PrevAndNext(
591                    long folderId, java.lang.String uuid, long companyId,
592                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
593                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
594                    return getPersistence()
595                                       .findByUuid_C_PrevAndNext(folderId, uuid, companyId,
596                            orderByComparator);
597            }
598    
599            /**
600            * Removes all the bookmarks folders where uuid = &#63; and companyId = &#63; from the database.
601            *
602            * @param uuid the uuid
603            * @param companyId the company ID
604            */
605            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
606                    getPersistence().removeByUuid_C(uuid, companyId);
607            }
608    
609            /**
610            * Returns the number of bookmarks folders where uuid = &#63; and companyId = &#63;.
611            *
612            * @param uuid the uuid
613            * @param companyId the company ID
614            * @return the number of matching bookmarks folders
615            */
616            public static int countByUuid_C(java.lang.String uuid, long companyId) {
617                    return getPersistence().countByUuid_C(uuid, companyId);
618            }
619    
620            /**
621            * Returns all the bookmarks folders where groupId = &#63;.
622            *
623            * @param groupId the group ID
624            * @return the matching bookmarks folders
625            */
626            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
627                    long groupId) {
628                    return getPersistence().findByGroupId(groupId);
629            }
630    
631            /**
632            * Returns a range of all the bookmarks folders where groupId = &#63;.
633            *
634            * <p>
635            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
636            * </p>
637            *
638            * @param groupId the group ID
639            * @param start the lower bound of the range of bookmarks folders
640            * @param end the upper bound of the range of bookmarks folders (not inclusive)
641            * @return the range of matching bookmarks folders
642            */
643            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
644                    long groupId, int start, int end) {
645                    return getPersistence().findByGroupId(groupId, start, end);
646            }
647    
648            /**
649            * Returns an ordered range of all the bookmarks folders where groupId = &#63;.
650            *
651            * <p>
652            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
653            * </p>
654            *
655            * @param groupId the group ID
656            * @param start the lower bound of the range of bookmarks folders
657            * @param end the upper bound of the range of bookmarks folders (not inclusive)
658            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
659            * @return the ordered range of matching bookmarks folders
660            */
661            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId(
662                    long groupId, int start, int end,
663                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
664                    return getPersistence()
665                                       .findByGroupId(groupId, start, end, orderByComparator);
666            }
667    
668            /**
669            * Returns the first bookmarks folder in the ordered set where groupId = &#63;.
670            *
671            * @param groupId the group ID
672            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
673            * @return the first matching bookmarks folder
674            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
675            */
676            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First(
677                    long groupId,
678                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
679                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
680                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
681            }
682    
683            /**
684            * Returns the first bookmarks folder in the ordered set where groupId = &#63;.
685            *
686            * @param groupId the group ID
687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
688            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
689            */
690            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_First(
691                    long groupId,
692                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
693                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
694            }
695    
696            /**
697            * Returns the last bookmarks folder in the ordered set where groupId = &#63;.
698            *
699            * @param groupId the group ID
700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
701            * @return the last matching bookmarks folder
702            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
703            */
704            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last(
705                    long groupId,
706                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
707                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
708                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
709            }
710    
711            /**
712            * Returns the last bookmarks folder in the ordered set where groupId = &#63;.
713            *
714            * @param groupId the group ID
715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
716            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
717            */
718            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_Last(
719                    long groupId,
720                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
721                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
722            }
723    
724            /**
725            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63;.
726            *
727            * @param folderId the primary key of the current bookmarks folder
728            * @param groupId the group ID
729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
730            * @return the previous, current, and next bookmarks folder
731            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
732            */
733            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext(
734                    long folderId, long groupId,
735                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
736                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
737                    return getPersistence()
738                                       .findByGroupId_PrevAndNext(folderId, groupId,
739                            orderByComparator);
740            }
741    
742            /**
743            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63;.
744            *
745            * @param groupId the group ID
746            * @return the matching bookmarks folders that the user has permission to view
747            */
748            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
749                    long groupId) {
750                    return getPersistence().filterFindByGroupId(groupId);
751            }
752    
753            /**
754            * Returns a range of all the bookmarks folders that the user has permission to view where groupId = &#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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
758            * </p>
759            *
760            * @param groupId the group ID
761            * @param start the lower bound of the range of bookmarks folders
762            * @param end the upper bound of the range of bookmarks folders (not inclusive)
763            * @return the range of matching bookmarks folders that the user has permission to view
764            */
765            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
766                    long groupId, int start, int end) {
767                    return getPersistence().filterFindByGroupId(groupId, start, end);
768            }
769    
770            /**
771            * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = &#63;.
772            *
773            * <p>
774            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
775            * </p>
776            *
777            * @param groupId the group ID
778            * @param start the lower bound of the range of bookmarks folders
779            * @param end the upper bound of the range of bookmarks folders (not inclusive)
780            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
781            * @return the ordered range of matching bookmarks folders that the user has permission to view
782            */
783            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId(
784                    long groupId, int start, int end,
785                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
786                    return getPersistence()
787                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
788            }
789    
790            /**
791            * 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;.
792            *
793            * @param folderId the primary key of the current bookmarks folder
794            * @param groupId the group ID
795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
796            * @return the previous, current, and next bookmarks folder
797            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
798            */
799            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext(
800                    long folderId, long groupId,
801                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
802                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
803                    return getPersistence()
804                                       .filterFindByGroupId_PrevAndNext(folderId, groupId,
805                            orderByComparator);
806            }
807    
808            /**
809            * Removes all the bookmarks folders where groupId = &#63; from the database.
810            *
811            * @param groupId the group ID
812            */
813            public static void removeByGroupId(long groupId) {
814                    getPersistence().removeByGroupId(groupId);
815            }
816    
817            /**
818            * Returns the number of bookmarks folders where groupId = &#63;.
819            *
820            * @param groupId the group ID
821            * @return the number of matching bookmarks folders
822            */
823            public static int countByGroupId(long groupId) {
824                    return getPersistence().countByGroupId(groupId);
825            }
826    
827            /**
828            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63;.
829            *
830            * @param groupId the group ID
831            * @return the number of matching bookmarks folders that the user has permission to view
832            */
833            public static int filterCountByGroupId(long groupId) {
834                    return getPersistence().filterCountByGroupId(groupId);
835            }
836    
837            /**
838            * Returns all the bookmarks folders where companyId = &#63;.
839            *
840            * @param companyId the company ID
841            * @return the matching bookmarks folders
842            */
843            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
844                    long companyId) {
845                    return getPersistence().findByCompanyId(companyId);
846            }
847    
848            /**
849            * Returns a range of all the bookmarks folders where companyId = &#63;.
850            *
851            * <p>
852            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
853            * </p>
854            *
855            * @param companyId the company ID
856            * @param start the lower bound of the range of bookmarks folders
857            * @param end the upper bound of the range of bookmarks folders (not inclusive)
858            * @return the range of matching bookmarks folders
859            */
860            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
861                    long companyId, int start, int end) {
862                    return getPersistence().findByCompanyId(companyId, start, end);
863            }
864    
865            /**
866            * Returns an ordered range of all the bookmarks folders where companyId = &#63;.
867            *
868            * <p>
869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
870            * </p>
871            *
872            * @param companyId the company ID
873            * @param start the lower bound of the range of bookmarks folders
874            * @param end the upper bound of the range of bookmarks folders (not inclusive)
875            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
876            * @return the ordered range of matching bookmarks folders
877            */
878            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId(
879                    long companyId, int start, int end,
880                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
881                    return getPersistence()
882                                       .findByCompanyId(companyId, start, end, orderByComparator);
883            }
884    
885            /**
886            * Returns the first bookmarks folder in the ordered set where companyId = &#63;.
887            *
888            * @param companyId the company ID
889            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
890            * @return the first matching bookmarks folder
891            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
892            */
893            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First(
894                    long companyId,
895                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
896                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
897                    return getPersistence()
898                                       .findByCompanyId_First(companyId, orderByComparator);
899            }
900    
901            /**
902            * Returns the first bookmarks folder in the ordered set where companyId = &#63;.
903            *
904            * @param companyId the company ID
905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
906            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
907            */
908            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_First(
909                    long companyId,
910                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
911                    return getPersistence()
912                                       .fetchByCompanyId_First(companyId, orderByComparator);
913            }
914    
915            /**
916            * Returns the last bookmarks folder in the ordered set where companyId = &#63;.
917            *
918            * @param companyId the company ID
919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
920            * @return the last matching bookmarks folder
921            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
922            */
923            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last(
924                    long companyId,
925                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
926                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
927                    return getPersistence()
928                                       .findByCompanyId_Last(companyId, orderByComparator);
929            }
930    
931            /**
932            * Returns the last bookmarks folder in the ordered set where companyId = &#63;.
933            *
934            * @param companyId the company ID
935            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
936            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
937            */
938            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_Last(
939                    long companyId,
940                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
941                    return getPersistence()
942                                       .fetchByCompanyId_Last(companyId, orderByComparator);
943            }
944    
945            /**
946            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = &#63;.
947            *
948            * @param folderId the primary key of the current bookmarks folder
949            * @param companyId the company ID
950            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
951            * @return the previous, current, and next bookmarks folder
952            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
953            */
954            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext(
955                    long folderId, long companyId,
956                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
957                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
958                    return getPersistence()
959                                       .findByCompanyId_PrevAndNext(folderId, companyId,
960                            orderByComparator);
961            }
962    
963            /**
964            * Removes all the bookmarks folders where companyId = &#63; from the database.
965            *
966            * @param companyId the company ID
967            */
968            public static void removeByCompanyId(long companyId) {
969                    getPersistence().removeByCompanyId(companyId);
970            }
971    
972            /**
973            * Returns the number of bookmarks folders where companyId = &#63;.
974            *
975            * @param companyId the company ID
976            * @return the number of matching bookmarks folders
977            */
978            public static int countByCompanyId(long companyId) {
979                    return getPersistence().countByCompanyId(companyId);
980            }
981    
982            /**
983            * Returns all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
984            *
985            * @param groupId the group ID
986            * @param parentFolderId the parent folder ID
987            * @return the matching bookmarks folders
988            */
989            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
990                    long groupId, long parentFolderId) {
991                    return getPersistence().findByG_P(groupId, parentFolderId);
992            }
993    
994            /**
995            * Returns a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
996            *
997            * <p>
998            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
999            * </p>
1000            *
1001            * @param groupId the group ID
1002            * @param parentFolderId the parent folder ID
1003            * @param start the lower bound of the range of bookmarks folders
1004            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1005            * @return the range of matching bookmarks folders
1006            */
1007            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
1008                    long groupId, long parentFolderId, int start, int end) {
1009                    return getPersistence().findByG_P(groupId, parentFolderId, start, end);
1010            }
1011    
1012            /**
1013            * Returns an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
1014            *
1015            * <p>
1016            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1017            * </p>
1018            *
1019            * @param groupId the group ID
1020            * @param parentFolderId the parent folder ID
1021            * @param start the lower bound of the range of bookmarks folders
1022            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1023            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1024            * @return the ordered range of matching bookmarks folders
1025            */
1026            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P(
1027                    long groupId, long parentFolderId, int start, int end,
1028                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1029                    return getPersistence()
1030                                       .findByG_P(groupId, parentFolderId, start, end,
1031                            orderByComparator);
1032            }
1033    
1034            /**
1035            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1036            *
1037            * @param groupId the group ID
1038            * @param parentFolderId the parent folder ID
1039            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1040            * @return the first matching bookmarks folder
1041            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1042            */
1043            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First(
1044                    long groupId, long parentFolderId,
1045                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1046                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1047                    return getPersistence()
1048                                       .findByG_P_First(groupId, parentFolderId, orderByComparator);
1049            }
1050    
1051            /**
1052            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1053            *
1054            * @param groupId the group ID
1055            * @param parentFolderId the parent folder ID
1056            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1057            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1058            */
1059            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_First(
1060                    long groupId, long parentFolderId,
1061                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1062                    return getPersistence()
1063                                       .fetchByG_P_First(groupId, parentFolderId, orderByComparator);
1064            }
1065    
1066            /**
1067            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1068            *
1069            * @param groupId the group ID
1070            * @param parentFolderId the parent folder ID
1071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1072            * @return the last matching bookmarks folder
1073            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1074            */
1075            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last(
1076                    long groupId, long parentFolderId,
1077                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1078                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1079                    return getPersistence()
1080                                       .findByG_P_Last(groupId, parentFolderId, orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1085            *
1086            * @param groupId the group ID
1087            * @param parentFolderId the parent folder ID
1088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1089            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1090            */
1091            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_Last(
1092                    long groupId, long parentFolderId,
1093                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1094                    return getPersistence()
1095                                       .fetchByG_P_Last(groupId, parentFolderId, orderByComparator);
1096            }
1097    
1098            /**
1099            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
1100            *
1101            * @param folderId the primary key of the current bookmarks folder
1102            * @param groupId the group ID
1103            * @param parentFolderId the parent folder ID
1104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1105            * @return the previous, current, and next bookmarks folder
1106            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1107            */
1108            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext(
1109                    long folderId, long groupId, long parentFolderId,
1110                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1111                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1112                    return getPersistence()
1113                                       .findByG_P_PrevAndNext(folderId, groupId, parentFolderId,
1114                            orderByComparator);
1115            }
1116    
1117            /**
1118            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1119            *
1120            * @param groupId the group ID
1121            * @param parentFolderId the parent folder ID
1122            * @return the matching bookmarks folders that the user has permission to view
1123            */
1124            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
1125                    long groupId, long parentFolderId) {
1126                    return getPersistence().filterFindByG_P(groupId, parentFolderId);
1127            }
1128    
1129            /**
1130            * Returns a range of all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1131            *
1132            * <p>
1133            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1134            * </p>
1135            *
1136            * @param groupId the group ID
1137            * @param parentFolderId the parent folder ID
1138            * @param start the lower bound of the range of bookmarks folders
1139            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1140            * @return the range of matching bookmarks folders that the user has permission to view
1141            */
1142            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
1143                    long groupId, long parentFolderId, int start, int end) {
1144                    return getPersistence()
1145                                       .filterFindByG_P(groupId, parentFolderId, start, end);
1146            }
1147    
1148            /**
1149            * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63;.
1150            *
1151            * <p>
1152            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1153            * </p>
1154            *
1155            * @param groupId the group ID
1156            * @param parentFolderId the parent folder ID
1157            * @param start the lower bound of the range of bookmarks folders
1158            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1159            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1160            * @return the ordered range of matching bookmarks folders that the user has permission to view
1161            */
1162            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P(
1163                    long groupId, long parentFolderId, int start, int end,
1164                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1165                    return getPersistence()
1166                                       .filterFindByG_P(groupId, parentFolderId, start, end,
1167                            orderByComparator);
1168            }
1169    
1170            /**
1171            * 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;.
1172            *
1173            * @param folderId the primary key of the current bookmarks folder
1174            * @param groupId the group ID
1175            * @param parentFolderId the parent folder ID
1176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1177            * @return the previous, current, and next bookmarks folder
1178            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1179            */
1180            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext(
1181                    long folderId, long groupId, long parentFolderId,
1182                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1183                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1184                    return getPersistence()
1185                                       .filterFindByG_P_PrevAndNext(folderId, groupId,
1186                            parentFolderId, orderByComparator);
1187            }
1188    
1189            /**
1190            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; from the database.
1191            *
1192            * @param groupId the group ID
1193            * @param parentFolderId the parent folder ID
1194            */
1195            public static void removeByG_P(long groupId, long parentFolderId) {
1196                    getPersistence().removeByG_P(groupId, parentFolderId);
1197            }
1198    
1199            /**
1200            * Returns the number of bookmarks folders where groupId = &#63; and parentFolderId = &#63;.
1201            *
1202            * @param groupId the group ID
1203            * @param parentFolderId the parent folder ID
1204            * @return the number of matching bookmarks folders
1205            */
1206            public static int countByG_P(long groupId, long parentFolderId) {
1207                    return getPersistence().countByG_P(groupId, parentFolderId);
1208            }
1209    
1210            /**
1211            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1212            *
1213            * @param groupId the group ID
1214            * @param parentFolderId the parent folder ID
1215            * @return the number of matching bookmarks folders that the user has permission to view
1216            */
1217            public static int filterCountByG_P(long groupId, long parentFolderId) {
1218                    return getPersistence().filterCountByG_P(groupId, parentFolderId);
1219            }
1220    
1221            /**
1222            * Returns all the bookmarks folders where companyId = &#63; and status &ne; &#63;.
1223            *
1224            * @param companyId the company ID
1225            * @param status the status
1226            * @return the matching bookmarks folders
1227            */
1228            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1229                    long companyId, int status) {
1230                    return getPersistence().findByC_NotS(companyId, status);
1231            }
1232    
1233            /**
1234            * Returns a range of all the bookmarks folders where companyId = &#63; and status &ne; &#63;.
1235            *
1236            * <p>
1237            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1238            * </p>
1239            *
1240            * @param companyId the company ID
1241            * @param status the status
1242            * @param start the lower bound of the range of bookmarks folders
1243            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1244            * @return the range of matching bookmarks folders
1245            */
1246            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1247                    long companyId, int status, int start, int end) {
1248                    return getPersistence().findByC_NotS(companyId, status, start, end);
1249            }
1250    
1251            /**
1252            * Returns an ordered range of all the bookmarks folders where companyId = &#63; and status &ne; &#63;.
1253            *
1254            * <p>
1255            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1256            * </p>
1257            *
1258            * @param companyId the company ID
1259            * @param status the status
1260            * @param start the lower bound of the range of bookmarks folders
1261            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1263            * @return the ordered range of matching bookmarks folders
1264            */
1265            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByC_NotS(
1266                    long companyId, int status, int start, int end,
1267                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1268                    return getPersistence()
1269                                       .findByC_NotS(companyId, status, start, end,
1270                            orderByComparator);
1271            }
1272    
1273            /**
1274            * Returns the first bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1275            *
1276            * @param companyId the company ID
1277            * @param status the status
1278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1279            * @return the first matching bookmarks folder
1280            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1281            */
1282            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_First(
1283                    long companyId, int status,
1284                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1285                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1286                    return getPersistence()
1287                                       .findByC_NotS_First(companyId, status, orderByComparator);
1288            }
1289    
1290            /**
1291            * Returns the first bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1292            *
1293            * @param companyId the company ID
1294            * @param status the status
1295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1296            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1297            */
1298            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_First(
1299                    long companyId, int status,
1300                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1301                    return getPersistence()
1302                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1303            }
1304    
1305            /**
1306            * Returns the last bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1307            *
1308            * @param companyId the company ID
1309            * @param status the status
1310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1311            * @return the last matching bookmarks folder
1312            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1313            */
1314            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByC_NotS_Last(
1315                    long companyId, int status,
1316                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1317                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1318                    return getPersistence()
1319                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1320            }
1321    
1322            /**
1323            * Returns the last bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1324            *
1325            * @param companyId the company ID
1326            * @param status the status
1327            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1328            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1329            */
1330            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByC_NotS_Last(
1331                    long companyId, int status,
1332                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1333                    return getPersistence()
1334                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1335            }
1336    
1337            /**
1338            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1339            *
1340            * @param folderId the primary key of the current bookmarks folder
1341            * @param companyId the company ID
1342            * @param status the status
1343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1344            * @return the previous, current, and next bookmarks folder
1345            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1346            */
1347            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByC_NotS_PrevAndNext(
1348                    long folderId, long companyId, int status,
1349                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1350                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1351                    return getPersistence()
1352                                       .findByC_NotS_PrevAndNext(folderId, companyId, status,
1353                            orderByComparator);
1354            }
1355    
1356            /**
1357            * Removes all the bookmarks folders where companyId = &#63; and status &ne; &#63; from the database.
1358            *
1359            * @param companyId the company ID
1360            * @param status the status
1361            */
1362            public static void removeByC_NotS(long companyId, int status) {
1363                    getPersistence().removeByC_NotS(companyId, status);
1364            }
1365    
1366            /**
1367            * Returns the number of bookmarks folders where companyId = &#63; and status &ne; &#63;.
1368            *
1369            * @param companyId the company ID
1370            * @param status the status
1371            * @return the number of matching bookmarks folders
1372            */
1373            public static int countByC_NotS(long companyId, int status) {
1374                    return getPersistence().countByC_NotS(companyId, status);
1375            }
1376    
1377            /**
1378            * Returns all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1379            *
1380            * @param groupId the group ID
1381            * @param parentFolderId the parent folder ID
1382            * @param status the status
1383            * @return the matching bookmarks folders
1384            */
1385            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1386                    long groupId, long parentFolderId, int status) {
1387                    return getPersistence().findByG_P_S(groupId, parentFolderId, status);
1388            }
1389    
1390            /**
1391            * Returns a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1392            *
1393            * <p>
1394            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1395            * </p>
1396            *
1397            * @param groupId the group ID
1398            * @param parentFolderId the parent folder ID
1399            * @param status the status
1400            * @param start the lower bound of the range of bookmarks folders
1401            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1402            * @return the range of matching bookmarks folders
1403            */
1404            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1405                    long groupId, long parentFolderId, int status, int start, int end) {
1406                    return getPersistence()
1407                                       .findByG_P_S(groupId, parentFolderId, status, start, end);
1408            }
1409    
1410            /**
1411            * Returns an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1412            *
1413            * <p>
1414            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1415            * </p>
1416            *
1417            * @param groupId the group ID
1418            * @param parentFolderId the parent folder ID
1419            * @param status the status
1420            * @param start the lower bound of the range of bookmarks folders
1421            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1422            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1423            * @return the ordered range of matching bookmarks folders
1424            */
1425            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S(
1426                    long groupId, long parentFolderId, int status, int start, int end,
1427                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1428                    return getPersistence()
1429                                       .findByG_P_S(groupId, parentFolderId, status, start, end,
1430                            orderByComparator);
1431            }
1432    
1433            /**
1434            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1435            *
1436            * @param groupId the group ID
1437            * @param parentFolderId the parent folder ID
1438            * @param status the status
1439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1440            * @return the first matching bookmarks folder
1441            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1442            */
1443            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_First(
1444                    long groupId, long parentFolderId, int status,
1445                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1446                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1447                    return getPersistence()
1448                                       .findByG_P_S_First(groupId, parentFolderId, status,
1449                            orderByComparator);
1450            }
1451    
1452            /**
1453            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1454            *
1455            * @param groupId the group ID
1456            * @param parentFolderId the parent folder ID
1457            * @param status the status
1458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1459            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1460            */
1461            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_First(
1462                    long groupId, long parentFolderId, int status,
1463                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1464                    return getPersistence()
1465                                       .fetchByG_P_S_First(groupId, parentFolderId, status,
1466                            orderByComparator);
1467            }
1468    
1469            /**
1470            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1471            *
1472            * @param groupId the group ID
1473            * @param parentFolderId the parent folder ID
1474            * @param status the status
1475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1476            * @return the last matching bookmarks folder
1477            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1478            */
1479            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_Last(
1480                    long groupId, long parentFolderId, int status,
1481                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1482                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1483                    return getPersistence()
1484                                       .findByG_P_S_Last(groupId, parentFolderId, status,
1485                            orderByComparator);
1486            }
1487    
1488            /**
1489            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1490            *
1491            * @param groupId the group ID
1492            * @param parentFolderId the parent folder ID
1493            * @param status the status
1494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1495            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1496            */
1497            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_Last(
1498                    long groupId, long parentFolderId, int status,
1499                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1500                    return getPersistence()
1501                                       .fetchByG_P_S_Last(groupId, parentFolderId, status,
1502                            orderByComparator);
1503            }
1504    
1505            /**
1506            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1507            *
1508            * @param folderId the primary key of the current bookmarks folder
1509            * @param groupId the group ID
1510            * @param parentFolderId the parent folder ID
1511            * @param status the status
1512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1513            * @return the previous, current, and next bookmarks folder
1514            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1515            */
1516            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_S_PrevAndNext(
1517                    long folderId, long groupId, long parentFolderId, int status,
1518                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1519                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1520                    return getPersistence()
1521                                       .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId,
1522                            status, orderByComparator);
1523            }
1524    
1525            /**
1526            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1527            *
1528            * @param groupId the group ID
1529            * @param parentFolderId the parent folder ID
1530            * @param status the status
1531            * @return the matching bookmarks folders that the user has permission to view
1532            */
1533            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1534                    long groupId, long parentFolderId, int status) {
1535                    return getPersistence()
1536                                       .filterFindByG_P_S(groupId, parentFolderId, status);
1537            }
1538    
1539            /**
1540            * Returns a range of all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1541            *
1542            * <p>
1543            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1544            * </p>
1545            *
1546            * @param groupId the group ID
1547            * @param parentFolderId the parent folder ID
1548            * @param status the status
1549            * @param start the lower bound of the range of bookmarks folders
1550            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1551            * @return the range of matching bookmarks folders that the user has permission to view
1552            */
1553            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1554                    long groupId, long parentFolderId, int status, int start, int end) {
1555                    return getPersistence()
1556                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1557                            end);
1558            }
1559    
1560            /**
1561            * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1562            *
1563            * <p>
1564            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1565            * </p>
1566            *
1567            * @param groupId the group ID
1568            * @param parentFolderId the parent folder ID
1569            * @param status the status
1570            * @param start the lower bound of the range of bookmarks folders
1571            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1572            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1573            * @return the ordered range of matching bookmarks folders that the user has permission to view
1574            */
1575            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S(
1576                    long groupId, long parentFolderId, int status, int start, int end,
1577                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1578                    return getPersistence()
1579                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1580                            end, orderByComparator);
1581            }
1582    
1583            /**
1584            * 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; and status = &#63;.
1585            *
1586            * @param folderId the primary key of the current bookmarks folder
1587            * @param groupId the group ID
1588            * @param parentFolderId the parent folder ID
1589            * @param status the status
1590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1591            * @return the previous, current, and next bookmarks folder
1592            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1593            */
1594            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_S_PrevAndNext(
1595                    long folderId, long groupId, long parentFolderId, int status,
1596                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1597                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1598                    return getPersistence()
1599                                       .filterFindByG_P_S_PrevAndNext(folderId, groupId,
1600                            parentFolderId, status, orderByComparator);
1601            }
1602    
1603            /**
1604            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63; from the database.
1605            *
1606            * @param groupId the group ID
1607            * @param parentFolderId the parent folder ID
1608            * @param status the status
1609            */
1610            public static void removeByG_P_S(long groupId, long parentFolderId,
1611                    int status) {
1612                    getPersistence().removeByG_P_S(groupId, parentFolderId, status);
1613            }
1614    
1615            /**
1616            * Returns the number of bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1617            *
1618            * @param groupId the group ID
1619            * @param parentFolderId the parent folder ID
1620            * @param status the status
1621            * @return the number of matching bookmarks folders
1622            */
1623            public static int countByG_P_S(long groupId, long parentFolderId, int status) {
1624                    return getPersistence().countByG_P_S(groupId, parentFolderId, status);
1625            }
1626    
1627            /**
1628            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1629            *
1630            * @param groupId the group ID
1631            * @param parentFolderId the parent folder ID
1632            * @param status the status
1633            * @return the number of matching bookmarks folders that the user has permission to view
1634            */
1635            public static int filterCountByG_P_S(long groupId, long parentFolderId,
1636                    int status) {
1637                    return getPersistence()
1638                                       .filterCountByG_P_S(groupId, parentFolderId, status);
1639            }
1640    
1641            /**
1642            * Returns all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1643            *
1644            * @param groupId the group ID
1645            * @param parentFolderId the parent folder ID
1646            * @param status the status
1647            * @return the matching bookmarks folders
1648            */
1649            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1650                    long groupId, long parentFolderId, int status) {
1651                    return getPersistence().findByG_P_NotS(groupId, parentFolderId, status);
1652            }
1653    
1654            /**
1655            * Returns a range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1656            *
1657            * <p>
1658            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1659            * </p>
1660            *
1661            * @param groupId the group ID
1662            * @param parentFolderId the parent folder ID
1663            * @param status the status
1664            * @param start the lower bound of the range of bookmarks folders
1665            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1666            * @return the range of matching bookmarks folders
1667            */
1668            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1669                    long groupId, long parentFolderId, int status, int start, int end) {
1670                    return getPersistence()
1671                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end);
1672            }
1673    
1674            /**
1675            * Returns an ordered range of all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1676            *
1677            * <p>
1678            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1679            * </p>
1680            *
1681            * @param groupId the group ID
1682            * @param parentFolderId the parent folder ID
1683            * @param status the status
1684            * @param start the lower bound of the range of bookmarks folders
1685            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1686            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1687            * @return the ordered range of matching bookmarks folders
1688            */
1689            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS(
1690                    long groupId, long parentFolderId, int status, int start, int end,
1691                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1692                    return getPersistence()
1693                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end,
1694                            orderByComparator);
1695            }
1696    
1697            /**
1698            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1699            *
1700            * @param groupId the group ID
1701            * @param parentFolderId the parent folder ID
1702            * @param status the status
1703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1704            * @return the first matching bookmarks folder
1705            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1706            */
1707            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_First(
1708                    long groupId, long parentFolderId, int status,
1709                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1710                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1711                    return getPersistence()
1712                                       .findByG_P_NotS_First(groupId, parentFolderId, status,
1713                            orderByComparator);
1714            }
1715    
1716            /**
1717            * Returns the first bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1718            *
1719            * @param groupId the group ID
1720            * @param parentFolderId the parent folder ID
1721            * @param status the status
1722            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1723            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1724            */
1725            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_First(
1726                    long groupId, long parentFolderId, int status,
1727                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1728                    return getPersistence()
1729                                       .fetchByG_P_NotS_First(groupId, parentFolderId, status,
1730                            orderByComparator);
1731            }
1732    
1733            /**
1734            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1735            *
1736            * @param groupId the group ID
1737            * @param parentFolderId the parent folder ID
1738            * @param status the status
1739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1740            * @return the last matching bookmarks folder
1741            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1742            */
1743            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_Last(
1744                    long groupId, long parentFolderId, int status,
1745                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1746                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1747                    return getPersistence()
1748                                       .findByG_P_NotS_Last(groupId, parentFolderId, status,
1749                            orderByComparator);
1750            }
1751    
1752            /**
1753            * Returns the last bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1754            *
1755            * @param groupId the group ID
1756            * @param parentFolderId the parent folder ID
1757            * @param status the status
1758            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1759            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1760            */
1761            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_Last(
1762                    long groupId, long parentFolderId, int status,
1763                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1764                    return getPersistence()
1765                                       .fetchByG_P_NotS_Last(groupId, parentFolderId, status,
1766                            orderByComparator);
1767            }
1768    
1769            /**
1770            * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1771            *
1772            * @param folderId the primary key of the current bookmarks folder
1773            * @param groupId the group ID
1774            * @param parentFolderId the parent folder ID
1775            * @param status the status
1776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1777            * @return the previous, current, and next bookmarks folder
1778            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1779            */
1780            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_NotS_PrevAndNext(
1781                    long folderId, long groupId, long parentFolderId, int status,
1782                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1783                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1784                    return getPersistence()
1785                                       .findByG_P_NotS_PrevAndNext(folderId, groupId,
1786                            parentFolderId, status, orderByComparator);
1787            }
1788    
1789            /**
1790            * Returns all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1791            *
1792            * @param groupId the group ID
1793            * @param parentFolderId the parent folder ID
1794            * @param status the status
1795            * @return the matching bookmarks folders that the user has permission to view
1796            */
1797            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
1798                    long groupId, long parentFolderId, int status) {
1799                    return getPersistence()
1800                                       .filterFindByG_P_NotS(groupId, parentFolderId, status);
1801            }
1802    
1803            /**
1804            * Returns a range of all the bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1805            *
1806            * <p>
1807            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1808            * </p>
1809            *
1810            * @param groupId the group ID
1811            * @param parentFolderId the parent folder ID
1812            * @param status the status
1813            * @param start the lower bound of the range of bookmarks folders
1814            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1815            * @return the range of matching bookmarks folders that the user has permission to view
1816            */
1817            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
1818                    long groupId, long parentFolderId, int status, int start, int end) {
1819                    return getPersistence()
1820                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
1821                            start, end);
1822            }
1823    
1824            /**
1825            * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1826            *
1827            * <p>
1828            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1829            * </p>
1830            *
1831            * @param groupId the group ID
1832            * @param parentFolderId the parent folder ID
1833            * @param status the status
1834            * @param start the lower bound of the range of bookmarks folders
1835            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1836            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1837            * @return the ordered range of matching bookmarks folders that the user has permission to view
1838            */
1839            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS(
1840                    long groupId, long parentFolderId, int status, int start, int end,
1841                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1842                    return getPersistence()
1843                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
1844                            start, end, orderByComparator);
1845            }
1846    
1847            /**
1848            * 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; and status &ne; &#63;.
1849            *
1850            * @param folderId the primary key of the current bookmarks folder
1851            * @param groupId the group ID
1852            * @param parentFolderId the parent folder ID
1853            * @param status the status
1854            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1855            * @return the previous, current, and next bookmarks folder
1856            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
1857            */
1858            public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_NotS_PrevAndNext(
1859                    long folderId, long groupId, long parentFolderId, int status,
1860                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1861                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1862                    return getPersistence()
1863                                       .filterFindByG_P_NotS_PrevAndNext(folderId, groupId,
1864                            parentFolderId, status, orderByComparator);
1865            }
1866    
1867            /**
1868            * Removes all the bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1869            *
1870            * @param groupId the group ID
1871            * @param parentFolderId the parent folder ID
1872            * @param status the status
1873            */
1874            public static void removeByG_P_NotS(long groupId, long parentFolderId,
1875                    int status) {
1876                    getPersistence().removeByG_P_NotS(groupId, parentFolderId, status);
1877            }
1878    
1879            /**
1880            * Returns the number of bookmarks folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1881            *
1882            * @param groupId the group ID
1883            * @param parentFolderId the parent folder ID
1884            * @param status the status
1885            * @return the number of matching bookmarks folders
1886            */
1887            public static int countByG_P_NotS(long groupId, long parentFolderId,
1888                    int status) {
1889                    return getPersistence().countByG_P_NotS(groupId, parentFolderId, status);
1890            }
1891    
1892            /**
1893            * Returns the number of bookmarks folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1894            *
1895            * @param groupId the group ID
1896            * @param parentFolderId the parent folder ID
1897            * @param status the status
1898            * @return the number of matching bookmarks folders that the user has permission to view
1899            */
1900            public static int filterCountByG_P_NotS(long groupId, long parentFolderId,
1901                    int status) {
1902                    return getPersistence()
1903                                       .filterCountByG_P_NotS(groupId, parentFolderId, status);
1904            }
1905    
1906            /**
1907            * Returns all the bookmarks folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1908            *
1909            * @param folderId the folder ID
1910            * @param companyId the company ID
1911            * @param parentFolderId the parent folder ID
1912            * @param status the status
1913            * @return the matching bookmarks folders
1914            */
1915            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByF_C_P_NotS(
1916                    long folderId, long companyId, long parentFolderId, int status) {
1917                    return getPersistence()
1918                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId, status);
1919            }
1920    
1921            /**
1922            * Returns a range of all the bookmarks folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1923            *
1924            * <p>
1925            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1926            * </p>
1927            *
1928            * @param folderId the folder ID
1929            * @param companyId the company ID
1930            * @param parentFolderId the parent folder ID
1931            * @param status the status
1932            * @param start the lower bound of the range of bookmarks folders
1933            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1934            * @return the range of matching bookmarks folders
1935            */
1936            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByF_C_P_NotS(
1937                    long folderId, long companyId, long parentFolderId, int status,
1938                    int start, int end) {
1939                    return getPersistence()
1940                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1941                            status, start, end);
1942            }
1943    
1944            /**
1945            * Returns an ordered range of all the bookmarks folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1946            *
1947            * <p>
1948            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1949            * </p>
1950            *
1951            * @param folderId the folder ID
1952            * @param companyId the company ID
1953            * @param parentFolderId the parent folder ID
1954            * @param status the status
1955            * @param start the lower bound of the range of bookmarks folders
1956            * @param end the upper bound of the range of bookmarks folders (not inclusive)
1957            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1958            * @return the ordered range of matching bookmarks folders
1959            */
1960            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByF_C_P_NotS(
1961                    long folderId, long companyId, long parentFolderId, int status,
1962                    int start, int end,
1963                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
1964                    return getPersistence()
1965                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1966                            status, start, end, orderByComparator);
1967            }
1968    
1969            /**
1970            * Returns the first bookmarks folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1971            *
1972            * @param folderId the folder ID
1973            * @param companyId the company ID
1974            * @param parentFolderId the parent folder ID
1975            * @param status the status
1976            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1977            * @return the first matching bookmarks folder
1978            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
1979            */
1980            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByF_C_P_NotS_First(
1981                    long folderId, long companyId, long parentFolderId, int status,
1982                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
1983                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
1984                    return getPersistence()
1985                                       .findByF_C_P_NotS_First(folderId, companyId, parentFolderId,
1986                            status, orderByComparator);
1987            }
1988    
1989            /**
1990            * Returns the first bookmarks folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1991            *
1992            * @param folderId the folder ID
1993            * @param companyId the company ID
1994            * @param parentFolderId the parent folder ID
1995            * @param status the status
1996            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1997            * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
1998            */
1999            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByF_C_P_NotS_First(
2000                    long folderId, long companyId, long parentFolderId, int status,
2001                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
2002                    return getPersistence()
2003                                       .fetchByF_C_P_NotS_First(folderId, companyId,
2004                            parentFolderId, status, orderByComparator);
2005            }
2006    
2007            /**
2008            * Returns the last bookmarks folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2009            *
2010            * @param folderId the folder ID
2011            * @param companyId the company ID
2012            * @param parentFolderId the parent folder ID
2013            * @param status the status
2014            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2015            * @return the last matching bookmarks folder
2016            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found
2017            */
2018            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByF_C_P_NotS_Last(
2019                    long folderId, long companyId, long parentFolderId, int status,
2020                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator)
2021                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
2022                    return getPersistence()
2023                                       .findByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
2024                            status, orderByComparator);
2025            }
2026    
2027            /**
2028            * Returns the last bookmarks folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2029            *
2030            * @param folderId the folder ID
2031            * @param companyId the company ID
2032            * @param parentFolderId the parent folder ID
2033            * @param status the status
2034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2035            * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found
2036            */
2037            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByF_C_P_NotS_Last(
2038                    long folderId, long companyId, long parentFolderId, int status,
2039                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
2040                    return getPersistence()
2041                                       .fetchByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
2042                            status, orderByComparator);
2043            }
2044    
2045            /**
2046            * Removes all the bookmarks folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
2047            *
2048            * @param folderId the folder ID
2049            * @param companyId the company ID
2050            * @param parentFolderId the parent folder ID
2051            * @param status the status
2052            */
2053            public static void removeByF_C_P_NotS(long folderId, long companyId,
2054                    long parentFolderId, int status) {
2055                    getPersistence()
2056                            .removeByF_C_P_NotS(folderId, companyId, parentFolderId, status);
2057            }
2058    
2059            /**
2060            * Returns the number of bookmarks folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2061            *
2062            * @param folderId the folder ID
2063            * @param companyId the company ID
2064            * @param parentFolderId the parent folder ID
2065            * @param status the status
2066            * @return the number of matching bookmarks folders
2067            */
2068            public static int countByF_C_P_NotS(long folderId, long companyId,
2069                    long parentFolderId, int status) {
2070                    return getPersistence()
2071                                       .countByF_C_P_NotS(folderId, companyId, parentFolderId,
2072                            status);
2073            }
2074    
2075            /**
2076            * Caches the bookmarks folder in the entity cache if it is enabled.
2077            *
2078            * @param bookmarksFolder the bookmarks folder
2079            */
2080            public static void cacheResult(
2081                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) {
2082                    getPersistence().cacheResult(bookmarksFolder);
2083            }
2084    
2085            /**
2086            * Caches the bookmarks folders in the entity cache if it is enabled.
2087            *
2088            * @param bookmarksFolders the bookmarks folders
2089            */
2090            public static void cacheResult(
2091                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) {
2092                    getPersistence().cacheResult(bookmarksFolders);
2093            }
2094    
2095            /**
2096            * Creates a new bookmarks folder with the primary key. Does not add the bookmarks folder to the database.
2097            *
2098            * @param folderId the primary key for the new bookmarks folder
2099            * @return the new bookmarks folder
2100            */
2101            public static com.liferay.portlet.bookmarks.model.BookmarksFolder create(
2102                    long folderId) {
2103                    return getPersistence().create(folderId);
2104            }
2105    
2106            /**
2107            * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners.
2108            *
2109            * @param folderId the primary key of the bookmarks folder
2110            * @return the bookmarks folder that was removed
2111            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
2112            */
2113            public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove(
2114                    long folderId)
2115                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
2116                    return getPersistence().remove(folderId);
2117            }
2118    
2119            public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl(
2120                    com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) {
2121                    return getPersistence().updateImpl(bookmarksFolder);
2122            }
2123    
2124            /**
2125            * Returns the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found.
2126            *
2127            * @param folderId the primary key of the bookmarks folder
2128            * @return the bookmarks folder
2129            * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found
2130            */
2131            public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey(
2132                    long folderId)
2133                    throws com.liferay.portlet.bookmarks.NoSuchFolderException {
2134                    return getPersistence().findByPrimaryKey(folderId);
2135            }
2136    
2137            /**
2138            * Returns the bookmarks folder with the primary key or returns <code>null</code> if it could not be found.
2139            *
2140            * @param folderId the primary key of the bookmarks folder
2141            * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found
2142            */
2143            public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey(
2144                    long folderId) {
2145                    return getPersistence().fetchByPrimaryKey(folderId);
2146            }
2147    
2148            public static java.util.Map<java.io.Serializable, com.liferay.portlet.bookmarks.model.BookmarksFolder> fetchByPrimaryKeys(
2149                    java.util.Set<java.io.Serializable> primaryKeys) {
2150                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2151            }
2152    
2153            /**
2154            * Returns all the bookmarks folders.
2155            *
2156            * @return the bookmarks folders
2157            */
2158            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() {
2159                    return getPersistence().findAll();
2160            }
2161    
2162            /**
2163            * Returns a range of all the bookmarks folders.
2164            *
2165            * <p>
2166            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2167            * </p>
2168            *
2169            * @param start the lower bound of the range of bookmarks folders
2170            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2171            * @return the range of bookmarks folders
2172            */
2173            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
2174                    int start, int end) {
2175                    return getPersistence().findAll(start, end);
2176            }
2177    
2178            /**
2179            * Returns an ordered range of all the bookmarks folders.
2180            *
2181            * <p>
2182            * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2183            * </p>
2184            *
2185            * @param start the lower bound of the range of bookmarks folders
2186            * @param end the upper bound of the range of bookmarks folders (not inclusive)
2187            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2188            * @return the ordered range of bookmarks folders
2189            */
2190            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll(
2191                    int start, int end,
2192                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.bookmarks.model.BookmarksFolder> orderByComparator) {
2193                    return getPersistence().findAll(start, end, orderByComparator);
2194            }
2195    
2196            /**
2197            * Removes all the bookmarks folders from the database.
2198            */
2199            public static void removeAll() {
2200                    getPersistence().removeAll();
2201            }
2202    
2203            /**
2204            * Returns the number of bookmarks folders.
2205            *
2206            * @return the number of bookmarks folders
2207            */
2208            public static int countAll() {
2209                    return getPersistence().countAll();
2210            }
2211    
2212            public static BookmarksFolderPersistence getPersistence() {
2213                    if (_persistence == null) {
2214                            _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName());
2215    
2216                            ReferenceRegistry.registerReference(BookmarksFolderUtil.class,
2217                                    "_persistence");
2218                    }
2219    
2220                    return _persistence;
2221            }
2222    
2223            /**
2224             * @deprecated As of 6.2.0
2225             */
2226            @Deprecated
2227            public void setPersistence(BookmarksFolderPersistence persistence) {
2228            }
2229    
2230            private static BookmarksFolderPersistence _persistence;
2231    }