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