001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.blogs.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.blogs.model.BlogsEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the blogs entry service. This utility wraps {@link BlogsEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see BlogsEntryPersistence
037     * @see BlogsEntryPersistenceImpl
038     * @generated
039     */
040    public class BlogsEntryUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(BlogsEntry blogsEntry) {
058                    getPersistence().clearCache(blogsEntry);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BlogsEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BlogsEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BlogsEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
099             */
100            public static BlogsEntry remove(BlogsEntry blogsEntry)
101                    throws SystemException {
102                    return getPersistence().remove(blogsEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
107             */
108            public static BlogsEntry update(BlogsEntry blogsEntry, boolean merge)
109                    throws SystemException {
110                    return getPersistence().update(blogsEntry, merge);
111            }
112    
113            /**
114             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
115             */
116            public static BlogsEntry update(BlogsEntry blogsEntry, boolean merge,
117                    ServiceContext serviceContext) throws SystemException {
118                    return getPersistence().update(blogsEntry, merge, serviceContext);
119            }
120    
121            /**
122            * Caches the blogs entry in the entity cache if it is enabled.
123            *
124            * @param blogsEntry the blogs entry to cache
125            */
126            public static void cacheResult(
127                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry) {
128                    getPersistence().cacheResult(blogsEntry);
129            }
130    
131            /**
132            * Caches the blogs entries in the entity cache if it is enabled.
133            *
134            * @param blogsEntries the blogs entries to cache
135            */
136            public static void cacheResult(
137                    java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> blogsEntries) {
138                    getPersistence().cacheResult(blogsEntries);
139            }
140    
141            /**
142            * Creates a new blogs entry with the primary key. Does not add the blogs entry to the database.
143            *
144            * @param entryId the primary key for the new blogs entry
145            * @return the new blogs entry
146            */
147            public static com.liferay.portlet.blogs.model.BlogsEntry create(
148                    long entryId) {
149                    return getPersistence().create(entryId);
150            }
151    
152            /**
153            * Removes the blogs entry with the primary key from the database. Also notifies the appropriate model listeners.
154            *
155            * @param entryId the primary key of the blogs entry to remove
156            * @return the blogs entry that was removed
157            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
158            * @throws SystemException if a system exception occurred
159            */
160            public static com.liferay.portlet.blogs.model.BlogsEntry remove(
161                    long entryId)
162                    throws com.liferay.portal.kernel.exception.SystemException,
163                            com.liferay.portlet.blogs.NoSuchEntryException {
164                    return getPersistence().remove(entryId);
165            }
166    
167            public static com.liferay.portlet.blogs.model.BlogsEntry updateImpl(
168                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry, boolean merge)
169                    throws com.liferay.portal.kernel.exception.SystemException {
170                    return getPersistence().updateImpl(blogsEntry, merge);
171            }
172    
173            /**
174            * Finds the blogs entry with the primary key or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
175            *
176            * @param entryId the primary key of the blogs entry to find
177            * @return the blogs entry
178            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
179            * @throws SystemException if a system exception occurred
180            */
181            public static com.liferay.portlet.blogs.model.BlogsEntry findByPrimaryKey(
182                    long entryId)
183                    throws com.liferay.portal.kernel.exception.SystemException,
184                            com.liferay.portlet.blogs.NoSuchEntryException {
185                    return getPersistence().findByPrimaryKey(entryId);
186            }
187    
188            /**
189            * Finds the blogs entry with the primary key or returns <code>null</code> if it could not be found.
190            *
191            * @param entryId the primary key of the blogs entry to find
192            * @return the blogs entry, or <code>null</code> if a blogs entry with the primary key could not be found
193            * @throws SystemException if a system exception occurred
194            */
195            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByPrimaryKey(
196                    long entryId)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence().fetchByPrimaryKey(entryId);
199            }
200    
201            /**
202            * Finds all the blogs entries where uuid = &#63;.
203            *
204            * @param uuid the uuid to search with
205            * @return the matching blogs entries
206            * @throws SystemException if a system exception occurred
207            */
208            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
209                    java.lang.String uuid)
210                    throws com.liferay.portal.kernel.exception.SystemException {
211                    return getPersistence().findByUuid(uuid);
212            }
213    
214            /**
215            * Finds a range of all the blogs entries where uuid = &#63;.
216            *
217            * <p>
218            * 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.
219            * </p>
220            *
221            * @param uuid the uuid to search with
222            * @param start the lower bound of the range of blogs entries to return
223            * @param end the upper bound of the range of blogs entries to return (not inclusive)
224            * @return the range of matching blogs entries
225            * @throws SystemException if a system exception occurred
226            */
227            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
228                    java.lang.String uuid, int start, int end)
229                    throws com.liferay.portal.kernel.exception.SystemException {
230                    return getPersistence().findByUuid(uuid, start, end);
231            }
232    
233            /**
234            * Finds an ordered range of all the blogs entries where uuid = &#63;.
235            *
236            * <p>
237            * 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.
238            * </p>
239            *
240            * @param uuid the uuid to search with
241            * @param start the lower bound of the range of blogs entries to return
242            * @param end the upper bound of the range of blogs entries to return (not inclusive)
243            * @param orderByComparator the comparator to order the results by
244            * @return the ordered range of matching blogs entries
245            * @throws SystemException if a system exception occurred
246            */
247            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
248                    java.lang.String uuid, int start, int end,
249                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
250                    throws com.liferay.portal.kernel.exception.SystemException {
251                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
252            }
253    
254            /**
255            * Finds the first blogs entry in the ordered set where uuid = &#63;.
256            *
257            * <p>
258            * 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.
259            * </p>
260            *
261            * @param uuid the uuid to search with
262            * @param orderByComparator the comparator to order the set by
263            * @return the first matching blogs entry
264            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
265            * @throws SystemException if a system exception occurred
266            */
267            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_First(
268                    java.lang.String uuid,
269                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
270                    throws com.liferay.portal.kernel.exception.SystemException,
271                            com.liferay.portlet.blogs.NoSuchEntryException {
272                    return getPersistence().findByUuid_First(uuid, orderByComparator);
273            }
274    
275            /**
276            * Finds the last blogs entry in the ordered set where uuid = &#63;.
277            *
278            * <p>
279            * 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.
280            * </p>
281            *
282            * @param uuid the uuid to search with
283            * @param orderByComparator the comparator to order the set by
284            * @return the last matching blogs entry
285            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
286            * @throws SystemException if a system exception occurred
287            */
288            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_Last(
289                    java.lang.String uuid,
290                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
291                    throws com.liferay.portal.kernel.exception.SystemException,
292                            com.liferay.portlet.blogs.NoSuchEntryException {
293                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
294            }
295    
296            /**
297            * Finds the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63;.
298            *
299            * <p>
300            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
301            * </p>
302            *
303            * @param entryId the primary key of the current blogs entry
304            * @param uuid the uuid to search with
305            * @param orderByComparator the comparator to order the set by
306            * @return the previous, current, and next blogs entry
307            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
308            * @throws SystemException if a system exception occurred
309            */
310            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_PrevAndNext(
311                    long entryId, java.lang.String uuid,
312                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
313                    throws com.liferay.portal.kernel.exception.SystemException,
314                            com.liferay.portlet.blogs.NoSuchEntryException {
315                    return getPersistence()
316                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
317            }
318    
319            /**
320            * Finds the blogs entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
321            *
322            * @param uuid the uuid to search with
323            * @param groupId the group ID to search with
324            * @return the matching blogs entry
325            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
326            * @throws SystemException if a system exception occurred
327            */
328            public static com.liferay.portlet.blogs.model.BlogsEntry findByUUID_G(
329                    java.lang.String uuid, long groupId)
330                    throws com.liferay.portal.kernel.exception.SystemException,
331                            com.liferay.portlet.blogs.NoSuchEntryException {
332                    return getPersistence().findByUUID_G(uuid, groupId);
333            }
334    
335            /**
336            * Finds the blogs entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
337            *
338            * @param uuid the uuid to search with
339            * @param groupId the group ID to search with
340            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
341            * @throws SystemException if a system exception occurred
342            */
343            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
344                    java.lang.String uuid, long groupId)
345                    throws com.liferay.portal.kernel.exception.SystemException {
346                    return getPersistence().fetchByUUID_G(uuid, groupId);
347            }
348    
349            /**
350            * Finds the blogs entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
351            *
352            * @param uuid the uuid to search with
353            * @param groupId the group ID to search with
354            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
355            * @throws SystemException if a system exception occurred
356            */
357            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
358                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
359                    throws com.liferay.portal.kernel.exception.SystemException {
360                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
361            }
362    
363            /**
364            * Finds all the blogs entries where groupId = &#63;.
365            *
366            * @param groupId the group ID to search with
367            * @return the matching blogs entries
368            * @throws SystemException if a system exception occurred
369            */
370            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
371                    long groupId)
372                    throws com.liferay.portal.kernel.exception.SystemException {
373                    return getPersistence().findByGroupId(groupId);
374            }
375    
376            /**
377            * Finds a range of all the blogs entries where groupId = &#63;.
378            *
379            * <p>
380            * 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.
381            * </p>
382            *
383            * @param groupId the group ID to search with
384            * @param start the lower bound of the range of blogs entries to return
385            * @param end the upper bound of the range of blogs entries to return (not inclusive)
386            * @return the range of matching blogs entries
387            * @throws SystemException if a system exception occurred
388            */
389            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
390                    long groupId, int start, int end)
391                    throws com.liferay.portal.kernel.exception.SystemException {
392                    return getPersistence().findByGroupId(groupId, start, end);
393            }
394    
395            /**
396            * Finds an ordered range of all the blogs entries where groupId = &#63;.
397            *
398            * <p>
399            * 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.
400            * </p>
401            *
402            * @param groupId the group ID to search with
403            * @param start the lower bound of the range of blogs entries to return
404            * @param end the upper bound of the range of blogs entries to return (not inclusive)
405            * @param orderByComparator the comparator to order the results by
406            * @return the ordered range of matching blogs entries
407            * @throws SystemException if a system exception occurred
408            */
409            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
410                    long groupId, int start, int end,
411                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
412                    throws com.liferay.portal.kernel.exception.SystemException {
413                    return getPersistence()
414                                       .findByGroupId(groupId, start, end, orderByComparator);
415            }
416    
417            /**
418            * Finds the first blogs entry in the ordered set where groupId = &#63;.
419            *
420            * <p>
421            * 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.
422            * </p>
423            *
424            * @param groupId the group ID to search with
425            * @param orderByComparator the comparator to order the set by
426            * @return the first matching blogs entry
427            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_First(
431                    long groupId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException,
434                            com.liferay.portlet.blogs.NoSuchEntryException {
435                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
436            }
437    
438            /**
439            * Finds the last blogs entry in the ordered set where groupId = &#63;.
440            *
441            * <p>
442            * 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.
443            * </p>
444            *
445            * @param groupId the group ID to search with
446            * @param orderByComparator the comparator to order the set by
447            * @return the last matching blogs entry
448            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
449            * @throws SystemException if a system exception occurred
450            */
451            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_Last(
452                    long groupId,
453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.blogs.NoSuchEntryException {
456                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
457            }
458    
459            /**
460            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63;.
461            *
462            * <p>
463            * 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.
464            * </p>
465            *
466            * @param entryId the primary key of the current blogs entry
467            * @param groupId the group ID to search with
468            * @param orderByComparator the comparator to order the set by
469            * @return the previous, current, and next blogs entry
470            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
471            * @throws SystemException if a system exception occurred
472            */
473            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByGroupId_PrevAndNext(
474                    long entryId, long groupId,
475                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
476                    throws com.liferay.portal.kernel.exception.SystemException,
477                            com.liferay.portlet.blogs.NoSuchEntryException {
478                    return getPersistence()
479                                       .findByGroupId_PrevAndNext(entryId, groupId,
480                            orderByComparator);
481            }
482    
483            /**
484            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63;.
485            *
486            * @param groupId the group ID to search with
487            * @return the matching blogs entries that the user has permission to view
488            * @throws SystemException if a system exception occurred
489            */
490            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
491                    long groupId)
492                    throws com.liferay.portal.kernel.exception.SystemException {
493                    return getPersistence().filterFindByGroupId(groupId);
494            }
495    
496            /**
497            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63;.
498            *
499            * <p>
500            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
501            * </p>
502            *
503            * @param groupId the group ID to search with
504            * @param start the lower bound of the range of blogs entries to return
505            * @param end the upper bound of the range of blogs entries to return (not inclusive)
506            * @return the range of matching blogs entries that the user has permission to view
507            * @throws SystemException if a system exception occurred
508            */
509            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
510                    long groupId, int start, int end)
511                    throws com.liferay.portal.kernel.exception.SystemException {
512                    return getPersistence().filterFindByGroupId(groupId, start, end);
513            }
514    
515            /**
516            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63;.
517            *
518            * <p>
519            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
520            * </p>
521            *
522            * @param groupId the group ID to search with
523            * @param start the lower bound of the range of blogs entries to return
524            * @param end the upper bound of the range of blogs entries to return (not inclusive)
525            * @param orderByComparator the comparator to order the results by
526            * @return the ordered range of matching blogs entries that the user has permission to view
527            * @throws SystemException if a system exception occurred
528            */
529            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
530                    long groupId, int start, int end,
531                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence()
534                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
535            }
536    
537            /**
538            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63;.
539            *
540            * <p>
541            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
542            * </p>
543            *
544            * @param entryId the primary key of the current blogs entry
545            * @param groupId the group ID to search with
546            * @param orderByComparator the comparator to order the set by
547            * @return the previous, current, and next blogs entry
548            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
549            * @throws SystemException if a system exception occurred
550            */
551            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByGroupId_PrevAndNext(
552                    long entryId, long groupId,
553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
554                    throws com.liferay.portal.kernel.exception.SystemException,
555                            com.liferay.portlet.blogs.NoSuchEntryException {
556                    return getPersistence()
557                                       .filterFindByGroupId_PrevAndNext(entryId, groupId,
558                            orderByComparator);
559            }
560    
561            /**
562            * Finds all the blogs entries where companyId = &#63;.
563            *
564            * @param companyId the company ID to search with
565            * @return the matching blogs entries
566            * @throws SystemException if a system exception occurred
567            */
568            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
569                    long companyId)
570                    throws com.liferay.portal.kernel.exception.SystemException {
571                    return getPersistence().findByCompanyId(companyId);
572            }
573    
574            /**
575            * Finds a range of all the blogs entries where companyId = &#63;.
576            *
577            * <p>
578            * 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.
579            * </p>
580            *
581            * @param companyId the company ID to search with
582            * @param start the lower bound of the range of blogs entries to return
583            * @param end the upper bound of the range of blogs entries to return (not inclusive)
584            * @return the range of matching blogs entries
585            * @throws SystemException if a system exception occurred
586            */
587            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
588                    long companyId, int start, int end)
589                    throws com.liferay.portal.kernel.exception.SystemException {
590                    return getPersistence().findByCompanyId(companyId, start, end);
591            }
592    
593            /**
594            * Finds an ordered range of all the blogs entries where companyId = &#63;.
595            *
596            * <p>
597            * 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.
598            * </p>
599            *
600            * @param companyId the company ID to search with
601            * @param start the lower bound of the range of blogs entries to return
602            * @param end the upper bound of the range of blogs entries to return (not inclusive)
603            * @param orderByComparator the comparator to order the results by
604            * @return the ordered range of matching blogs entries
605            * @throws SystemException if a system exception occurred
606            */
607            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
608                    long companyId, int start, int end,
609                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
610                    throws com.liferay.portal.kernel.exception.SystemException {
611                    return getPersistence()
612                                       .findByCompanyId(companyId, start, end, orderByComparator);
613            }
614    
615            /**
616            * Finds the first blogs entry in the ordered set where companyId = &#63;.
617            *
618            * <p>
619            * 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.
620            * </p>
621            *
622            * @param companyId the company ID to search with
623            * @param orderByComparator the comparator to order the set by
624            * @return the first matching blogs entry
625            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
626            * @throws SystemException if a system exception occurred
627            */
628            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_First(
629                    long companyId,
630                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
631                    throws com.liferay.portal.kernel.exception.SystemException,
632                            com.liferay.portlet.blogs.NoSuchEntryException {
633                    return getPersistence()
634                                       .findByCompanyId_First(companyId, orderByComparator);
635            }
636    
637            /**
638            * Finds the last blogs entry in the ordered set where companyId = &#63;.
639            *
640            * <p>
641            * 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.
642            * </p>
643            *
644            * @param companyId the company ID to search with
645            * @param orderByComparator the comparator to order the set by
646            * @return the last matching blogs entry
647            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
648            * @throws SystemException if a system exception occurred
649            */
650            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_Last(
651                    long companyId,
652                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
653                    throws com.liferay.portal.kernel.exception.SystemException,
654                            com.liferay.portlet.blogs.NoSuchEntryException {
655                    return getPersistence()
656                                       .findByCompanyId_Last(companyId, orderByComparator);
657            }
658    
659            /**
660            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63;.
661            *
662            * <p>
663            * 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.
664            * </p>
665            *
666            * @param entryId the primary key of the current blogs entry
667            * @param companyId the company ID to search with
668            * @param orderByComparator the comparator to order the set by
669            * @return the previous, current, and next blogs entry
670            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
671            * @throws SystemException if a system exception occurred
672            */
673            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByCompanyId_PrevAndNext(
674                    long entryId, long companyId,
675                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
676                    throws com.liferay.portal.kernel.exception.SystemException,
677                            com.liferay.portlet.blogs.NoSuchEntryException {
678                    return getPersistence()
679                                       .findByCompanyId_PrevAndNext(entryId, companyId,
680                            orderByComparator);
681            }
682    
683            /**
684            * Finds all the blogs entries where companyId = &#63; and userId = &#63;.
685            *
686            * @param companyId the company ID to search with
687            * @param userId the user ID to search with
688            * @return the matching blogs entries
689            * @throws SystemException if a system exception occurred
690            */
691            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
692                    long companyId, long userId)
693                    throws com.liferay.portal.kernel.exception.SystemException {
694                    return getPersistence().findByC_U(companyId, userId);
695            }
696    
697            /**
698            * Finds a range of all the blogs entries where companyId = &#63; and userId = &#63;.
699            *
700            * <p>
701            * 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.
702            * </p>
703            *
704            * @param companyId the company ID to search with
705            * @param userId the user ID to search with
706            * @param start the lower bound of the range of blogs entries to return
707            * @param end the upper bound of the range of blogs entries to return (not inclusive)
708            * @return the range of matching blogs entries
709            * @throws SystemException if a system exception occurred
710            */
711            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
712                    long companyId, long userId, int start, int end)
713                    throws com.liferay.portal.kernel.exception.SystemException {
714                    return getPersistence().findByC_U(companyId, userId, start, end);
715            }
716    
717            /**
718            * Finds an ordered range of all the blogs entries where companyId = &#63; and userId = &#63;.
719            *
720            * <p>
721            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
722            * </p>
723            *
724            * @param companyId the company ID to search with
725            * @param userId the user ID to search with
726            * @param start the lower bound of the range of blogs entries to return
727            * @param end the upper bound of the range of blogs entries to return (not inclusive)
728            * @param orderByComparator the comparator to order the results by
729            * @return the ordered range of matching blogs entries
730            * @throws SystemException if a system exception occurred
731            */
732            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
733                    long companyId, long userId, int start, int end,
734                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
735                    throws com.liferay.portal.kernel.exception.SystemException {
736                    return getPersistence()
737                                       .findByC_U(companyId, userId, start, end, orderByComparator);
738            }
739    
740            /**
741            * Finds the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
742            *
743            * <p>
744            * 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.
745            * </p>
746            *
747            * @param companyId the company ID to search with
748            * @param userId the user ID to search with
749            * @param orderByComparator the comparator to order the set by
750            * @return the first matching blogs entry
751            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_First(
755                    long companyId, long userId,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.blogs.NoSuchEntryException {
759                    return getPersistence()
760                                       .findByC_U_First(companyId, userId, orderByComparator);
761            }
762    
763            /**
764            * Finds the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
765            *
766            * <p>
767            * 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.
768            * </p>
769            *
770            * @param companyId the company ID to search with
771            * @param userId the user ID to search with
772            * @param orderByComparator the comparator to order the set by
773            * @return the last matching blogs entry
774            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
775            * @throws SystemException if a system exception occurred
776            */
777            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_Last(
778                    long companyId, long userId,
779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
780                    throws com.liferay.portal.kernel.exception.SystemException,
781                            com.liferay.portlet.blogs.NoSuchEntryException {
782                    return getPersistence()
783                                       .findByC_U_Last(companyId, userId, orderByComparator);
784            }
785    
786            /**
787            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
788            *
789            * <p>
790            * 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.
791            * </p>
792            *
793            * @param entryId the primary key of the current blogs entry
794            * @param companyId the company ID to search with
795            * @param userId the user ID to search with
796            * @param orderByComparator the comparator to order the set by
797            * @return the previous, current, and next blogs entry
798            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
799            * @throws SystemException if a system exception occurred
800            */
801            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_PrevAndNext(
802                    long entryId, long companyId, long userId,
803                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
804                    throws com.liferay.portal.kernel.exception.SystemException,
805                            com.liferay.portlet.blogs.NoSuchEntryException {
806                    return getPersistence()
807                                       .findByC_U_PrevAndNext(entryId, companyId, userId,
808                            orderByComparator);
809            }
810    
811            /**
812            * Finds all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
813            *
814            * @param companyId the company ID to search with
815            * @param displayDate the display date to search with
816            * @return the matching blogs entries
817            * @throws SystemException if a system exception occurred
818            */
819            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
820                    long companyId, java.util.Date displayDate)
821                    throws com.liferay.portal.kernel.exception.SystemException {
822                    return getPersistence().findByC_LtD(companyId, displayDate);
823            }
824    
825            /**
826            * Finds a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
827            *
828            * <p>
829            * 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.
830            * </p>
831            *
832            * @param companyId the company ID to search with
833            * @param displayDate the display date to search with
834            * @param start the lower bound of the range of blogs entries to return
835            * @param end the upper bound of the range of blogs entries to return (not inclusive)
836            * @return the range of matching blogs entries
837            * @throws SystemException if a system exception occurred
838            */
839            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
840                    long companyId, java.util.Date displayDate, int start, int end)
841                    throws com.liferay.portal.kernel.exception.SystemException {
842                    return getPersistence().findByC_LtD(companyId, displayDate, start, end);
843            }
844    
845            /**
846            * Finds an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
847            *
848            * <p>
849            * 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.
850            * </p>
851            *
852            * @param companyId the company ID to search with
853            * @param displayDate the display date to search with
854            * @param start the lower bound of the range of blogs entries to return
855            * @param end the upper bound of the range of blogs entries to return (not inclusive)
856            * @param orderByComparator the comparator to order the results by
857            * @return the ordered range of matching blogs entries
858            * @throws SystemException if a system exception occurred
859            */
860            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
861                    long companyId, java.util.Date displayDate, int start, int end,
862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
863                    throws com.liferay.portal.kernel.exception.SystemException {
864                    return getPersistence()
865                                       .findByC_LtD(companyId, displayDate, start, end,
866                            orderByComparator);
867            }
868    
869            /**
870            * Finds the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
871            *
872            * <p>
873            * 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.
874            * </p>
875            *
876            * @param companyId the company ID to search with
877            * @param displayDate the display date to search with
878            * @param orderByComparator the comparator to order the set by
879            * @return the first matching blogs entry
880            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
881            * @throws SystemException if a system exception occurred
882            */
883            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_First(
884                    long companyId, java.util.Date displayDate,
885                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
886                    throws com.liferay.portal.kernel.exception.SystemException,
887                            com.liferay.portlet.blogs.NoSuchEntryException {
888                    return getPersistence()
889                                       .findByC_LtD_First(companyId, displayDate, orderByComparator);
890            }
891    
892            /**
893            * Finds the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
894            *
895            * <p>
896            * 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.
897            * </p>
898            *
899            * @param companyId the company ID to search with
900            * @param displayDate the display date to search with
901            * @param orderByComparator the comparator to order the set by
902            * @return the last matching blogs entry
903            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
904            * @throws SystemException if a system exception occurred
905            */
906            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_Last(
907                    long companyId, java.util.Date displayDate,
908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
909                    throws com.liferay.portal.kernel.exception.SystemException,
910                            com.liferay.portlet.blogs.NoSuchEntryException {
911                    return getPersistence()
912                                       .findByC_LtD_Last(companyId, displayDate, orderByComparator);
913            }
914    
915            /**
916            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
917            *
918            * <p>
919            * 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.
920            * </p>
921            *
922            * @param entryId the primary key of the current blogs entry
923            * @param companyId the company ID to search with
924            * @param displayDate the display date to search with
925            * @param orderByComparator the comparator to order the set by
926            * @return the previous, current, and next blogs entry
927            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
928            * @throws SystemException if a system exception occurred
929            */
930            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_PrevAndNext(
931                    long entryId, long companyId, java.util.Date displayDate,
932                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
933                    throws com.liferay.portal.kernel.exception.SystemException,
934                            com.liferay.portlet.blogs.NoSuchEntryException {
935                    return getPersistence()
936                                       .findByC_LtD_PrevAndNext(entryId, companyId, displayDate,
937                            orderByComparator);
938            }
939    
940            /**
941            * Finds all the blogs entries where companyId = &#63; and status = &#63;.
942            *
943            * @param companyId the company ID to search with
944            * @param status the status to search with
945            * @return the matching blogs entries
946            * @throws SystemException if a system exception occurred
947            */
948            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
949                    long companyId, int status)
950                    throws com.liferay.portal.kernel.exception.SystemException {
951                    return getPersistence().findByC_S(companyId, status);
952            }
953    
954            /**
955            * Finds a range of all the blogs entries where companyId = &#63; and status = &#63;.
956            *
957            * <p>
958            * 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.
959            * </p>
960            *
961            * @param companyId the company ID to search with
962            * @param status the status to search with
963            * @param start the lower bound of the range of blogs entries to return
964            * @param end the upper bound of the range of blogs entries to return (not inclusive)
965            * @return the range of matching blogs entries
966            * @throws SystemException if a system exception occurred
967            */
968            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
969                    long companyId, int status, int start, int end)
970                    throws com.liferay.portal.kernel.exception.SystemException {
971                    return getPersistence().findByC_S(companyId, status, start, end);
972            }
973    
974            /**
975            * Finds an ordered range of all the blogs entries where companyId = &#63; and status = &#63;.
976            *
977            * <p>
978            * 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.
979            * </p>
980            *
981            * @param companyId the company ID to search with
982            * @param status the status to search with
983            * @param start the lower bound of the range of blogs entries to return
984            * @param end the upper bound of the range of blogs entries to return (not inclusive)
985            * @param orderByComparator the comparator to order the results by
986            * @return the ordered range of matching blogs entries
987            * @throws SystemException if a system exception occurred
988            */
989            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
990                    long companyId, int status, int start, int end,
991                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
992                    throws com.liferay.portal.kernel.exception.SystemException {
993                    return getPersistence()
994                                       .findByC_S(companyId, status, start, end, orderByComparator);
995            }
996    
997            /**
998            * Finds the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
999            *
1000            * <p>
1001            * 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.
1002            * </p>
1003            *
1004            * @param companyId the company ID to search with
1005            * @param status the status to search with
1006            * @param orderByComparator the comparator to order the set by
1007            * @return the first matching blogs entry
1008            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1009            * @throws SystemException if a system exception occurred
1010            */
1011            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_First(
1012                    long companyId, int status,
1013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1014                    throws com.liferay.portal.kernel.exception.SystemException,
1015                            com.liferay.portlet.blogs.NoSuchEntryException {
1016                    return getPersistence()
1017                                       .findByC_S_First(companyId, status, orderByComparator);
1018            }
1019    
1020            /**
1021            * Finds the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1022            *
1023            * <p>
1024            * 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.
1025            * </p>
1026            *
1027            * @param companyId the company ID to search with
1028            * @param status the status to search with
1029            * @param orderByComparator the comparator to order the set by
1030            * @return the last matching blogs entry
1031            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1032            * @throws SystemException if a system exception occurred
1033            */
1034            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_Last(
1035                    long companyId, int status,
1036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1037                    throws com.liferay.portal.kernel.exception.SystemException,
1038                            com.liferay.portlet.blogs.NoSuchEntryException {
1039                    return getPersistence()
1040                                       .findByC_S_Last(companyId, status, orderByComparator);
1041            }
1042    
1043            /**
1044            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1045            *
1046            * <p>
1047            * 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.
1048            * </p>
1049            *
1050            * @param entryId the primary key of the current blogs entry
1051            * @param companyId the company ID to search with
1052            * @param status the status to search with
1053            * @param orderByComparator the comparator to order the set by
1054            * @return the previous, current, and next blogs entry
1055            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1056            * @throws SystemException if a system exception occurred
1057            */
1058            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_S_PrevAndNext(
1059                    long entryId, long companyId, int status,
1060                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1061                    throws com.liferay.portal.kernel.exception.SystemException,
1062                            com.liferay.portlet.blogs.NoSuchEntryException {
1063                    return getPersistence()
1064                                       .findByC_S_PrevAndNext(entryId, companyId, status,
1065                            orderByComparator);
1066            }
1067    
1068            /**
1069            * Finds the blogs entry where groupId = &#63; and urlTitle = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
1070            *
1071            * @param groupId the group ID to search with
1072            * @param urlTitle the url title to search with
1073            * @return the matching blogs entry
1074            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1075            * @throws SystemException if a system exception occurred
1076            */
1077            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_UT(
1078                    long groupId, java.lang.String urlTitle)
1079                    throws com.liferay.portal.kernel.exception.SystemException,
1080                            com.liferay.portlet.blogs.NoSuchEntryException {
1081                    return getPersistence().findByG_UT(groupId, urlTitle);
1082            }
1083    
1084            /**
1085            * Finds the blogs entry where groupId = &#63; and urlTitle = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1086            *
1087            * @param groupId the group ID to search with
1088            * @param urlTitle the url title to search with
1089            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1090            * @throws SystemException if a system exception occurred
1091            */
1092            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1093                    long groupId, java.lang.String urlTitle)
1094                    throws com.liferay.portal.kernel.exception.SystemException {
1095                    return getPersistence().fetchByG_UT(groupId, urlTitle);
1096            }
1097    
1098            /**
1099            * Finds the blogs entry where groupId = &#63; and urlTitle = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1100            *
1101            * @param groupId the group ID to search with
1102            * @param urlTitle the url title to search with
1103            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1104            * @throws SystemException if a system exception occurred
1105            */
1106            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1107                    long groupId, java.lang.String urlTitle, boolean retrieveFromCache)
1108                    throws com.liferay.portal.kernel.exception.SystemException {
1109                    return getPersistence().fetchByG_UT(groupId, urlTitle, retrieveFromCache);
1110            }
1111    
1112            /**
1113            * Finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1114            *
1115            * @param groupId the group ID to search with
1116            * @param displayDate the display date to search with
1117            * @return the matching blogs entries
1118            * @throws SystemException if a system exception occurred
1119            */
1120            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1121                    long groupId, java.util.Date displayDate)
1122                    throws com.liferay.portal.kernel.exception.SystemException {
1123                    return getPersistence().findByG_LtD(groupId, displayDate);
1124            }
1125    
1126            /**
1127            * Finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1128            *
1129            * <p>
1130            * 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.
1131            * </p>
1132            *
1133            * @param groupId the group ID to search with
1134            * @param displayDate the display date to search with
1135            * @param start the lower bound of the range of blogs entries to return
1136            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1137            * @return the range of matching blogs entries
1138            * @throws SystemException if a system exception occurred
1139            */
1140            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1141                    long groupId, java.util.Date displayDate, int start, int end)
1142                    throws com.liferay.portal.kernel.exception.SystemException {
1143                    return getPersistence().findByG_LtD(groupId, displayDate, start, end);
1144            }
1145    
1146            /**
1147            * Finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1148            *
1149            * <p>
1150            * 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.
1151            * </p>
1152            *
1153            * @param groupId the group ID to search with
1154            * @param displayDate the display date to search with
1155            * @param start the lower bound of the range of blogs entries to return
1156            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1157            * @param orderByComparator the comparator to order the results by
1158            * @return the ordered range of matching blogs entries
1159            * @throws SystemException if a system exception occurred
1160            */
1161            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1162                    long groupId, java.util.Date displayDate, int start, int end,
1163                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1164                    throws com.liferay.portal.kernel.exception.SystemException {
1165                    return getPersistence()
1166                                       .findByG_LtD(groupId, displayDate, start, end,
1167                            orderByComparator);
1168            }
1169    
1170            /**
1171            * Finds the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1172            *
1173            * <p>
1174            * 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.
1175            * </p>
1176            *
1177            * @param groupId the group ID to search with
1178            * @param displayDate the display date to search with
1179            * @param orderByComparator the comparator to order the set by
1180            * @return the first matching blogs entry
1181            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_First(
1185                    long groupId, java.util.Date displayDate,
1186                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1187                    throws com.liferay.portal.kernel.exception.SystemException,
1188                            com.liferay.portlet.blogs.NoSuchEntryException {
1189                    return getPersistence()
1190                                       .findByG_LtD_First(groupId, displayDate, orderByComparator);
1191            }
1192    
1193            /**
1194            * Finds the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1195            *
1196            * <p>
1197            * 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.
1198            * </p>
1199            *
1200            * @param groupId the group ID to search with
1201            * @param displayDate the display date to search with
1202            * @param orderByComparator the comparator to order the set by
1203            * @return the last matching blogs entry
1204            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1205            * @throws SystemException if a system exception occurred
1206            */
1207            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_Last(
1208                    long groupId, java.util.Date displayDate,
1209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1210                    throws com.liferay.portal.kernel.exception.SystemException,
1211                            com.liferay.portlet.blogs.NoSuchEntryException {
1212                    return getPersistence()
1213                                       .findByG_LtD_Last(groupId, displayDate, orderByComparator);
1214            }
1215    
1216            /**
1217            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1218            *
1219            * <p>
1220            * 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.
1221            * </p>
1222            *
1223            * @param entryId the primary key of the current blogs entry
1224            * @param groupId the group ID to search with
1225            * @param displayDate the display date to search with
1226            * @param orderByComparator the comparator to order the set by
1227            * @return the previous, current, and next blogs entry
1228            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1229            * @throws SystemException if a system exception occurred
1230            */
1231            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_PrevAndNext(
1232                    long entryId, long groupId, java.util.Date displayDate,
1233                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1234                    throws com.liferay.portal.kernel.exception.SystemException,
1235                            com.liferay.portlet.blogs.NoSuchEntryException {
1236                    return getPersistence()
1237                                       .findByG_LtD_PrevAndNext(entryId, groupId, displayDate,
1238                            orderByComparator);
1239            }
1240    
1241            /**
1242            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1243            *
1244            * @param groupId the group ID to search with
1245            * @param displayDate the display date to search with
1246            * @return the matching blogs entries that the user has permission to view
1247            * @throws SystemException if a system exception occurred
1248            */
1249            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1250                    long groupId, java.util.Date displayDate)
1251                    throws com.liferay.portal.kernel.exception.SystemException {
1252                    return getPersistence().filterFindByG_LtD(groupId, displayDate);
1253            }
1254    
1255            /**
1256            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1257            *
1258            * <p>
1259            * 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.
1260            * </p>
1261            *
1262            * @param groupId the group ID to search with
1263            * @param displayDate the display date to search with
1264            * @param start the lower bound of the range of blogs entries to return
1265            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1266            * @return the range of matching blogs entries that the user has permission to view
1267            * @throws SystemException if a system exception occurred
1268            */
1269            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1270                    long groupId, java.util.Date displayDate, int start, int end)
1271                    throws com.liferay.portal.kernel.exception.SystemException {
1272                    return getPersistence()
1273                                       .filterFindByG_LtD(groupId, displayDate, start, end);
1274            }
1275    
1276            /**
1277            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1278            *
1279            * <p>
1280            * 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.
1281            * </p>
1282            *
1283            * @param groupId the group ID to search with
1284            * @param displayDate the display date to search with
1285            * @param start the lower bound of the range of blogs entries to return
1286            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1287            * @param orderByComparator the comparator to order the results by
1288            * @return the ordered range of matching blogs entries that the user has permission to view
1289            * @throws SystemException if a system exception occurred
1290            */
1291            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1292                    long groupId, java.util.Date displayDate, int start, int end,
1293                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1294                    throws com.liferay.portal.kernel.exception.SystemException {
1295                    return getPersistence()
1296                                       .filterFindByG_LtD(groupId, displayDate, start, end,
1297                            orderByComparator);
1298            }
1299    
1300            /**
1301            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1302            *
1303            * <p>
1304            * 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.
1305            * </p>
1306            *
1307            * @param entryId the primary key of the current blogs entry
1308            * @param groupId the group ID to search with
1309            * @param displayDate the display date to search with
1310            * @param orderByComparator the comparator to order the set by
1311            * @return the previous, current, and next blogs entry
1312            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1313            * @throws SystemException if a system exception occurred
1314            */
1315            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_PrevAndNext(
1316                    long entryId, long groupId, java.util.Date displayDate,
1317                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1318                    throws com.liferay.portal.kernel.exception.SystemException,
1319                            com.liferay.portlet.blogs.NoSuchEntryException {
1320                    return getPersistence()
1321                                       .filterFindByG_LtD_PrevAndNext(entryId, groupId,
1322                            displayDate, orderByComparator);
1323            }
1324    
1325            /**
1326            * Finds all the blogs entries where groupId = &#63; and status = &#63;.
1327            *
1328            * @param groupId the group ID to search with
1329            * @param status the status to search with
1330            * @return the matching blogs entries
1331            * @throws SystemException if a system exception occurred
1332            */
1333            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1334                    long groupId, int status)
1335                    throws com.liferay.portal.kernel.exception.SystemException {
1336                    return getPersistence().findByG_S(groupId, status);
1337            }
1338    
1339            /**
1340            * Finds a range of all the blogs entries where groupId = &#63; and status = &#63;.
1341            *
1342            * <p>
1343            * 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.
1344            * </p>
1345            *
1346            * @param groupId the group ID to search with
1347            * @param status the status to search with
1348            * @param start the lower bound of the range of blogs entries to return
1349            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1350            * @return the range of matching blogs entries
1351            * @throws SystemException if a system exception occurred
1352            */
1353            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1354                    long groupId, int status, int start, int end)
1355                    throws com.liferay.portal.kernel.exception.SystemException {
1356                    return getPersistence().findByG_S(groupId, status, start, end);
1357            }
1358    
1359            /**
1360            * Finds an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
1361            *
1362            * <p>
1363            * 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.
1364            * </p>
1365            *
1366            * @param groupId the group ID to search with
1367            * @param status the status to search with
1368            * @param start the lower bound of the range of blogs entries to return
1369            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1370            * @param orderByComparator the comparator to order the results by
1371            * @return the ordered range of matching blogs entries
1372            * @throws SystemException if a system exception occurred
1373            */
1374            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1375                    long groupId, int status, int start, int end,
1376                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1377                    throws com.liferay.portal.kernel.exception.SystemException {
1378                    return getPersistence()
1379                                       .findByG_S(groupId, status, start, end, orderByComparator);
1380            }
1381    
1382            /**
1383            * Finds the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1384            *
1385            * <p>
1386            * 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.
1387            * </p>
1388            *
1389            * @param groupId the group ID to search with
1390            * @param status the status to search with
1391            * @param orderByComparator the comparator to order the set by
1392            * @return the first matching blogs entry
1393            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1394            * @throws SystemException if a system exception occurred
1395            */
1396            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_First(
1397                    long groupId, int status,
1398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1399                    throws com.liferay.portal.kernel.exception.SystemException,
1400                            com.liferay.portlet.blogs.NoSuchEntryException {
1401                    return getPersistence()
1402                                       .findByG_S_First(groupId, status, orderByComparator);
1403            }
1404    
1405            /**
1406            * Finds the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1407            *
1408            * <p>
1409            * 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.
1410            * </p>
1411            *
1412            * @param groupId the group ID to search with
1413            * @param status the status to search with
1414            * @param orderByComparator the comparator to order the set by
1415            * @return the last matching blogs entry
1416            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1417            * @throws SystemException if a system exception occurred
1418            */
1419            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_Last(
1420                    long groupId, int status,
1421                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1422                    throws com.liferay.portal.kernel.exception.SystemException,
1423                            com.liferay.portlet.blogs.NoSuchEntryException {
1424                    return getPersistence()
1425                                       .findByG_S_Last(groupId, status, orderByComparator);
1426            }
1427    
1428            /**
1429            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1430            *
1431            * <p>
1432            * 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.
1433            * </p>
1434            *
1435            * @param entryId the primary key of the current blogs entry
1436            * @param groupId the group ID to search with
1437            * @param status the status to search with
1438            * @param orderByComparator the comparator to order the set by
1439            * @return the previous, current, and next blogs entry
1440            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1441            * @throws SystemException if a system exception occurred
1442            */
1443            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_S_PrevAndNext(
1444                    long entryId, long groupId, int status,
1445                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1446                    throws com.liferay.portal.kernel.exception.SystemException,
1447                            com.liferay.portlet.blogs.NoSuchEntryException {
1448                    return getPersistence()
1449                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1450                            orderByComparator);
1451            }
1452    
1453            /**
1454            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and status = &#63;.
1455            *
1456            * @param groupId the group ID to search with
1457            * @param status the status to search with
1458            * @return the matching blogs entries that the user has permission to view
1459            * @throws SystemException if a system exception occurred
1460            */
1461            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1462                    long groupId, int status)
1463                    throws com.liferay.portal.kernel.exception.SystemException {
1464                    return getPersistence().filterFindByG_S(groupId, status);
1465            }
1466    
1467            /**
1468            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and status = &#63;.
1469            *
1470            * <p>
1471            * 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.
1472            * </p>
1473            *
1474            * @param groupId the group ID to search with
1475            * @param status the status to search with
1476            * @param start the lower bound of the range of blogs entries to return
1477            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1478            * @return the range of matching blogs entries that the user has permission to view
1479            * @throws SystemException if a system exception occurred
1480            */
1481            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1482                    long groupId, int status, int start, int end)
1483                    throws com.liferay.portal.kernel.exception.SystemException {
1484                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1485            }
1486    
1487            /**
1488            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
1489            *
1490            * <p>
1491            * 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.
1492            * </p>
1493            *
1494            * @param groupId the group ID to search with
1495            * @param status the status to search with
1496            * @param start the lower bound of the range of blogs entries to return
1497            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1498            * @param orderByComparator the comparator to order the results by
1499            * @return the ordered range of matching blogs entries that the user has permission to view
1500            * @throws SystemException if a system exception occurred
1501            */
1502            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1503                    long groupId, int status, int start, int end,
1504                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1505                    throws com.liferay.portal.kernel.exception.SystemException {
1506                    return getPersistence()
1507                                       .filterFindByG_S(groupId, status, start, end,
1508                            orderByComparator);
1509            }
1510    
1511            /**
1512            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1513            *
1514            * <p>
1515            * 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.
1516            * </p>
1517            *
1518            * @param entryId the primary key of the current blogs entry
1519            * @param groupId the group ID to search with
1520            * @param status the status to search with
1521            * @param orderByComparator the comparator to order the set by
1522            * @return the previous, current, and next blogs entry
1523            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1524            * @throws SystemException if a system exception occurred
1525            */
1526            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_S_PrevAndNext(
1527                    long entryId, long groupId, int status,
1528                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1529                    throws com.liferay.portal.kernel.exception.SystemException,
1530                            com.liferay.portlet.blogs.NoSuchEntryException {
1531                    return getPersistence()
1532                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
1533                            orderByComparator);
1534            }
1535    
1536            /**
1537            * Finds all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1538            *
1539            * @param companyId the company ID to search with
1540            * @param userId the user ID to search with
1541            * @param status the status to search with
1542            * @return the matching blogs entries
1543            * @throws SystemException if a system exception occurred
1544            */
1545            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1546                    long companyId, long userId, int status)
1547                    throws com.liferay.portal.kernel.exception.SystemException {
1548                    return getPersistence().findByC_U_S(companyId, userId, status);
1549            }
1550    
1551            /**
1552            * Finds a range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1553            *
1554            * <p>
1555            * 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.
1556            * </p>
1557            *
1558            * @param companyId the company ID to search with
1559            * @param userId the user ID to search with
1560            * @param status the status to search with
1561            * @param start the lower bound of the range of blogs entries to return
1562            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1563            * @return the range of matching blogs entries
1564            * @throws SystemException if a system exception occurred
1565            */
1566            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1567                    long companyId, long userId, int status, int start, int end)
1568                    throws com.liferay.portal.kernel.exception.SystemException {
1569                    return getPersistence()
1570                                       .findByC_U_S(companyId, userId, status, start, end);
1571            }
1572    
1573            /**
1574            * Finds an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1575            *
1576            * <p>
1577            * 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.
1578            * </p>
1579            *
1580            * @param companyId the company ID to search with
1581            * @param userId the user ID to search with
1582            * @param status the status to search with
1583            * @param start the lower bound of the range of blogs entries to return
1584            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1585            * @param orderByComparator the comparator to order the results by
1586            * @return the ordered range of matching blogs entries
1587            * @throws SystemException if a system exception occurred
1588            */
1589            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1590                    long companyId, long userId, int status, int start, int end,
1591                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1592                    throws com.liferay.portal.kernel.exception.SystemException {
1593                    return getPersistence()
1594                                       .findByC_U_S(companyId, userId, status, start, end,
1595                            orderByComparator);
1596            }
1597    
1598            /**
1599            * Finds the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1600            *
1601            * <p>
1602            * 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.
1603            * </p>
1604            *
1605            * @param companyId the company ID to search with
1606            * @param userId the user ID to search with
1607            * @param status the status to search with
1608            * @param orderByComparator the comparator to order the set by
1609            * @return the first matching blogs entry
1610            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1611            * @throws SystemException if a system exception occurred
1612            */
1613            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_First(
1614                    long companyId, long userId, int status,
1615                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1616                    throws com.liferay.portal.kernel.exception.SystemException,
1617                            com.liferay.portlet.blogs.NoSuchEntryException {
1618                    return getPersistence()
1619                                       .findByC_U_S_First(companyId, userId, status,
1620                            orderByComparator);
1621            }
1622    
1623            /**
1624            * Finds the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1625            *
1626            * <p>
1627            * 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.
1628            * </p>
1629            *
1630            * @param companyId the company ID to search with
1631            * @param userId the user ID to search with
1632            * @param status the status to search with
1633            * @param orderByComparator the comparator to order the set by
1634            * @return the last matching blogs entry
1635            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_Last(
1639                    long companyId, long userId, int status,
1640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1641                    throws com.liferay.portal.kernel.exception.SystemException,
1642                            com.liferay.portlet.blogs.NoSuchEntryException {
1643                    return getPersistence()
1644                                       .findByC_U_S_Last(companyId, userId, status,
1645                            orderByComparator);
1646            }
1647    
1648            /**
1649            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1650            *
1651            * <p>
1652            * 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.
1653            * </p>
1654            *
1655            * @param entryId the primary key of the current blogs entry
1656            * @param companyId the company ID to search with
1657            * @param userId the user ID to search with
1658            * @param status the status to search with
1659            * @param orderByComparator the comparator to order the set by
1660            * @return the previous, current, and next blogs entry
1661            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1662            * @throws SystemException if a system exception occurred
1663            */
1664            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_S_PrevAndNext(
1665                    long entryId, long companyId, long userId, int status,
1666                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1667                    throws com.liferay.portal.kernel.exception.SystemException,
1668                            com.liferay.portlet.blogs.NoSuchEntryException {
1669                    return getPersistence()
1670                                       .findByC_U_S_PrevAndNext(entryId, companyId, userId, status,
1671                            orderByComparator);
1672            }
1673    
1674            /**
1675            * Finds all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1676            *
1677            * @param companyId the company ID to search with
1678            * @param displayDate the display date to search with
1679            * @param status the status to search with
1680            * @return the matching blogs entries
1681            * @throws SystemException if a system exception occurred
1682            */
1683            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1684                    long companyId, java.util.Date displayDate, int status)
1685                    throws com.liferay.portal.kernel.exception.SystemException {
1686                    return getPersistence().findByC_LtD_S(companyId, displayDate, status);
1687            }
1688    
1689            /**
1690            * Finds a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1691            *
1692            * <p>
1693            * 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.
1694            * </p>
1695            *
1696            * @param companyId the company ID to search with
1697            * @param displayDate the display date to search with
1698            * @param status the status to search with
1699            * @param start the lower bound of the range of blogs entries to return
1700            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1701            * @return the range of matching blogs entries
1702            * @throws SystemException if a system exception occurred
1703            */
1704            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1705                    long companyId, java.util.Date displayDate, int status, int start,
1706                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1707                    return getPersistence()
1708                                       .findByC_LtD_S(companyId, displayDate, status, start, end);
1709            }
1710    
1711            /**
1712            * Finds an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1713            *
1714            * <p>
1715            * 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.
1716            * </p>
1717            *
1718            * @param companyId the company ID to search with
1719            * @param displayDate the display date to search with
1720            * @param status the status to search with
1721            * @param start the lower bound of the range of blogs entries to return
1722            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1723            * @param orderByComparator the comparator to order the results by
1724            * @return the ordered range of matching blogs entries
1725            * @throws SystemException if a system exception occurred
1726            */
1727            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1728                    long companyId, java.util.Date displayDate, int status, int start,
1729                    int end,
1730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1731                    throws com.liferay.portal.kernel.exception.SystemException {
1732                    return getPersistence()
1733                                       .findByC_LtD_S(companyId, displayDate, status, start, end,
1734                            orderByComparator);
1735            }
1736    
1737            /**
1738            * Finds the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1739            *
1740            * <p>
1741            * 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.
1742            * </p>
1743            *
1744            * @param companyId the company ID to search with
1745            * @param displayDate the display date to search with
1746            * @param status the status to search with
1747            * @param orderByComparator the comparator to order the set by
1748            * @return the first matching blogs entry
1749            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1750            * @throws SystemException if a system exception occurred
1751            */
1752            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_First(
1753                    long companyId, java.util.Date displayDate, int status,
1754                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1755                    throws com.liferay.portal.kernel.exception.SystemException,
1756                            com.liferay.portlet.blogs.NoSuchEntryException {
1757                    return getPersistence()
1758                                       .findByC_LtD_S_First(companyId, displayDate, status,
1759                            orderByComparator);
1760            }
1761    
1762            /**
1763            * Finds the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1764            *
1765            * <p>
1766            * 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.
1767            * </p>
1768            *
1769            * @param companyId the company ID to search with
1770            * @param displayDate the display date to search with
1771            * @param status the status to search with
1772            * @param orderByComparator the comparator to order the set by
1773            * @return the last matching blogs entry
1774            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1775            * @throws SystemException if a system exception occurred
1776            */
1777            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_Last(
1778                    long companyId, java.util.Date displayDate, int status,
1779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1780                    throws com.liferay.portal.kernel.exception.SystemException,
1781                            com.liferay.portlet.blogs.NoSuchEntryException {
1782                    return getPersistence()
1783                                       .findByC_LtD_S_Last(companyId, displayDate, status,
1784                            orderByComparator);
1785            }
1786    
1787            /**
1788            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1789            *
1790            * <p>
1791            * 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.
1792            * </p>
1793            *
1794            * @param entryId the primary key of the current blogs entry
1795            * @param companyId the company ID to search with
1796            * @param displayDate the display date to search with
1797            * @param status the status to search with
1798            * @param orderByComparator the comparator to order the set by
1799            * @return the previous, current, and next blogs entry
1800            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1801            * @throws SystemException if a system exception occurred
1802            */
1803            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_S_PrevAndNext(
1804                    long entryId, long companyId, java.util.Date displayDate, int status,
1805                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1806                    throws com.liferay.portal.kernel.exception.SystemException,
1807                            com.liferay.portlet.blogs.NoSuchEntryException {
1808                    return getPersistence()
1809                                       .findByC_LtD_S_PrevAndNext(entryId, companyId, displayDate,
1810                            status, orderByComparator);
1811            }
1812    
1813            /**
1814            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1815            *
1816            * @param groupId the group ID to search with
1817            * @param userId the user ID to search with
1818            * @param displayDate the display date to search with
1819            * @return the matching blogs entries
1820            * @throws SystemException if a system exception occurred
1821            */
1822            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1823                    long groupId, long userId, java.util.Date displayDate)
1824                    throws com.liferay.portal.kernel.exception.SystemException {
1825                    return getPersistence().findByG_U_LtD(groupId, userId, displayDate);
1826            }
1827    
1828            /**
1829            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1830            *
1831            * <p>
1832            * 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.
1833            * </p>
1834            *
1835            * @param groupId the group ID to search with
1836            * @param userId the user ID to search with
1837            * @param displayDate the display date to search with
1838            * @param start the lower bound of the range of blogs entries to return
1839            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1840            * @return the range of matching blogs entries
1841            * @throws SystemException if a system exception occurred
1842            */
1843            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1844                    long groupId, long userId, java.util.Date displayDate, int start,
1845                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1846                    return getPersistence()
1847                                       .findByG_U_LtD(groupId, userId, displayDate, start, end);
1848            }
1849    
1850            /**
1851            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1852            *
1853            * <p>
1854            * 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.
1855            * </p>
1856            *
1857            * @param groupId the group ID to search with
1858            * @param userId the user ID to search with
1859            * @param displayDate the display date to search with
1860            * @param start the lower bound of the range of blogs entries to return
1861            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1862            * @param orderByComparator the comparator to order the results by
1863            * @return the ordered range of matching blogs entries
1864            * @throws SystemException if a system exception occurred
1865            */
1866            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1867                    long groupId, long userId, java.util.Date displayDate, int start,
1868                    int end,
1869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1870                    throws com.liferay.portal.kernel.exception.SystemException {
1871                    return getPersistence()
1872                                       .findByG_U_LtD(groupId, userId, displayDate, start, end,
1873                            orderByComparator);
1874            }
1875    
1876            /**
1877            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1878            *
1879            * <p>
1880            * 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.
1881            * </p>
1882            *
1883            * @param groupId the group ID to search with
1884            * @param userId the user ID to search with
1885            * @param displayDate the display date to search with
1886            * @param orderByComparator the comparator to order the set by
1887            * @return the first matching blogs entry
1888            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1889            * @throws SystemException if a system exception occurred
1890            */
1891            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_First(
1892                    long groupId, long userId, java.util.Date displayDate,
1893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1894                    throws com.liferay.portal.kernel.exception.SystemException,
1895                            com.liferay.portlet.blogs.NoSuchEntryException {
1896                    return getPersistence()
1897                                       .findByG_U_LtD_First(groupId, userId, displayDate,
1898                            orderByComparator);
1899            }
1900    
1901            /**
1902            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1903            *
1904            * <p>
1905            * 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.
1906            * </p>
1907            *
1908            * @param groupId the group ID to search with
1909            * @param userId the user ID to search with
1910            * @param displayDate the display date to search with
1911            * @param orderByComparator the comparator to order the set by
1912            * @return the last matching blogs entry
1913            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1914            * @throws SystemException if a system exception occurred
1915            */
1916            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_Last(
1917                    long groupId, long userId, java.util.Date displayDate,
1918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1919                    throws com.liferay.portal.kernel.exception.SystemException,
1920                            com.liferay.portlet.blogs.NoSuchEntryException {
1921                    return getPersistence()
1922                                       .findByG_U_LtD_Last(groupId, userId, displayDate,
1923                            orderByComparator);
1924            }
1925    
1926            /**
1927            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1928            *
1929            * <p>
1930            * 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.
1931            * </p>
1932            *
1933            * @param entryId the primary key of the current blogs entry
1934            * @param groupId the group ID to search with
1935            * @param userId the user ID to search with
1936            * @param displayDate the display date to search with
1937            * @param orderByComparator the comparator to order the set by
1938            * @return the previous, current, and next blogs entry
1939            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1940            * @throws SystemException if a system exception occurred
1941            */
1942            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_PrevAndNext(
1943                    long entryId, long groupId, long userId, java.util.Date displayDate,
1944                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1945                    throws com.liferay.portal.kernel.exception.SystemException,
1946                            com.liferay.portlet.blogs.NoSuchEntryException {
1947                    return getPersistence()
1948                                       .findByG_U_LtD_PrevAndNext(entryId, groupId, userId,
1949                            displayDate, orderByComparator);
1950            }
1951    
1952            /**
1953            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1954            *
1955            * @param groupId the group ID to search with
1956            * @param userId the user ID to search with
1957            * @param displayDate the display date to search with
1958            * @return the matching blogs entries that the user has permission to view
1959            * @throws SystemException if a system exception occurred
1960            */
1961            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
1962                    long groupId, long userId, java.util.Date displayDate)
1963                    throws com.liferay.portal.kernel.exception.SystemException {
1964                    return getPersistence().filterFindByG_U_LtD(groupId, userId, displayDate);
1965            }
1966    
1967            /**
1968            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1969            *
1970            * <p>
1971            * 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.
1972            * </p>
1973            *
1974            * @param groupId the group ID to search with
1975            * @param userId the user ID to search with
1976            * @param displayDate the display date to search with
1977            * @param start the lower bound of the range of blogs entries to return
1978            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1979            * @return the range of matching blogs entries that the user has permission to view
1980            * @throws SystemException if a system exception occurred
1981            */
1982            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
1983                    long groupId, long userId, java.util.Date displayDate, int start,
1984                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1985                    return getPersistence()
1986                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start, end);
1987            }
1988    
1989            /**
1990            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1991            *
1992            * <p>
1993            * 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.
1994            * </p>
1995            *
1996            * @param groupId the group ID to search with
1997            * @param userId the user ID to search with
1998            * @param displayDate the display date to search with
1999            * @param start the lower bound of the range of blogs entries to return
2000            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2001            * @param orderByComparator the comparator to order the results by
2002            * @return the ordered range of matching blogs entries that the user has permission to view
2003            * @throws SystemException if a system exception occurred
2004            */
2005            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
2006                    long groupId, long userId, java.util.Date displayDate, int start,
2007                    int end,
2008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2009                    throws com.liferay.portal.kernel.exception.SystemException {
2010                    return getPersistence()
2011                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start,
2012                            end, orderByComparator);
2013            }
2014    
2015            /**
2016            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
2017            *
2018            * <p>
2019            * 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.
2020            * </p>
2021            *
2022            * @param entryId the primary key of the current blogs entry
2023            * @param groupId the group ID to search with
2024            * @param userId the user ID to search with
2025            * @param displayDate the display date to search with
2026            * @param orderByComparator the comparator to order the set by
2027            * @return the previous, current, and next blogs entry
2028            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2029            * @throws SystemException if a system exception occurred
2030            */
2031            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_PrevAndNext(
2032                    long entryId, long groupId, long userId, java.util.Date displayDate,
2033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2034                    throws com.liferay.portal.kernel.exception.SystemException,
2035                            com.liferay.portlet.blogs.NoSuchEntryException {
2036                    return getPersistence()
2037                                       .filterFindByG_U_LtD_PrevAndNext(entryId, groupId, userId,
2038                            displayDate, orderByComparator);
2039            }
2040    
2041            /**
2042            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2043            *
2044            * @param groupId the group ID to search with
2045            * @param userId the user ID to search with
2046            * @param status the status to search with
2047            * @return the matching blogs entries
2048            * @throws SystemException if a system exception occurred
2049            */
2050            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
2051                    long groupId, long userId, int status)
2052                    throws com.liferay.portal.kernel.exception.SystemException {
2053                    return getPersistence().findByG_U_S(groupId, userId, status);
2054            }
2055    
2056            /**
2057            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2058            *
2059            * <p>
2060            * 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.
2061            * </p>
2062            *
2063            * @param groupId the group ID to search with
2064            * @param userId the user ID to search with
2065            * @param status the status to search with
2066            * @param start the lower bound of the range of blogs entries to return
2067            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2068            * @return the range of matching blogs entries
2069            * @throws SystemException if a system exception occurred
2070            */
2071            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
2072                    long groupId, long userId, int status, int start, int end)
2073                    throws com.liferay.portal.kernel.exception.SystemException {
2074                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
2075            }
2076    
2077            /**
2078            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2079            *
2080            * <p>
2081            * 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.
2082            * </p>
2083            *
2084            * @param groupId the group ID to search with
2085            * @param userId the user ID to search with
2086            * @param status the status to search with
2087            * @param start the lower bound of the range of blogs entries to return
2088            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2089            * @param orderByComparator the comparator to order the results by
2090            * @return the ordered range of matching blogs entries
2091            * @throws SystemException if a system exception occurred
2092            */
2093            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
2094                    long groupId, long userId, int status, int start, int end,
2095                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2096                    throws com.liferay.portal.kernel.exception.SystemException {
2097                    return getPersistence()
2098                                       .findByG_U_S(groupId, userId, status, start, end,
2099                            orderByComparator);
2100            }
2101    
2102            /**
2103            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2104            *
2105            * <p>
2106            * 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.
2107            * </p>
2108            *
2109            * @param groupId the group ID to search with
2110            * @param userId the user ID to search with
2111            * @param status the status to search with
2112            * @param orderByComparator the comparator to order the set by
2113            * @return the first matching blogs entry
2114            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2115            * @throws SystemException if a system exception occurred
2116            */
2117            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_First(
2118                    long groupId, long userId, int status,
2119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2120                    throws com.liferay.portal.kernel.exception.SystemException,
2121                            com.liferay.portlet.blogs.NoSuchEntryException {
2122                    return getPersistence()
2123                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
2124            }
2125    
2126            /**
2127            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2128            *
2129            * <p>
2130            * 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.
2131            * </p>
2132            *
2133            * @param groupId the group ID to search with
2134            * @param userId the user ID to search with
2135            * @param status the status to search with
2136            * @param orderByComparator the comparator to order the set by
2137            * @return the last matching blogs entry
2138            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2139            * @throws SystemException if a system exception occurred
2140            */
2141            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_Last(
2142                    long groupId, long userId, int status,
2143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2144                    throws com.liferay.portal.kernel.exception.SystemException,
2145                            com.liferay.portlet.blogs.NoSuchEntryException {
2146                    return getPersistence()
2147                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
2148            }
2149    
2150            /**
2151            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2152            *
2153            * <p>
2154            * 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.
2155            * </p>
2156            *
2157            * @param entryId the primary key of the current blogs entry
2158            * @param groupId the group ID to search with
2159            * @param userId the user ID to search with
2160            * @param status the status to search with
2161            * @param orderByComparator the comparator to order the set by
2162            * @return the previous, current, and next blogs entry
2163            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_S_PrevAndNext(
2167                    long entryId, long groupId, long userId, int status,
2168                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2169                    throws com.liferay.portal.kernel.exception.SystemException,
2170                            com.liferay.portlet.blogs.NoSuchEntryException {
2171                    return getPersistence()
2172                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
2173                            orderByComparator);
2174            }
2175    
2176            /**
2177            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2178            *
2179            * @param groupId the group ID to search with
2180            * @param userId the user ID to search with
2181            * @param status the status to search with
2182            * @return the matching blogs entries that the user has permission to view
2183            * @throws SystemException if a system exception occurred
2184            */
2185            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2186                    long groupId, long userId, int status)
2187                    throws com.liferay.portal.kernel.exception.SystemException {
2188                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
2189            }
2190    
2191            /**
2192            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2193            *
2194            * <p>
2195            * 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.
2196            * </p>
2197            *
2198            * @param groupId the group ID to search with
2199            * @param userId the user ID to search with
2200            * @param status the status to search with
2201            * @param start the lower bound of the range of blogs entries to return
2202            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2203            * @return the range of matching blogs entries that the user has permission to view
2204            * @throws SystemException if a system exception occurred
2205            */
2206            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2207                    long groupId, long userId, int status, int start, int end)
2208                    throws com.liferay.portal.kernel.exception.SystemException {
2209                    return getPersistence()
2210                                       .filterFindByG_U_S(groupId, userId, status, start, end);
2211            }
2212    
2213            /**
2214            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2215            *
2216            * <p>
2217            * 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.
2218            * </p>
2219            *
2220            * @param groupId the group ID to search with
2221            * @param userId the user ID to search with
2222            * @param status the status to search with
2223            * @param start the lower bound of the range of blogs entries to return
2224            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2225            * @param orderByComparator the comparator to order the results by
2226            * @return the ordered range of matching blogs entries that the user has permission to view
2227            * @throws SystemException if a system exception occurred
2228            */
2229            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2230                    long groupId, long userId, int status, int start, int end,
2231                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2232                    throws com.liferay.portal.kernel.exception.SystemException {
2233                    return getPersistence()
2234                                       .filterFindByG_U_S(groupId, userId, status, start, end,
2235                            orderByComparator);
2236            }
2237    
2238            /**
2239            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2240            *
2241            * <p>
2242            * 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.
2243            * </p>
2244            *
2245            * @param entryId the primary key of the current blogs entry
2246            * @param groupId the group ID to search with
2247            * @param userId the user ID to search with
2248            * @param status the status to search with
2249            * @param orderByComparator the comparator to order the set by
2250            * @return the previous, current, and next blogs entry
2251            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2252            * @throws SystemException if a system exception occurred
2253            */
2254            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_S_PrevAndNext(
2255                    long entryId, long groupId, long userId, int status,
2256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2257                    throws com.liferay.portal.kernel.exception.SystemException,
2258                            com.liferay.portlet.blogs.NoSuchEntryException {
2259                    return getPersistence()
2260                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
2261                            status, orderByComparator);
2262            }
2263    
2264            /**
2265            * Finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2266            *
2267            * @param groupId the group ID to search with
2268            * @param displayDate the display date to search with
2269            * @param status the status to search with
2270            * @return the matching blogs entries
2271            * @throws SystemException if a system exception occurred
2272            */
2273            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2274                    long groupId, java.util.Date displayDate, int status)
2275                    throws com.liferay.portal.kernel.exception.SystemException {
2276                    return getPersistence().findByG_LtD_S(groupId, displayDate, status);
2277            }
2278    
2279            /**
2280            * Finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2281            *
2282            * <p>
2283            * 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.
2284            * </p>
2285            *
2286            * @param groupId the group ID to search with
2287            * @param displayDate the display date to search with
2288            * @param status the status to search with
2289            * @param start the lower bound of the range of blogs entries to return
2290            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2291            * @return the range of matching blogs entries
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2295                    long groupId, java.util.Date displayDate, int status, int start, int end)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence()
2298                                       .findByG_LtD_S(groupId, displayDate, status, start, end);
2299            }
2300    
2301            /**
2302            * Finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2303            *
2304            * <p>
2305            * 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.
2306            * </p>
2307            *
2308            * @param groupId the group ID to search with
2309            * @param displayDate the display date to search with
2310            * @param status the status to search with
2311            * @param start the lower bound of the range of blogs entries to return
2312            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2313            * @param orderByComparator the comparator to order the results by
2314            * @return the ordered range of matching blogs entries
2315            * @throws SystemException if a system exception occurred
2316            */
2317            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2318                    long groupId, java.util.Date displayDate, int status, int start,
2319                    int end,
2320                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2321                    throws com.liferay.portal.kernel.exception.SystemException {
2322                    return getPersistence()
2323                                       .findByG_LtD_S(groupId, displayDate, status, start, end,
2324                            orderByComparator);
2325            }
2326    
2327            /**
2328            * Finds the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2329            *
2330            * <p>
2331            * 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.
2332            * </p>
2333            *
2334            * @param groupId the group ID to search with
2335            * @param displayDate the display date to search with
2336            * @param status the status to search with
2337            * @param orderByComparator the comparator to order the set by
2338            * @return the first matching blogs entry
2339            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2340            * @throws SystemException if a system exception occurred
2341            */
2342            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_First(
2343                    long groupId, java.util.Date displayDate, int status,
2344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2345                    throws com.liferay.portal.kernel.exception.SystemException,
2346                            com.liferay.portlet.blogs.NoSuchEntryException {
2347                    return getPersistence()
2348                                       .findByG_LtD_S_First(groupId, displayDate, status,
2349                            orderByComparator);
2350            }
2351    
2352            /**
2353            * Finds the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2354            *
2355            * <p>
2356            * 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.
2357            * </p>
2358            *
2359            * @param groupId the group ID to search with
2360            * @param displayDate the display date to search with
2361            * @param status the status to search with
2362            * @param orderByComparator the comparator to order the set by
2363            * @return the last matching blogs entry
2364            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2365            * @throws SystemException if a system exception occurred
2366            */
2367            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_Last(
2368                    long groupId, java.util.Date displayDate, int status,
2369                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2370                    throws com.liferay.portal.kernel.exception.SystemException,
2371                            com.liferay.portlet.blogs.NoSuchEntryException {
2372                    return getPersistence()
2373                                       .findByG_LtD_S_Last(groupId, displayDate, status,
2374                            orderByComparator);
2375            }
2376    
2377            /**
2378            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2379            *
2380            * <p>
2381            * 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.
2382            * </p>
2383            *
2384            * @param entryId the primary key of the current blogs entry
2385            * @param groupId the group ID to search with
2386            * @param displayDate the display date to search with
2387            * @param status the status to search with
2388            * @param orderByComparator the comparator to order the set by
2389            * @return the previous, current, and next blogs entry
2390            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2391            * @throws SystemException if a system exception occurred
2392            */
2393            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_S_PrevAndNext(
2394                    long entryId, long groupId, java.util.Date displayDate, int status,
2395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2396                    throws com.liferay.portal.kernel.exception.SystemException,
2397                            com.liferay.portlet.blogs.NoSuchEntryException {
2398                    return getPersistence()
2399                                       .findByG_LtD_S_PrevAndNext(entryId, groupId, displayDate,
2400                            status, orderByComparator);
2401            }
2402    
2403            /**
2404            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2405            *
2406            * @param groupId the group ID to search with
2407            * @param displayDate the display date to search with
2408            * @param status the status to search with
2409            * @return the matching blogs entries that the user has permission to view
2410            * @throws SystemException if a system exception occurred
2411            */
2412            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2413                    long groupId, java.util.Date displayDate, int status)
2414                    throws com.liferay.portal.kernel.exception.SystemException {
2415                    return getPersistence().filterFindByG_LtD_S(groupId, displayDate, status);
2416            }
2417    
2418            /**
2419            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2420            *
2421            * <p>
2422            * 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.
2423            * </p>
2424            *
2425            * @param groupId the group ID to search with
2426            * @param displayDate the display date to search with
2427            * @param status the status to search with
2428            * @param start the lower bound of the range of blogs entries to return
2429            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2430            * @return the range of matching blogs entries that the user has permission to view
2431            * @throws SystemException if a system exception occurred
2432            */
2433            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2434                    long groupId, java.util.Date displayDate, int status, int start, int end)
2435                    throws com.liferay.portal.kernel.exception.SystemException {
2436                    return getPersistence()
2437                                       .filterFindByG_LtD_S(groupId, displayDate, status, start, end);
2438            }
2439    
2440            /**
2441            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2442            *
2443            * <p>
2444            * 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.
2445            * </p>
2446            *
2447            * @param groupId the group ID to search with
2448            * @param displayDate the display date to search with
2449            * @param status the status to search with
2450            * @param start the lower bound of the range of blogs entries to return
2451            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2452            * @param orderByComparator the comparator to order the results by
2453            * @return the ordered range of matching blogs entries that the user has permission to view
2454            * @throws SystemException if a system exception occurred
2455            */
2456            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2457                    long groupId, java.util.Date displayDate, int status, int start,
2458                    int end,
2459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2460                    throws com.liferay.portal.kernel.exception.SystemException {
2461                    return getPersistence()
2462                                       .filterFindByG_LtD_S(groupId, displayDate, status, start,
2463                            end, orderByComparator);
2464            }
2465    
2466            /**
2467            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2468            *
2469            * <p>
2470            * 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.
2471            * </p>
2472            *
2473            * @param entryId the primary key of the current blogs entry
2474            * @param groupId the group ID to search with
2475            * @param displayDate the display date to search with
2476            * @param status the status to search with
2477            * @param orderByComparator the comparator to order the set by
2478            * @return the previous, current, and next blogs entry
2479            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2480            * @throws SystemException if a system exception occurred
2481            */
2482            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_S_PrevAndNext(
2483                    long entryId, long groupId, java.util.Date displayDate, int status,
2484                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2485                    throws com.liferay.portal.kernel.exception.SystemException,
2486                            com.liferay.portlet.blogs.NoSuchEntryException {
2487                    return getPersistence()
2488                                       .filterFindByG_LtD_S_PrevAndNext(entryId, groupId,
2489                            displayDate, status, orderByComparator);
2490            }
2491    
2492            /**
2493            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2494            *
2495            * @param groupId the group ID to search with
2496            * @param userId the user ID to search with
2497            * @param displayDate the display date to search with
2498            * @param status the status to search with
2499            * @return the matching blogs entries
2500            * @throws SystemException if a system exception occurred
2501            */
2502            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2503                    long groupId, long userId, java.util.Date displayDate, int status)
2504                    throws com.liferay.portal.kernel.exception.SystemException {
2505                    return getPersistence()
2506                                       .findByG_U_LtD_S(groupId, userId, displayDate, status);
2507            }
2508    
2509            /**
2510            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2511            *
2512            * <p>
2513            * 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.
2514            * </p>
2515            *
2516            * @param groupId the group ID to search with
2517            * @param userId the user ID to search with
2518            * @param displayDate the display date to search with
2519            * @param status the status to search with
2520            * @param start the lower bound of the range of blogs entries to return
2521            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2522            * @return the range of matching blogs entries
2523            * @throws SystemException if a system exception occurred
2524            */
2525            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2526                    long groupId, long userId, java.util.Date displayDate, int status,
2527                    int start, int end)
2528                    throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence()
2530                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
2531                            start, end);
2532            }
2533    
2534            /**
2535            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2536            *
2537            * <p>
2538            * 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.
2539            * </p>
2540            *
2541            * @param groupId the group ID to search with
2542            * @param userId the user ID to search with
2543            * @param displayDate the display date to search with
2544            * @param status the status to search with
2545            * @param start the lower bound of the range of blogs entries to return
2546            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2547            * @param orderByComparator the comparator to order the results by
2548            * @return the ordered range of matching blogs entries
2549            * @throws SystemException if a system exception occurred
2550            */
2551            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2552                    long groupId, long userId, java.util.Date displayDate, int status,
2553                    int start, int end,
2554                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2555                    throws com.liferay.portal.kernel.exception.SystemException {
2556                    return getPersistence()
2557                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
2558                            start, end, orderByComparator);
2559            }
2560    
2561            /**
2562            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2563            *
2564            * <p>
2565            * 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.
2566            * </p>
2567            *
2568            * @param groupId the group ID to search with
2569            * @param userId the user ID to search with
2570            * @param displayDate the display date to search with
2571            * @param status the status to search with
2572            * @param orderByComparator the comparator to order the set by
2573            * @return the first matching blogs entry
2574            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2575            * @throws SystemException if a system exception occurred
2576            */
2577            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_First(
2578                    long groupId, long userId, java.util.Date displayDate, int status,
2579                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2580                    throws com.liferay.portal.kernel.exception.SystemException,
2581                            com.liferay.portlet.blogs.NoSuchEntryException {
2582                    return getPersistence()
2583                                       .findByG_U_LtD_S_First(groupId, userId, displayDate, status,
2584                            orderByComparator);
2585            }
2586    
2587            /**
2588            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2589            *
2590            * <p>
2591            * 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.
2592            * </p>
2593            *
2594            * @param groupId the group ID to search with
2595            * @param userId the user ID to search with
2596            * @param displayDate the display date to search with
2597            * @param status the status to search with
2598            * @param orderByComparator the comparator to order the set by
2599            * @return the last matching blogs entry
2600            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2601            * @throws SystemException if a system exception occurred
2602            */
2603            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_Last(
2604                    long groupId, long userId, java.util.Date displayDate, int status,
2605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2606                    throws com.liferay.portal.kernel.exception.SystemException,
2607                            com.liferay.portlet.blogs.NoSuchEntryException {
2608                    return getPersistence()
2609                                       .findByG_U_LtD_S_Last(groupId, userId, displayDate, status,
2610                            orderByComparator);
2611            }
2612    
2613            /**
2614            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2615            *
2616            * <p>
2617            * 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.
2618            * </p>
2619            *
2620            * @param entryId the primary key of the current blogs entry
2621            * @param groupId the group ID to search with
2622            * @param userId the user ID to search with
2623            * @param displayDate the display date to search with
2624            * @param status the status to search with
2625            * @param orderByComparator the comparator to order the set by
2626            * @return the previous, current, and next blogs entry
2627            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2628            * @throws SystemException if a system exception occurred
2629            */
2630            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_S_PrevAndNext(
2631                    long entryId, long groupId, long userId, java.util.Date displayDate,
2632                    int status,
2633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2634                    throws com.liferay.portal.kernel.exception.SystemException,
2635                            com.liferay.portlet.blogs.NoSuchEntryException {
2636                    return getPersistence()
2637                                       .findByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
2638                            displayDate, status, orderByComparator);
2639            }
2640    
2641            /**
2642            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2643            *
2644            * @param groupId the group ID to search with
2645            * @param userId the user ID to search with
2646            * @param displayDate the display date to search with
2647            * @param status the status to search with
2648            * @return the matching blogs entries that the user has permission to view
2649            * @throws SystemException if a system exception occurred
2650            */
2651            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2652                    long groupId, long userId, java.util.Date displayDate, int status)
2653                    throws com.liferay.portal.kernel.exception.SystemException {
2654                    return getPersistence()
2655                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status);
2656            }
2657    
2658            /**
2659            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2660            *
2661            * <p>
2662            * 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.
2663            * </p>
2664            *
2665            * @param groupId the group ID to search with
2666            * @param userId the user ID to search with
2667            * @param displayDate the display date to search with
2668            * @param status the status to search with
2669            * @param start the lower bound of the range of blogs entries to return
2670            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2671            * @return the range of matching blogs entries that the user has permission to view
2672            * @throws SystemException if a system exception occurred
2673            */
2674            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2675                    long groupId, long userId, java.util.Date displayDate, int status,
2676                    int start, int end)
2677                    throws com.liferay.portal.kernel.exception.SystemException {
2678                    return getPersistence()
2679                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
2680                            start, end);
2681            }
2682    
2683            /**
2684            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2685            *
2686            * <p>
2687            * 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.
2688            * </p>
2689            *
2690            * @param groupId the group ID to search with
2691            * @param userId the user ID to search with
2692            * @param displayDate the display date to search with
2693            * @param status the status to search with
2694            * @param start the lower bound of the range of blogs entries to return
2695            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2696            * @param orderByComparator the comparator to order the results by
2697            * @return the ordered range of matching blogs entries that the user has permission to view
2698            * @throws SystemException if a system exception occurred
2699            */
2700            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2701                    long groupId, long userId, java.util.Date displayDate, int status,
2702                    int start, int end,
2703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2704                    throws com.liferay.portal.kernel.exception.SystemException {
2705                    return getPersistence()
2706                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
2707                            start, end, orderByComparator);
2708            }
2709    
2710            /**
2711            * Filters the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2712            *
2713            * <p>
2714            * 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.
2715            * </p>
2716            *
2717            * @param entryId the primary key of the current blogs entry
2718            * @param groupId the group ID to search with
2719            * @param userId the user ID to search with
2720            * @param displayDate the display date to search with
2721            * @param status the status to search with
2722            * @param orderByComparator the comparator to order the set by
2723            * @return the previous, current, and next blogs entry
2724            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2725            * @throws SystemException if a system exception occurred
2726            */
2727            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_S_PrevAndNext(
2728                    long entryId, long groupId, long userId, java.util.Date displayDate,
2729                    int status,
2730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2731                    throws com.liferay.portal.kernel.exception.SystemException,
2732                            com.liferay.portlet.blogs.NoSuchEntryException {
2733                    return getPersistence()
2734                                       .filterFindByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
2735                            displayDate, status, orderByComparator);
2736            }
2737    
2738            /**
2739            * Finds all the blogs entries.
2740            *
2741            * @return the blogs entries
2742            * @throws SystemException if a system exception occurred
2743            */
2744            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll()
2745                    throws com.liferay.portal.kernel.exception.SystemException {
2746                    return getPersistence().findAll();
2747            }
2748    
2749            /**
2750            * Finds a range of all the blogs entries.
2751            *
2752            * <p>
2753            * 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.
2754            * </p>
2755            *
2756            * @param start the lower bound of the range of blogs entries to return
2757            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2758            * @return the range of blogs entries
2759            * @throws SystemException if a system exception occurred
2760            */
2761            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
2762                    int start, int end)
2763                    throws com.liferay.portal.kernel.exception.SystemException {
2764                    return getPersistence().findAll(start, end);
2765            }
2766    
2767            /**
2768            * Finds an ordered range of all the blogs entries.
2769            *
2770            * <p>
2771            * 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.
2772            * </p>
2773            *
2774            * @param start the lower bound of the range of blogs entries to return
2775            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2776            * @param orderByComparator the comparator to order the results by
2777            * @return the ordered range of blogs entries
2778            * @throws SystemException if a system exception occurred
2779            */
2780            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
2781                    int start, int end,
2782                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2783                    throws com.liferay.portal.kernel.exception.SystemException {
2784                    return getPersistence().findAll(start, end, orderByComparator);
2785            }
2786    
2787            /**
2788            * Removes all the blogs entries where uuid = &#63; from the database.
2789            *
2790            * @param uuid the uuid to search with
2791            * @throws SystemException if a system exception occurred
2792            */
2793            public static void removeByUuid(java.lang.String uuid)
2794                    throws com.liferay.portal.kernel.exception.SystemException {
2795                    getPersistence().removeByUuid(uuid);
2796            }
2797    
2798            /**
2799            * Removes the blogs entry where uuid = &#63; and groupId = &#63; from the database.
2800            *
2801            * @param uuid the uuid to search with
2802            * @param groupId the group ID to search with
2803            * @throws SystemException if a system exception occurred
2804            */
2805            public static void removeByUUID_G(java.lang.String uuid, long groupId)
2806                    throws com.liferay.portal.kernel.exception.SystemException,
2807                            com.liferay.portlet.blogs.NoSuchEntryException {
2808                    getPersistence().removeByUUID_G(uuid, groupId);
2809            }
2810    
2811            /**
2812            * Removes all the blogs entries where groupId = &#63; from the database.
2813            *
2814            * @param groupId the group ID to search with
2815            * @throws SystemException if a system exception occurred
2816            */
2817            public static void removeByGroupId(long groupId)
2818                    throws com.liferay.portal.kernel.exception.SystemException {
2819                    getPersistence().removeByGroupId(groupId);
2820            }
2821    
2822            /**
2823            * Removes all the blogs entries where companyId = &#63; from the database.
2824            *
2825            * @param companyId the company ID to search with
2826            * @throws SystemException if a system exception occurred
2827            */
2828            public static void removeByCompanyId(long companyId)
2829                    throws com.liferay.portal.kernel.exception.SystemException {
2830                    getPersistence().removeByCompanyId(companyId);
2831            }
2832    
2833            /**
2834            * Removes all the blogs entries where companyId = &#63; and userId = &#63; from the database.
2835            *
2836            * @param companyId the company ID to search with
2837            * @param userId the user ID to search with
2838            * @throws SystemException if a system exception occurred
2839            */
2840            public static void removeByC_U(long companyId, long userId)
2841                    throws com.liferay.portal.kernel.exception.SystemException {
2842                    getPersistence().removeByC_U(companyId, userId);
2843            }
2844    
2845            /**
2846            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; from the database.
2847            *
2848            * @param companyId the company ID to search with
2849            * @param displayDate the display date to search with
2850            * @throws SystemException if a system exception occurred
2851            */
2852            public static void removeByC_LtD(long companyId, java.util.Date displayDate)
2853                    throws com.liferay.portal.kernel.exception.SystemException {
2854                    getPersistence().removeByC_LtD(companyId, displayDate);
2855            }
2856    
2857            /**
2858            * Removes all the blogs entries where companyId = &#63; and status = &#63; from the database.
2859            *
2860            * @param companyId the company ID to search with
2861            * @param status the status to search with
2862            * @throws SystemException if a system exception occurred
2863            */
2864            public static void removeByC_S(long companyId, int status)
2865                    throws com.liferay.portal.kernel.exception.SystemException {
2866                    getPersistence().removeByC_S(companyId, status);
2867            }
2868    
2869            /**
2870            * Removes the blogs entry where groupId = &#63; and urlTitle = &#63; from the database.
2871            *
2872            * @param groupId the group ID to search with
2873            * @param urlTitle the url title to search with
2874            * @throws SystemException if a system exception occurred
2875            */
2876            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
2877                    throws com.liferay.portal.kernel.exception.SystemException,
2878                            com.liferay.portlet.blogs.NoSuchEntryException {
2879                    getPersistence().removeByG_UT(groupId, urlTitle);
2880            }
2881    
2882            /**
2883            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; from the database.
2884            *
2885            * @param groupId the group ID to search with
2886            * @param displayDate the display date to search with
2887            * @throws SystemException if a system exception occurred
2888            */
2889            public static void removeByG_LtD(long groupId, java.util.Date displayDate)
2890                    throws com.liferay.portal.kernel.exception.SystemException {
2891                    getPersistence().removeByG_LtD(groupId, displayDate);
2892            }
2893    
2894            /**
2895            * Removes all the blogs entries where groupId = &#63; and status = &#63; from the database.
2896            *
2897            * @param groupId the group ID to search with
2898            * @param status the status to search with
2899            * @throws SystemException if a system exception occurred
2900            */
2901            public static void removeByG_S(long groupId, int status)
2902                    throws com.liferay.portal.kernel.exception.SystemException {
2903                    getPersistence().removeByG_S(groupId, status);
2904            }
2905    
2906            /**
2907            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63; from the database.
2908            *
2909            * @param companyId the company ID to search with
2910            * @param userId the user ID to search with
2911            * @param status the status to search with
2912            * @throws SystemException if a system exception occurred
2913            */
2914            public static void removeByC_U_S(long companyId, long userId, int status)
2915                    throws com.liferay.portal.kernel.exception.SystemException {
2916                    getPersistence().removeByC_U_S(companyId, userId, status);
2917            }
2918    
2919            /**
2920            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2921            *
2922            * @param companyId the company ID to search with
2923            * @param displayDate the display date to search with
2924            * @param status the status to search with
2925            * @throws SystemException if a system exception occurred
2926            */
2927            public static void removeByC_LtD_S(long companyId,
2928                    java.util.Date displayDate, int status)
2929                    throws com.liferay.portal.kernel.exception.SystemException {
2930                    getPersistence().removeByC_LtD_S(companyId, displayDate, status);
2931            }
2932    
2933            /**
2934            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; from the database.
2935            *
2936            * @param groupId the group ID to search with
2937            * @param userId the user ID to search with
2938            * @param displayDate the display date to search with
2939            * @throws SystemException if a system exception occurred
2940            */
2941            public static void removeByG_U_LtD(long groupId, long userId,
2942                    java.util.Date displayDate)
2943                    throws com.liferay.portal.kernel.exception.SystemException {
2944                    getPersistence().removeByG_U_LtD(groupId, userId, displayDate);
2945            }
2946    
2947            /**
2948            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
2949            *
2950            * @param groupId the group ID to search with
2951            * @param userId the user ID to search with
2952            * @param status the status to search with
2953            * @throws SystemException if a system exception occurred
2954            */
2955            public static void removeByG_U_S(long groupId, long userId, int status)
2956                    throws com.liferay.portal.kernel.exception.SystemException {
2957                    getPersistence().removeByG_U_S(groupId, userId, status);
2958            }
2959    
2960            /**
2961            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2962            *
2963            * @param groupId the group ID to search with
2964            * @param displayDate the display date to search with
2965            * @param status the status to search with
2966            * @throws SystemException if a system exception occurred
2967            */
2968            public static void removeByG_LtD_S(long groupId,
2969                    java.util.Date displayDate, int status)
2970                    throws com.liferay.portal.kernel.exception.SystemException {
2971                    getPersistence().removeByG_LtD_S(groupId, displayDate, status);
2972            }
2973    
2974            /**
2975            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2976            *
2977            * @param groupId the group ID to search with
2978            * @param userId the user ID to search with
2979            * @param displayDate the display date to search with
2980            * @param status the status to search with
2981            * @throws SystemException if a system exception occurred
2982            */
2983            public static void removeByG_U_LtD_S(long groupId, long userId,
2984                    java.util.Date displayDate, int status)
2985                    throws com.liferay.portal.kernel.exception.SystemException {
2986                    getPersistence().removeByG_U_LtD_S(groupId, userId, displayDate, status);
2987            }
2988    
2989            /**
2990            * Removes all the blogs entries from the database.
2991            *
2992            * @throws SystemException if a system exception occurred
2993            */
2994            public static void removeAll()
2995                    throws com.liferay.portal.kernel.exception.SystemException {
2996                    getPersistence().removeAll();
2997            }
2998    
2999            /**
3000            * Counts all the blogs entries where uuid = &#63;.
3001            *
3002            * @param uuid the uuid to search with
3003            * @return the number of matching blogs entries
3004            * @throws SystemException if a system exception occurred
3005            */
3006            public static int countByUuid(java.lang.String uuid)
3007                    throws com.liferay.portal.kernel.exception.SystemException {
3008                    return getPersistence().countByUuid(uuid);
3009            }
3010    
3011            /**
3012            * Counts all the blogs entries where uuid = &#63; and groupId = &#63;.
3013            *
3014            * @param uuid the uuid to search with
3015            * @param groupId the group ID to search with
3016            * @return the number of matching blogs entries
3017            * @throws SystemException if a system exception occurred
3018            */
3019            public static int countByUUID_G(java.lang.String uuid, long groupId)
3020                    throws com.liferay.portal.kernel.exception.SystemException {
3021                    return getPersistence().countByUUID_G(uuid, groupId);
3022            }
3023    
3024            /**
3025            * Counts all the blogs entries where groupId = &#63;.
3026            *
3027            * @param groupId the group ID to search with
3028            * @return the number of matching blogs entries
3029            * @throws SystemException if a system exception occurred
3030            */
3031            public static int countByGroupId(long groupId)
3032                    throws com.liferay.portal.kernel.exception.SystemException {
3033                    return getPersistence().countByGroupId(groupId);
3034            }
3035    
3036            /**
3037            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63;.
3038            *
3039            * @param groupId the group ID to search with
3040            * @return the number of matching blogs entries that the user has permission to view
3041            * @throws SystemException if a system exception occurred
3042            */
3043            public static int filterCountByGroupId(long groupId)
3044                    throws com.liferay.portal.kernel.exception.SystemException {
3045                    return getPersistence().filterCountByGroupId(groupId);
3046            }
3047    
3048            /**
3049            * Counts all the blogs entries where companyId = &#63;.
3050            *
3051            * @param companyId the company ID to search with
3052            * @return the number of matching blogs entries
3053            * @throws SystemException if a system exception occurred
3054            */
3055            public static int countByCompanyId(long companyId)
3056                    throws com.liferay.portal.kernel.exception.SystemException {
3057                    return getPersistence().countByCompanyId(companyId);
3058            }
3059    
3060            /**
3061            * Counts all the blogs entries where companyId = &#63; and userId = &#63;.
3062            *
3063            * @param companyId the company ID to search with
3064            * @param userId the user ID to search with
3065            * @return the number of matching blogs entries
3066            * @throws SystemException if a system exception occurred
3067            */
3068            public static int countByC_U(long companyId, long userId)
3069                    throws com.liferay.portal.kernel.exception.SystemException {
3070                    return getPersistence().countByC_U(companyId, userId);
3071            }
3072    
3073            /**
3074            * Counts all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
3075            *
3076            * @param companyId the company ID to search with
3077            * @param displayDate the display date to search with
3078            * @return the number of matching blogs entries
3079            * @throws SystemException if a system exception occurred
3080            */
3081            public static int countByC_LtD(long companyId, java.util.Date displayDate)
3082                    throws com.liferay.portal.kernel.exception.SystemException {
3083                    return getPersistence().countByC_LtD(companyId, displayDate);
3084            }
3085    
3086            /**
3087            * Counts all the blogs entries where companyId = &#63; and status = &#63;.
3088            *
3089            * @param companyId the company ID to search with
3090            * @param status the status to search with
3091            * @return the number of matching blogs entries
3092            * @throws SystemException if a system exception occurred
3093            */
3094            public static int countByC_S(long companyId, int status)
3095                    throws com.liferay.portal.kernel.exception.SystemException {
3096                    return getPersistence().countByC_S(companyId, status);
3097            }
3098    
3099            /**
3100            * Counts all the blogs entries where groupId = &#63; and urlTitle = &#63;.
3101            *
3102            * @param groupId the group ID to search with
3103            * @param urlTitle the url title to search with
3104            * @return the number of matching blogs entries
3105            * @throws SystemException if a system exception occurred
3106            */
3107            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3108                    throws com.liferay.portal.kernel.exception.SystemException {
3109                    return getPersistence().countByG_UT(groupId, urlTitle);
3110            }
3111    
3112            /**
3113            * Counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
3114            *
3115            * @param groupId the group ID to search with
3116            * @param displayDate the display date to search with
3117            * @return the number of matching blogs entries
3118            * @throws SystemException if a system exception occurred
3119            */
3120            public static int countByG_LtD(long groupId, java.util.Date displayDate)
3121                    throws com.liferay.portal.kernel.exception.SystemException {
3122                    return getPersistence().countByG_LtD(groupId, displayDate);
3123            }
3124    
3125            /**
3126            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
3127            *
3128            * @param groupId the group ID to search with
3129            * @param displayDate the display date to search with
3130            * @return the number of matching blogs entries that the user has permission to view
3131            * @throws SystemException if a system exception occurred
3132            */
3133            public static int filterCountByG_LtD(long groupId,
3134                    java.util.Date displayDate)
3135                    throws com.liferay.portal.kernel.exception.SystemException {
3136                    return getPersistence().filterCountByG_LtD(groupId, displayDate);
3137            }
3138    
3139            /**
3140            * Counts all the blogs entries where groupId = &#63; and status = &#63;.
3141            *
3142            * @param groupId the group ID to search with
3143            * @param status the status to search with
3144            * @return the number of matching blogs entries
3145            * @throws SystemException if a system exception occurred
3146            */
3147            public static int countByG_S(long groupId, int status)
3148                    throws com.liferay.portal.kernel.exception.SystemException {
3149                    return getPersistence().countByG_S(groupId, status);
3150            }
3151    
3152            /**
3153            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and status = &#63;.
3154            *
3155            * @param groupId the group ID to search with
3156            * @param status the status to search with
3157            * @return the number of matching blogs entries that the user has permission to view
3158            * @throws SystemException if a system exception occurred
3159            */
3160            public static int filterCountByG_S(long groupId, int status)
3161                    throws com.liferay.portal.kernel.exception.SystemException {
3162                    return getPersistence().filterCountByG_S(groupId, status);
3163            }
3164    
3165            /**
3166            * Counts all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
3167            *
3168            * @param companyId the company ID to search with
3169            * @param userId the user ID to search with
3170            * @param status the status to search with
3171            * @return the number of matching blogs entries
3172            * @throws SystemException if a system exception occurred
3173            */
3174            public static int countByC_U_S(long companyId, long userId, int status)
3175                    throws com.liferay.portal.kernel.exception.SystemException {
3176                    return getPersistence().countByC_U_S(companyId, userId, status);
3177            }
3178    
3179            /**
3180            * Counts all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3181            *
3182            * @param companyId the company ID to search with
3183            * @param displayDate the display date to search with
3184            * @param status the status to search with
3185            * @return the number of matching blogs entries
3186            * @throws SystemException if a system exception occurred
3187            */
3188            public static int countByC_LtD_S(long companyId,
3189                    java.util.Date displayDate, int status)
3190                    throws com.liferay.portal.kernel.exception.SystemException {
3191                    return getPersistence().countByC_LtD_S(companyId, displayDate, status);
3192            }
3193    
3194            /**
3195            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3196            *
3197            * @param groupId the group ID to search with
3198            * @param userId the user ID to search with
3199            * @param displayDate the display date to search with
3200            * @return the number of matching blogs entries
3201            * @throws SystemException if a system exception occurred
3202            */
3203            public static int countByG_U_LtD(long groupId, long userId,
3204                    java.util.Date displayDate)
3205                    throws com.liferay.portal.kernel.exception.SystemException {
3206                    return getPersistence().countByG_U_LtD(groupId, userId, displayDate);
3207            }
3208    
3209            /**
3210            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3211            *
3212            * @param groupId the group ID to search with
3213            * @param userId the user ID to search with
3214            * @param displayDate the display date to search with
3215            * @return the number of matching blogs entries that the user has permission to view
3216            * @throws SystemException if a system exception occurred
3217            */
3218            public static int filterCountByG_U_LtD(long groupId, long userId,
3219                    java.util.Date displayDate)
3220                    throws com.liferay.portal.kernel.exception.SystemException {
3221                    return getPersistence()
3222                                       .filterCountByG_U_LtD(groupId, userId, displayDate);
3223            }
3224    
3225            /**
3226            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3227            *
3228            * @param groupId the group ID to search with
3229            * @param userId the user ID to search with
3230            * @param status the status to search with
3231            * @return the number of matching blogs entries
3232            * @throws SystemException if a system exception occurred
3233            */
3234            public static int countByG_U_S(long groupId, long userId, int status)
3235                    throws com.liferay.portal.kernel.exception.SystemException {
3236                    return getPersistence().countByG_U_S(groupId, userId, status);
3237            }
3238    
3239            /**
3240            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3241            *
3242            * @param groupId the group ID to search with
3243            * @param userId the user ID to search with
3244            * @param status the status to search with
3245            * @return the number of matching blogs entries that the user has permission to view
3246            * @throws SystemException if a system exception occurred
3247            */
3248            public static int filterCountByG_U_S(long groupId, long userId, int status)
3249                    throws com.liferay.portal.kernel.exception.SystemException {
3250                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
3251            }
3252    
3253            /**
3254            * Counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
3255            *
3256            * @param groupId the group ID to search with
3257            * @param displayDate the display date to search with
3258            * @param status the status to search with
3259            * @return the number of matching blogs entries
3260            * @throws SystemException if a system exception occurred
3261            */
3262            public static int countByG_LtD_S(long groupId, java.util.Date displayDate,
3263                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3264                    return getPersistence().countByG_LtD_S(groupId, displayDate, status);
3265            }
3266    
3267            /**
3268            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
3269            *
3270            * @param groupId the group ID to search with
3271            * @param displayDate the display date to search with
3272            * @param status the status to search with
3273            * @return the number of matching blogs entries that the user has permission to view
3274            * @throws SystemException if a system exception occurred
3275            */
3276            public static int filterCountByG_LtD_S(long groupId,
3277                    java.util.Date displayDate, int status)
3278                    throws com.liferay.portal.kernel.exception.SystemException {
3279                    return getPersistence()
3280                                       .filterCountByG_LtD_S(groupId, displayDate, status);
3281            }
3282    
3283            /**
3284            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
3285            *
3286            * @param groupId the group ID to search with
3287            * @param userId the user ID to search with
3288            * @param displayDate the display date to search with
3289            * @param status the status to search with
3290            * @return the number of matching blogs entries
3291            * @throws SystemException if a system exception occurred
3292            */
3293            public static int countByG_U_LtD_S(long groupId, long userId,
3294                    java.util.Date displayDate, int status)
3295                    throws com.liferay.portal.kernel.exception.SystemException {
3296                    return getPersistence()
3297                                       .countByG_U_LtD_S(groupId, userId, displayDate, status);
3298            }
3299    
3300            /**
3301            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
3302            *
3303            * @param groupId the group ID to search with
3304            * @param userId the user ID to search with
3305            * @param displayDate the display date to search with
3306            * @param status the status to search with
3307            * @return the number of matching blogs entries that the user has permission to view
3308            * @throws SystemException if a system exception occurred
3309            */
3310            public static int filterCountByG_U_LtD_S(long groupId, long userId,
3311                    java.util.Date displayDate, int status)
3312                    throws com.liferay.portal.kernel.exception.SystemException {
3313                    return getPersistence()
3314                                       .filterCountByG_U_LtD_S(groupId, userId, displayDate, status);
3315            }
3316    
3317            /**
3318            * Counts all the blogs entries.
3319            *
3320            * @return the number of blogs entries
3321            * @throws SystemException if a system exception occurred
3322            */
3323            public static int countAll()
3324                    throws com.liferay.portal.kernel.exception.SystemException {
3325                    return getPersistence().countAll();
3326            }
3327    
3328            public static BlogsEntryPersistence getPersistence() {
3329                    if (_persistence == null) {
3330                            _persistence = (BlogsEntryPersistence)PortalBeanLocatorUtil.locate(BlogsEntryPersistence.class.getName());
3331    
3332                            ReferenceRegistry.registerReference(BlogsEntryUtil.class,
3333                                    "_persistence");
3334                    }
3335    
3336                    return _persistence;
3337            }
3338    
3339            public void setPersistence(BlogsEntryPersistence persistence) {
3340                    _persistence = persistence;
3341    
3342                    ReferenceRegistry.registerReference(BlogsEntryUtil.class, "_persistence");
3343            }
3344    
3345            private static BlogsEntryPersistence _persistence;
3346    }