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