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