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