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