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