001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.messageboards.model.MBMessage;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the message-boards message service. This utility wraps {@link MBMessagePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see MBMessagePersistence
037     * @see MBMessagePersistenceImpl
038     * @generated
039     */
040    public class MBMessageUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(MBMessage mbMessage) {
058                    getPersistence().clearCache(mbMessage);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<MBMessage> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<MBMessage> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<MBMessage> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static MBMessage update(MBMessage mbMessage)
101                    throws SystemException {
102                    return getPersistence().update(mbMessage);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static MBMessage update(MBMessage mbMessage,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(mbMessage, serviceContext);
111            }
112    
113            /**
114            * Returns all the message-boards messages where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching message-boards messages
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the message-boards messages where uuid = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of message-boards messages
135            * @param end the upper bound of the range of message-boards messages (not inclusive)
136            * @return the range of matching message-boards messages
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the message-boards messages where uuid = &#63;.
147            *
148            * <p>
149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of message-boards messages
154            * @param end the upper bound of the range of message-boards messages (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching message-boards messages
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first message-boards message in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching message-boards message
172            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.messageboards.NoSuchMessageException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first message-boards message in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last message-boards message in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching message-boards message
204            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.messageboards.NoSuchMessageException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last message-boards message in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the message-boards messages before and after the current message-boards message in the ordered set where uuid = &#63;.
232            *
233            * @param messageId the primary key of the current message-boards message
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next message-boards message
237            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.messageboards.model.MBMessage[] findByUuid_PrevAndNext(
241                    long messageId, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.messageboards.NoSuchMessageException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(messageId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the message-boards messages where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of message-boards messages where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching message-boards messages
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * Returns the message-boards message where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchMessageException} if it could not be found.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching message-boards message
278            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.messageboards.model.MBMessage findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.messageboards.NoSuchMessageException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * 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.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * 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.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the message-boards message where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the message-boards message that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.messageboards.model.MBMessage removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.messageboards.NoSuchMessageException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of message-boards messages where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching message-boards messages
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the message-boards messages where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching message-boards messages
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the message-boards messages where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of message-boards messages
369            * @param end the upper bound of the range of message-boards messages (not inclusive)
370            * @return the range of matching message-boards messages
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the message-boards messages where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of message-boards messages
389            * @param end the upper bound of the range of message-boards messages (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching message-boards messages
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching message-boards message
409            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.messageboards.NoSuchMessageException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching message-boards message
445            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.messageboards.NoSuchMessageException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the message-boards messages before and after the current message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param messageId the primary key of the current message-boards message
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next message-boards message
482            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.messageboards.model.MBMessage[] findByUuid_C_PrevAndNext(
486                    long messageId, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.messageboards.NoSuchMessageException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(messageId, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the message-boards messages where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of message-boards messages where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching message-boards messages
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the message-boards messages where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @return the matching message-boards messages
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
528                    long groupId)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByGroupId(groupId);
531            }
532    
533            /**
534            * Returns a range of all the message-boards messages where groupId = &#63;.
535            *
536            * <p>
537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
538            * </p>
539            *
540            * @param groupId the group ID
541            * @param start the lower bound of the range of message-boards messages
542            * @param end the upper bound of the range of message-boards messages (not inclusive)
543            * @return the range of matching message-boards messages
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
547                    long groupId, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence().findByGroupId(groupId, start, end);
550            }
551    
552            /**
553            * Returns an ordered range of all the message-boards messages where groupId = &#63;.
554            *
555            * <p>
556            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
557            * </p>
558            *
559            * @param groupId the group ID
560            * @param start the lower bound of the range of message-boards messages
561            * @param end the upper bound of the range of message-boards messages (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the ordered range of matching message-boards messages
564            * @throws SystemException if a system exception occurred
565            */
566            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
567                    long groupId, int start, int end,
568                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
569                    throws com.liferay.portal.kernel.exception.SystemException {
570                    return getPersistence()
571                                       .findByGroupId(groupId, start, end, orderByComparator);
572            }
573    
574            /**
575            * Returns the first message-boards message in the ordered set where groupId = &#63;.
576            *
577            * @param groupId the group ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching message-boards message
580            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_First(
584                    long groupId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.messageboards.NoSuchMessageException {
588                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
589            }
590    
591            /**
592            * Returns the first message-boards message in the ordered set where groupId = &#63;.
593            *
594            * @param groupId the group ID
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
597            * @throws SystemException if a system exception occurred
598            */
599            public static com.liferay.portlet.messageboards.model.MBMessage fetchByGroupId_First(
600                    long groupId,
601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
602                    throws com.liferay.portal.kernel.exception.SystemException {
603                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
604            }
605    
606            /**
607            * Returns the last message-boards message in the ordered set where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching message-boards message
612            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_Last(
616                    long groupId,
617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
618                    throws com.liferay.portal.kernel.exception.SystemException,
619                            com.liferay.portlet.messageboards.NoSuchMessageException {
620                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
621            }
622    
623            /**
624            * Returns the last message-boards message in the ordered set where groupId = &#63;.
625            *
626            * @param groupId the group ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
629            * @throws SystemException if a system exception occurred
630            */
631            public static com.liferay.portlet.messageboards.model.MBMessage fetchByGroupId_Last(
632                    long groupId,
633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
634                    throws com.liferay.portal.kernel.exception.SystemException {
635                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
636            }
637    
638            /**
639            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63;.
640            *
641            * @param messageId the primary key of the current message-boards message
642            * @param groupId the group ID
643            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
644            * @return the previous, current, and next message-boards message
645            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
646            * @throws SystemException if a system exception occurred
647            */
648            public static com.liferay.portlet.messageboards.model.MBMessage[] findByGroupId_PrevAndNext(
649                    long messageId, long groupId,
650                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
651                    throws com.liferay.portal.kernel.exception.SystemException,
652                            com.liferay.portlet.messageboards.NoSuchMessageException {
653                    return getPersistence()
654                                       .findByGroupId_PrevAndNext(messageId, groupId,
655                            orderByComparator);
656            }
657    
658            /**
659            * Returns all the message-boards messages that the user has permission to view where groupId = &#63;.
660            *
661            * @param groupId the group ID
662            * @return the matching message-boards messages that the user has permission to view
663            * @throws SystemException if a system exception occurred
664            */
665            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
666                    long groupId)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    return getPersistence().filterFindByGroupId(groupId);
669            }
670    
671            /**
672            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
676            * </p>
677            *
678            * @param groupId the group ID
679            * @param start the lower bound of the range of message-boards messages
680            * @param end the upper bound of the range of message-boards messages (not inclusive)
681            * @return the range of matching message-boards messages that the user has permission to view
682            * @throws SystemException if a system exception occurred
683            */
684            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
685                    long groupId, int start, int end)
686                    throws com.liferay.portal.kernel.exception.SystemException {
687                    return getPersistence().filterFindByGroupId(groupId, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63;.
692            *
693            * <p>
694            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
695            * </p>
696            *
697            * @param groupId the group ID
698            * @param start the lower bound of the range of message-boards messages
699            * @param end the upper bound of the range of message-boards messages (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @return the ordered range of matching message-boards messages that the user has permission to view
702            * @throws SystemException if a system exception occurred
703            */
704            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
705                    long groupId, int start, int end,
706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
707                    throws com.liferay.portal.kernel.exception.SystemException {
708                    return getPersistence()
709                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
710            }
711    
712            /**
713            * 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;.
714            *
715            * @param messageId the primary key of the current message-boards message
716            * @param groupId the group ID
717            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
718            * @return the previous, current, and next message-boards message
719            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByGroupId_PrevAndNext(
723                    long messageId, long groupId,
724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
725                    throws com.liferay.portal.kernel.exception.SystemException,
726                            com.liferay.portlet.messageboards.NoSuchMessageException {
727                    return getPersistence()
728                                       .filterFindByGroupId_PrevAndNext(messageId, groupId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Removes all the message-boards messages where groupId = &#63; from the database.
734            *
735            * @param groupId the group ID
736            * @throws SystemException if a system exception occurred
737            */
738            public static void removeByGroupId(long groupId)
739                    throws com.liferay.portal.kernel.exception.SystemException {
740                    getPersistence().removeByGroupId(groupId);
741            }
742    
743            /**
744            * Returns the number of message-boards messages where groupId = &#63;.
745            *
746            * @param groupId the group ID
747            * @return the number of matching message-boards messages
748            * @throws SystemException if a system exception occurred
749            */
750            public static int countByGroupId(long groupId)
751                    throws com.liferay.portal.kernel.exception.SystemException {
752                    return getPersistence().countByGroupId(groupId);
753            }
754    
755            /**
756            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63;.
757            *
758            * @param groupId the group ID
759            * @return the number of matching message-boards messages that the user has permission to view
760            * @throws SystemException if a system exception occurred
761            */
762            public static int filterCountByGroupId(long groupId)
763                    throws com.liferay.portal.kernel.exception.SystemException {
764                    return getPersistence().filterCountByGroupId(groupId);
765            }
766    
767            /**
768            * Returns all the message-boards messages where companyId = &#63;.
769            *
770            * @param companyId the company ID
771            * @return the matching message-boards messages
772            * @throws SystemException if a system exception occurred
773            */
774            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
775                    long companyId)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().findByCompanyId(companyId);
778            }
779    
780            /**
781            * Returns a range of all the message-boards messages where companyId = &#63;.
782            *
783            * <p>
784            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
785            * </p>
786            *
787            * @param companyId the company ID
788            * @param start the lower bound of the range of message-boards messages
789            * @param end the upper bound of the range of message-boards messages (not inclusive)
790            * @return the range of matching message-boards messages
791            * @throws SystemException if a system exception occurred
792            */
793            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
794                    long companyId, int start, int end)
795                    throws com.liferay.portal.kernel.exception.SystemException {
796                    return getPersistence().findByCompanyId(companyId, start, end);
797            }
798    
799            /**
800            * Returns an ordered range of all the message-boards messages where companyId = &#63;.
801            *
802            * <p>
803            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
804            * </p>
805            *
806            * @param companyId the company ID
807            * @param start the lower bound of the range of message-boards messages
808            * @param end the upper bound of the range of message-boards messages (not inclusive)
809            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
810            * @return the ordered range of matching message-boards messages
811            * @throws SystemException if a system exception occurred
812            */
813            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
814                    long companyId, int start, int end,
815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
816                    throws com.liferay.portal.kernel.exception.SystemException {
817                    return getPersistence()
818                                       .findByCompanyId(companyId, start, end, orderByComparator);
819            }
820    
821            /**
822            * Returns the first message-boards message in the ordered set where companyId = &#63;.
823            *
824            * @param companyId the company ID
825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
826            * @return the first matching message-boards message
827            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
828            * @throws SystemException if a system exception occurred
829            */
830            public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_First(
831                    long companyId,
832                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
833                    throws com.liferay.portal.kernel.exception.SystemException,
834                            com.liferay.portlet.messageboards.NoSuchMessageException {
835                    return getPersistence()
836                                       .findByCompanyId_First(companyId, orderByComparator);
837            }
838    
839            /**
840            * Returns the first message-boards message in the ordered set where companyId = &#63;.
841            *
842            * @param companyId the company ID
843            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
844            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
845            * @throws SystemException if a system exception occurred
846            */
847            public static com.liferay.portlet.messageboards.model.MBMessage fetchByCompanyId_First(
848                    long companyId,
849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
850                    throws com.liferay.portal.kernel.exception.SystemException {
851                    return getPersistence()
852                                       .fetchByCompanyId_First(companyId, orderByComparator);
853            }
854    
855            /**
856            * Returns the last message-boards message in the ordered set where companyId = &#63;.
857            *
858            * @param companyId the company ID
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the last matching message-boards message
861            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_Last(
865                    long companyId,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.kernel.exception.SystemException,
868                            com.liferay.portlet.messageboards.NoSuchMessageException {
869                    return getPersistence()
870                                       .findByCompanyId_Last(companyId, orderByComparator);
871            }
872    
873            /**
874            * Returns the last message-boards message in the ordered set where companyId = &#63;.
875            *
876            * @param companyId the company ID
877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
878            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
879            * @throws SystemException if a system exception occurred
880            */
881            public static com.liferay.portlet.messageboards.model.MBMessage fetchByCompanyId_Last(
882                    long companyId,
883                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
884                    throws com.liferay.portal.kernel.exception.SystemException {
885                    return getPersistence()
886                                       .fetchByCompanyId_Last(companyId, orderByComparator);
887            }
888    
889            /**
890            * Returns the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63;.
891            *
892            * @param messageId the primary key of the current message-boards message
893            * @param companyId the company ID
894            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
895            * @return the previous, current, and next message-boards message
896            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
897            * @throws SystemException if a system exception occurred
898            */
899            public static com.liferay.portlet.messageboards.model.MBMessage[] findByCompanyId_PrevAndNext(
900                    long messageId, long companyId,
901                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
902                    throws com.liferay.portal.kernel.exception.SystemException,
903                            com.liferay.portlet.messageboards.NoSuchMessageException {
904                    return getPersistence()
905                                       .findByCompanyId_PrevAndNext(messageId, companyId,
906                            orderByComparator);
907            }
908    
909            /**
910            * Removes all the message-boards messages where companyId = &#63; from the database.
911            *
912            * @param companyId the company ID
913            * @throws SystemException if a system exception occurred
914            */
915            public static void removeByCompanyId(long companyId)
916                    throws com.liferay.portal.kernel.exception.SystemException {
917                    getPersistence().removeByCompanyId(companyId);
918            }
919    
920            /**
921            * Returns the number of message-boards messages where companyId = &#63;.
922            *
923            * @param companyId the company ID
924            * @return the number of matching message-boards messages
925            * @throws SystemException if a system exception occurred
926            */
927            public static int countByCompanyId(long companyId)
928                    throws com.liferay.portal.kernel.exception.SystemException {
929                    return getPersistence().countByCompanyId(companyId);
930            }
931    
932            /**
933            * Returns all the message-boards messages where threadId = &#63;.
934            *
935            * @param threadId the thread ID
936            * @return the matching message-boards messages
937            * @throws SystemException if a system exception occurred
938            */
939            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
940                    long threadId)
941                    throws com.liferay.portal.kernel.exception.SystemException {
942                    return getPersistence().findByThreadId(threadId);
943            }
944    
945            /**
946            * Returns a range of all the message-boards messages where threadId = &#63;.
947            *
948            * <p>
949            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
950            * </p>
951            *
952            * @param threadId the thread ID
953            * @param start the lower bound of the range of message-boards messages
954            * @param end the upper bound of the range of message-boards messages (not inclusive)
955            * @return the range of matching message-boards messages
956            * @throws SystemException if a system exception occurred
957            */
958            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
959                    long threadId, int start, int end)
960                    throws com.liferay.portal.kernel.exception.SystemException {
961                    return getPersistence().findByThreadId(threadId, start, end);
962            }
963    
964            /**
965            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
966            *
967            * <p>
968            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
969            * </p>
970            *
971            * @param threadId the thread ID
972            * @param start the lower bound of the range of message-boards messages
973            * @param end the upper bound of the range of message-boards messages (not inclusive)
974            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
975            * @return the ordered range of matching message-boards messages
976            * @throws SystemException if a system exception occurred
977            */
978            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
979                    long threadId, int start, int end,
980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
981                    throws com.liferay.portal.kernel.exception.SystemException {
982                    return getPersistence()
983                                       .findByThreadId(threadId, start, end, orderByComparator);
984            }
985    
986            /**
987            * Returns the first message-boards message in the ordered set where threadId = &#63;.
988            *
989            * @param threadId the thread ID
990            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
991            * @return the first matching message-boards message
992            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
993            * @throws SystemException if a system exception occurred
994            */
995            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_First(
996                    long threadId,
997                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
998                    throws com.liferay.portal.kernel.exception.SystemException,
999                            com.liferay.portlet.messageboards.NoSuchMessageException {
1000                    return getPersistence().findByThreadId_First(threadId, orderByComparator);
1001            }
1002    
1003            /**
1004            * Returns the first message-boards message in the ordered set where threadId = &#63;.
1005            *
1006            * @param threadId the thread ID
1007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1008            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1009            * @throws SystemException if a system exception occurred
1010            */
1011            public static com.liferay.portlet.messageboards.model.MBMessage fetchByThreadId_First(
1012                    long threadId,
1013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1014                    throws com.liferay.portal.kernel.exception.SystemException {
1015                    return getPersistence()
1016                                       .fetchByThreadId_First(threadId, orderByComparator);
1017            }
1018    
1019            /**
1020            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1021            *
1022            * @param threadId the thread ID
1023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1024            * @return the last matching message-boards message
1025            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1026            * @throws SystemException if a system exception occurred
1027            */
1028            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_Last(
1029                    long threadId,
1030                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1031                    throws com.liferay.portal.kernel.exception.SystemException,
1032                            com.liferay.portlet.messageboards.NoSuchMessageException {
1033                    return getPersistence().findByThreadId_Last(threadId, orderByComparator);
1034            }
1035    
1036            /**
1037            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1038            *
1039            * @param threadId the thread ID
1040            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1041            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1042            * @throws SystemException if a system exception occurred
1043            */
1044            public static com.liferay.portlet.messageboards.model.MBMessage fetchByThreadId_Last(
1045                    long threadId,
1046                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1047                    throws com.liferay.portal.kernel.exception.SystemException {
1048                    return getPersistence().fetchByThreadId_Last(threadId, orderByComparator);
1049            }
1050    
1051            /**
1052            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
1053            *
1054            * @param messageId the primary key of the current message-boards message
1055            * @param threadId the thread ID
1056            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1057            * @return the previous, current, and next message-boards message
1058            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1059            * @throws SystemException if a system exception occurred
1060            */
1061            public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadId_PrevAndNext(
1062                    long messageId, long threadId,
1063                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1064                    throws com.liferay.portal.kernel.exception.SystemException,
1065                            com.liferay.portlet.messageboards.NoSuchMessageException {
1066                    return getPersistence()
1067                                       .findByThreadId_PrevAndNext(messageId, threadId,
1068                            orderByComparator);
1069            }
1070    
1071            /**
1072            * Removes all the message-boards messages where threadId = &#63; from the database.
1073            *
1074            * @param threadId the thread ID
1075            * @throws SystemException if a system exception occurred
1076            */
1077            public static void removeByThreadId(long threadId)
1078                    throws com.liferay.portal.kernel.exception.SystemException {
1079                    getPersistence().removeByThreadId(threadId);
1080            }
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            * @throws SystemException if a system exception occurred
1088            */
1089            public static int countByThreadId(long threadId)
1090                    throws com.liferay.portal.kernel.exception.SystemException {
1091                    return getPersistence().countByThreadId(threadId);
1092            }
1093    
1094            /**
1095            * Returns all the message-boards messages where threadId = &#63;.
1096            *
1097            * @param threadId the thread ID
1098            * @return the matching message-boards messages
1099            * @throws SystemException if a system exception occurred
1100            */
1101            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
1102                    long threadId)
1103                    throws com.liferay.portal.kernel.exception.SystemException {
1104                    return getPersistence().findByThreadReplies(threadId);
1105            }
1106    
1107            /**
1108            * Returns a range of all the message-boards messages where threadId = &#63;.
1109            *
1110            * <p>
1111            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1112            * </p>
1113            *
1114            * @param threadId the thread ID
1115            * @param start the lower bound of the range of message-boards messages
1116            * @param end the upper bound of the range of message-boards messages (not inclusive)
1117            * @return the range of matching message-boards messages
1118            * @throws SystemException if a system exception occurred
1119            */
1120            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
1121                    long threadId, int start, int end)
1122                    throws com.liferay.portal.kernel.exception.SystemException {
1123                    return getPersistence().findByThreadReplies(threadId, start, end);
1124            }
1125    
1126            /**
1127            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
1128            *
1129            * <p>
1130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1131            * </p>
1132            *
1133            * @param threadId the thread ID
1134            * @param start the lower bound of the range of message-boards messages
1135            * @param end the upper bound of the range of message-boards messages (not inclusive)
1136            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1137            * @return the ordered range of matching message-boards messages
1138            * @throws SystemException if a system exception occurred
1139            */
1140            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
1141                    long threadId, int start, int end,
1142                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1143                    throws com.liferay.portal.kernel.exception.SystemException {
1144                    return getPersistence()
1145                                       .findByThreadReplies(threadId, start, end, orderByComparator);
1146            }
1147    
1148            /**
1149            * Returns the first message-boards message in the ordered set where threadId = &#63;.
1150            *
1151            * @param threadId the thread ID
1152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1153            * @return the first matching message-boards message
1154            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1155            * @throws SystemException if a system exception occurred
1156            */
1157            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_First(
1158                    long threadId,
1159                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1160                    throws com.liferay.portal.kernel.exception.SystemException,
1161                            com.liferay.portlet.messageboards.NoSuchMessageException {
1162                    return getPersistence()
1163                                       .findByThreadReplies_First(threadId, orderByComparator);
1164            }
1165    
1166            /**
1167            * Returns the first message-boards message in the ordered set where threadId = &#63;.
1168            *
1169            * @param threadId the thread ID
1170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1171            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1172            * @throws SystemException if a system exception occurred
1173            */
1174            public static com.liferay.portlet.messageboards.model.MBMessage fetchByThreadReplies_First(
1175                    long threadId,
1176                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1177                    throws com.liferay.portal.kernel.exception.SystemException {
1178                    return getPersistence()
1179                                       .fetchByThreadReplies_First(threadId, orderByComparator);
1180            }
1181    
1182            /**
1183            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1184            *
1185            * @param threadId the thread ID
1186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1187            * @return the last matching message-boards message
1188            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_Last(
1192                    long threadId,
1193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1194                    throws com.liferay.portal.kernel.exception.SystemException,
1195                            com.liferay.portlet.messageboards.NoSuchMessageException {
1196                    return getPersistence()
1197                                       .findByThreadReplies_Last(threadId, orderByComparator);
1198            }
1199    
1200            /**
1201            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1202            *
1203            * @param threadId the thread ID
1204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1205            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1206            * @throws SystemException if a system exception occurred
1207            */
1208            public static com.liferay.portlet.messageboards.model.MBMessage fetchByThreadReplies_Last(
1209                    long threadId,
1210                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1211                    throws com.liferay.portal.kernel.exception.SystemException {
1212                    return getPersistence()
1213                                       .fetchByThreadReplies_Last(threadId, orderByComparator);
1214            }
1215    
1216            /**
1217            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
1218            *
1219            * @param messageId the primary key of the current message-boards message
1220            * @param threadId the thread ID
1221            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1222            * @return the previous, current, and next message-boards message
1223            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1224            * @throws SystemException if a system exception occurred
1225            */
1226            public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadReplies_PrevAndNext(
1227                    long messageId, long threadId,
1228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1229                    throws com.liferay.portal.kernel.exception.SystemException,
1230                            com.liferay.portlet.messageboards.NoSuchMessageException {
1231                    return getPersistence()
1232                                       .findByThreadReplies_PrevAndNext(messageId, threadId,
1233                            orderByComparator);
1234            }
1235    
1236            /**
1237            * Removes all the message-boards messages where threadId = &#63; from the database.
1238            *
1239            * @param threadId the thread ID
1240            * @throws SystemException if a system exception occurred
1241            */
1242            public static void removeByThreadReplies(long threadId)
1243                    throws com.liferay.portal.kernel.exception.SystemException {
1244                    getPersistence().removeByThreadReplies(threadId);
1245            }
1246    
1247            /**
1248            * Returns the number of message-boards messages where threadId = &#63;.
1249            *
1250            * @param threadId the thread ID
1251            * @return the number of matching message-boards messages
1252            * @throws SystemException if a system exception occurred
1253            */
1254            public static int countByThreadReplies(long threadId)
1255                    throws com.liferay.portal.kernel.exception.SystemException {
1256                    return getPersistence().countByThreadReplies(threadId);
1257            }
1258    
1259            /**
1260            * Returns all the message-boards messages where userId = &#63;.
1261            *
1262            * @param userId the user ID
1263            * @return the matching message-boards messages
1264            * @throws SystemException if a system exception occurred
1265            */
1266            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
1267                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
1268                    return getPersistence().findByUserId(userId);
1269            }
1270    
1271            /**
1272            * Returns a range of all the message-boards messages where userId = &#63;.
1273            *
1274            * <p>
1275            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1276            * </p>
1277            *
1278            * @param userId the user ID
1279            * @param start the lower bound of the range of message-boards messages
1280            * @param end the upper bound of the range of message-boards messages (not inclusive)
1281            * @return the range of matching message-boards messages
1282            * @throws SystemException if a system exception occurred
1283            */
1284            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
1285                    long userId, int start, int end)
1286                    throws com.liferay.portal.kernel.exception.SystemException {
1287                    return getPersistence().findByUserId(userId, start, end);
1288            }
1289    
1290            /**
1291            * Returns an ordered range of all the message-boards messages where userId = &#63;.
1292            *
1293            * <p>
1294            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1295            * </p>
1296            *
1297            * @param userId the user ID
1298            * @param start the lower bound of the range of message-boards messages
1299            * @param end the upper bound of the range of message-boards messages (not inclusive)
1300            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1301            * @return the ordered range of matching message-boards messages
1302            * @throws SystemException if a system exception occurred
1303            */
1304            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
1305                    long userId, int start, int end,
1306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1307                    throws com.liferay.portal.kernel.exception.SystemException {
1308                    return getPersistence()
1309                                       .findByUserId(userId, start, end, orderByComparator);
1310            }
1311    
1312            /**
1313            * Returns the first message-boards message in the ordered set where userId = &#63;.
1314            *
1315            * @param userId the user ID
1316            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1317            * @return the first matching message-boards message
1318            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1319            * @throws SystemException if a system exception occurred
1320            */
1321            public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_First(
1322                    long userId,
1323                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1324                    throws com.liferay.portal.kernel.exception.SystemException,
1325                            com.liferay.portlet.messageboards.NoSuchMessageException {
1326                    return getPersistence().findByUserId_First(userId, orderByComparator);
1327            }
1328    
1329            /**
1330            * Returns the first message-boards message in the ordered set where userId = &#63;.
1331            *
1332            * @param userId the user ID
1333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1334            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1335            * @throws SystemException if a system exception occurred
1336            */
1337            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUserId_First(
1338                    long userId,
1339                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1340                    throws com.liferay.portal.kernel.exception.SystemException {
1341                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
1342            }
1343    
1344            /**
1345            * Returns the last message-boards message in the ordered set where userId = &#63;.
1346            *
1347            * @param userId the user ID
1348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1349            * @return the last matching message-boards message
1350            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1351            * @throws SystemException if a system exception occurred
1352            */
1353            public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_Last(
1354                    long userId,
1355                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1356                    throws com.liferay.portal.kernel.exception.SystemException,
1357                            com.liferay.portlet.messageboards.NoSuchMessageException {
1358                    return getPersistence().findByUserId_Last(userId, orderByComparator);
1359            }
1360    
1361            /**
1362            * Returns the last message-boards message in the ordered set where userId = &#63;.
1363            *
1364            * @param userId the user ID
1365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1366            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1367            * @throws SystemException if a system exception occurred
1368            */
1369            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUserId_Last(
1370                    long userId,
1371                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1372                    throws com.liferay.portal.kernel.exception.SystemException {
1373                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
1374            }
1375    
1376            /**
1377            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63;.
1378            *
1379            * @param messageId the primary key of the current message-boards message
1380            * @param userId the user ID
1381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1382            * @return the previous, current, and next message-boards message
1383            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1384            * @throws SystemException if a system exception occurred
1385            */
1386            public static com.liferay.portlet.messageboards.model.MBMessage[] findByUserId_PrevAndNext(
1387                    long messageId, long userId,
1388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1389                    throws com.liferay.portal.kernel.exception.SystemException,
1390                            com.liferay.portlet.messageboards.NoSuchMessageException {
1391                    return getPersistence()
1392                                       .findByUserId_PrevAndNext(messageId, userId,
1393                            orderByComparator);
1394            }
1395    
1396            /**
1397            * Removes all the message-boards messages where userId = &#63; from the database.
1398            *
1399            * @param userId the user ID
1400            * @throws SystemException if a system exception occurred
1401            */
1402            public static void removeByUserId(long userId)
1403                    throws com.liferay.portal.kernel.exception.SystemException {
1404                    getPersistence().removeByUserId(userId);
1405            }
1406    
1407            /**
1408            * Returns the number of message-boards messages where userId = &#63;.
1409            *
1410            * @param userId the user ID
1411            * @return the number of matching message-boards messages
1412            * @throws SystemException if a system exception occurred
1413            */
1414            public static int countByUserId(long userId)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    return getPersistence().countByUserId(userId);
1417            }
1418    
1419            /**
1420            * Returns all the message-boards messages where groupId = &#63; and userId = &#63;.
1421            *
1422            * @param groupId the group ID
1423            * @param userId the user ID
1424            * @return the matching message-boards messages
1425            * @throws SystemException if a system exception occurred
1426            */
1427            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1428                    long groupId, long userId)
1429                    throws com.liferay.portal.kernel.exception.SystemException {
1430                    return getPersistence().findByG_U(groupId, userId);
1431            }
1432    
1433            /**
1434            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1435            *
1436            * <p>
1437            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1438            * </p>
1439            *
1440            * @param groupId the group ID
1441            * @param userId the user ID
1442            * @param start the lower bound of the range of message-boards messages
1443            * @param end the upper bound of the range of message-boards messages (not inclusive)
1444            * @return the range of matching message-boards messages
1445            * @throws SystemException if a system exception occurred
1446            */
1447            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1448                    long groupId, long userId, int start, int end)
1449                    throws com.liferay.portal.kernel.exception.SystemException {
1450                    return getPersistence().findByG_U(groupId, userId, start, end);
1451            }
1452    
1453            /**
1454            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1455            *
1456            * <p>
1457            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1458            * </p>
1459            *
1460            * @param groupId the group ID
1461            * @param userId the user ID
1462            * @param start the lower bound of the range of message-boards messages
1463            * @param end the upper bound of the range of message-boards messages (not inclusive)
1464            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1465            * @return the ordered range of matching message-boards messages
1466            * @throws SystemException if a system exception occurred
1467            */
1468            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1469                    long groupId, long userId, int start, int end,
1470                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1471                    throws com.liferay.portal.kernel.exception.SystemException {
1472                    return getPersistence()
1473                                       .findByG_U(groupId, userId, start, end, orderByComparator);
1474            }
1475    
1476            /**
1477            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1478            *
1479            * @param groupId the group ID
1480            * @param userId the user ID
1481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1482            * @return the first matching message-boards message
1483            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1484            * @throws SystemException if a system exception occurred
1485            */
1486            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_First(
1487                    long groupId, long userId,
1488                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1489                    throws com.liferay.portal.kernel.exception.SystemException,
1490                            com.liferay.portlet.messageboards.NoSuchMessageException {
1491                    return getPersistence()
1492                                       .findByG_U_First(groupId, userId, orderByComparator);
1493            }
1494    
1495            /**
1496            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1497            *
1498            * @param groupId the group ID
1499            * @param userId the user ID
1500            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1501            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1502            * @throws SystemException if a system exception occurred
1503            */
1504            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_First(
1505                    long groupId, long userId,
1506                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1507                    throws com.liferay.portal.kernel.exception.SystemException {
1508                    return getPersistence()
1509                                       .fetchByG_U_First(groupId, userId, orderByComparator);
1510            }
1511    
1512            /**
1513            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1514            *
1515            * @param groupId the group ID
1516            * @param userId the user ID
1517            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1518            * @return the last matching message-boards message
1519            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1520            * @throws SystemException if a system exception occurred
1521            */
1522            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_Last(
1523                    long groupId, long userId,
1524                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1525                    throws com.liferay.portal.kernel.exception.SystemException,
1526                            com.liferay.portlet.messageboards.NoSuchMessageException {
1527                    return getPersistence()
1528                                       .findByG_U_Last(groupId, userId, orderByComparator);
1529            }
1530    
1531            /**
1532            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1533            *
1534            * @param groupId the group ID
1535            * @param userId the user ID
1536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1537            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1538            * @throws SystemException if a system exception occurred
1539            */
1540            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_Last(
1541                    long groupId, long userId,
1542                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1543                    throws com.liferay.portal.kernel.exception.SystemException {
1544                    return getPersistence()
1545                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
1546            }
1547    
1548            /**
1549            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1550            *
1551            * @param messageId the primary key of the current message-boards message
1552            * @param groupId the group ID
1553            * @param userId the user ID
1554            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1555            * @return the previous, current, and next message-boards message
1556            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1557            * @throws SystemException if a system exception occurred
1558            */
1559            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_PrevAndNext(
1560                    long messageId, long groupId, long userId,
1561                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1562                    throws com.liferay.portal.kernel.exception.SystemException,
1563                            com.liferay.portlet.messageboards.NoSuchMessageException {
1564                    return getPersistence()
1565                                       .findByG_U_PrevAndNext(messageId, groupId, userId,
1566                            orderByComparator);
1567            }
1568    
1569            /**
1570            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1571            *
1572            * @param groupId the group ID
1573            * @param userId the user ID
1574            * @return the matching message-boards messages that the user has permission to view
1575            * @throws SystemException if a system exception occurred
1576            */
1577            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1578                    long groupId, long userId)
1579                    throws com.liferay.portal.kernel.exception.SystemException {
1580                    return getPersistence().filterFindByG_U(groupId, userId);
1581            }
1582    
1583            /**
1584            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1585            *
1586            * <p>
1587            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1588            * </p>
1589            *
1590            * @param groupId the group ID
1591            * @param userId the user ID
1592            * @param start the lower bound of the range of message-boards messages
1593            * @param end the upper bound of the range of message-boards messages (not inclusive)
1594            * @return the range of matching message-boards messages that the user has permission to view
1595            * @throws SystemException if a system exception occurred
1596            */
1597            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1598                    long groupId, long userId, int start, int end)
1599                    throws com.liferay.portal.kernel.exception.SystemException {
1600                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
1601            }
1602    
1603            /**
1604            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and userId = &#63;.
1605            *
1606            * <p>
1607            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1608            * </p>
1609            *
1610            * @param groupId the group ID
1611            * @param userId the user ID
1612            * @param start the lower bound of the range of message-boards messages
1613            * @param end the upper bound of the range of message-boards messages (not inclusive)
1614            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1615            * @return the ordered range of matching message-boards messages that the user has permission to view
1616            * @throws SystemException if a system exception occurred
1617            */
1618            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1619                    long groupId, long userId, int start, int end,
1620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1621                    throws com.liferay.portal.kernel.exception.SystemException {
1622                    return getPersistence()
1623                                       .filterFindByG_U(groupId, userId, start, end,
1624                            orderByComparator);
1625            }
1626    
1627            /**
1628            * 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;.
1629            *
1630            * @param messageId the primary key of the current message-boards message
1631            * @param groupId the group ID
1632            * @param userId the user ID
1633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1634            * @return the previous, current, and next message-boards message
1635            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_U_PrevAndNext(
1639                    long messageId, long groupId, long userId,
1640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1641                    throws com.liferay.portal.kernel.exception.SystemException,
1642                            com.liferay.portlet.messageboards.NoSuchMessageException {
1643                    return getPersistence()
1644                                       .filterFindByG_U_PrevAndNext(messageId, groupId, userId,
1645                            orderByComparator);
1646            }
1647    
1648            /**
1649            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; from the database.
1650            *
1651            * @param groupId the group ID
1652            * @param userId the user ID
1653            * @throws SystemException if a system exception occurred
1654            */
1655            public static void removeByG_U(long groupId, long userId)
1656                    throws com.liferay.portal.kernel.exception.SystemException {
1657                    getPersistence().removeByG_U(groupId, userId);
1658            }
1659    
1660            /**
1661            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63;.
1662            *
1663            * @param groupId the group ID
1664            * @param userId the user ID
1665            * @return the number of matching message-boards messages
1666            * @throws SystemException if a system exception occurred
1667            */
1668            public static int countByG_U(long groupId, long userId)
1669                    throws com.liferay.portal.kernel.exception.SystemException {
1670                    return getPersistence().countByG_U(groupId, userId);
1671            }
1672    
1673            /**
1674            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1675            *
1676            * @param groupId the group ID
1677            * @param userId the user ID
1678            * @return the number of matching message-boards messages that the user has permission to view
1679            * @throws SystemException if a system exception occurred
1680            */
1681            public static int filterCountByG_U(long groupId, long userId)
1682                    throws com.liferay.portal.kernel.exception.SystemException {
1683                    return getPersistence().filterCountByG_U(groupId, userId);
1684            }
1685    
1686            /**
1687            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1688            *
1689            * @param groupId the group ID
1690            * @param categoryId the category ID
1691            * @return the matching message-boards messages
1692            * @throws SystemException if a system exception occurred
1693            */
1694            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1695                    long groupId, long categoryId)
1696                    throws com.liferay.portal.kernel.exception.SystemException {
1697                    return getPersistence().findByG_C(groupId, categoryId);
1698            }
1699    
1700            /**
1701            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1702            *
1703            * <p>
1704            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1705            * </p>
1706            *
1707            * @param groupId the group ID
1708            * @param categoryId the category ID
1709            * @param start the lower bound of the range of message-boards messages
1710            * @param end the upper bound of the range of message-boards messages (not inclusive)
1711            * @return the range of matching message-boards messages
1712            * @throws SystemException if a system exception occurred
1713            */
1714            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1715                    long groupId, long categoryId, int start, int end)
1716                    throws com.liferay.portal.kernel.exception.SystemException {
1717                    return getPersistence().findByG_C(groupId, categoryId, start, end);
1718            }
1719    
1720            /**
1721            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1722            *
1723            * <p>
1724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1725            * </p>
1726            *
1727            * @param groupId the group ID
1728            * @param categoryId the category ID
1729            * @param start the lower bound of the range of message-boards messages
1730            * @param end the upper bound of the range of message-boards messages (not inclusive)
1731            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1732            * @return the ordered range of matching message-boards messages
1733            * @throws SystemException if a system exception occurred
1734            */
1735            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1736                    long groupId, long categoryId, int start, int end,
1737                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1738                    throws com.liferay.portal.kernel.exception.SystemException {
1739                    return getPersistence()
1740                                       .findByG_C(groupId, categoryId, start, end, orderByComparator);
1741            }
1742    
1743            /**
1744            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1745            *
1746            * @param groupId the group ID
1747            * @param categoryId the category ID
1748            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1749            * @return the first matching message-boards message
1750            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1751            * @throws SystemException if a system exception occurred
1752            */
1753            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_First(
1754                    long groupId, long categoryId,
1755                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1756                    throws com.liferay.portal.kernel.exception.SystemException,
1757                            com.liferay.portlet.messageboards.NoSuchMessageException {
1758                    return getPersistence()
1759                                       .findByG_C_First(groupId, categoryId, orderByComparator);
1760            }
1761    
1762            /**
1763            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1764            *
1765            * @param groupId the group ID
1766            * @param categoryId the category ID
1767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1768            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1769            * @throws SystemException if a system exception occurred
1770            */
1771            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_First(
1772                    long groupId, long categoryId,
1773                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1774                    throws com.liferay.portal.kernel.exception.SystemException {
1775                    return getPersistence()
1776                                       .fetchByG_C_First(groupId, categoryId, orderByComparator);
1777            }
1778    
1779            /**
1780            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1781            *
1782            * @param groupId the group ID
1783            * @param categoryId the category ID
1784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1785            * @return the last matching message-boards message
1786            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1787            * @throws SystemException if a system exception occurred
1788            */
1789            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_Last(
1790                    long groupId, long categoryId,
1791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1792                    throws com.liferay.portal.kernel.exception.SystemException,
1793                            com.liferay.portlet.messageboards.NoSuchMessageException {
1794                    return getPersistence()
1795                                       .findByG_C_Last(groupId, categoryId, orderByComparator);
1796            }
1797    
1798            /**
1799            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1800            *
1801            * @param groupId the group ID
1802            * @param categoryId the category ID
1803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1804            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1805            * @throws SystemException if a system exception occurred
1806            */
1807            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_Last(
1808                    long groupId, long categoryId,
1809                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1810                    throws com.liferay.portal.kernel.exception.SystemException {
1811                    return getPersistence()
1812                                       .fetchByG_C_Last(groupId, categoryId, orderByComparator);
1813            }
1814    
1815            /**
1816            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1817            *
1818            * @param messageId the primary key of the current message-boards message
1819            * @param groupId the group ID
1820            * @param categoryId the category ID
1821            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1822            * @return the previous, current, and next message-boards message
1823            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1824            * @throws SystemException if a system exception occurred
1825            */
1826            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_PrevAndNext(
1827                    long messageId, long groupId, long categoryId,
1828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1829                    throws com.liferay.portal.kernel.exception.SystemException,
1830                            com.liferay.portlet.messageboards.NoSuchMessageException {
1831                    return getPersistence()
1832                                       .findByG_C_PrevAndNext(messageId, groupId, categoryId,
1833                            orderByComparator);
1834            }
1835    
1836            /**
1837            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1838            *
1839            * @param groupId the group ID
1840            * @param categoryId the category ID
1841            * @return the matching message-boards messages that the user has permission to view
1842            * @throws SystemException if a system exception occurred
1843            */
1844            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1845                    long groupId, long categoryId)
1846                    throws com.liferay.portal.kernel.exception.SystemException {
1847                    return getPersistence().filterFindByG_C(groupId, categoryId);
1848            }
1849    
1850            /**
1851            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1852            *
1853            * <p>
1854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1855            * </p>
1856            *
1857            * @param groupId the group ID
1858            * @param categoryId the category ID
1859            * @param start the lower bound of the range of message-boards messages
1860            * @param end the upper bound of the range of message-boards messages (not inclusive)
1861            * @return the range of matching message-boards messages that the user has permission to view
1862            * @throws SystemException if a system exception occurred
1863            */
1864            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1865                    long groupId, long categoryId, int start, int end)
1866                    throws com.liferay.portal.kernel.exception.SystemException {
1867                    return getPersistence().filterFindByG_C(groupId, categoryId, start, end);
1868            }
1869    
1870            /**
1871            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63;.
1872            *
1873            * <p>
1874            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1875            * </p>
1876            *
1877            * @param groupId the group ID
1878            * @param categoryId the category ID
1879            * @param start the lower bound of the range of message-boards messages
1880            * @param end the upper bound of the range of message-boards messages (not inclusive)
1881            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1882            * @return the ordered range of matching message-boards messages that the user has permission to view
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1886                    long groupId, long categoryId, int start, int end,
1887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1888                    throws com.liferay.portal.kernel.exception.SystemException {
1889                    return getPersistence()
1890                                       .filterFindByG_C(groupId, categoryId, start, end,
1891                            orderByComparator);
1892            }
1893    
1894            /**
1895            * 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;.
1896            *
1897            * @param messageId the primary key of the current message-boards message
1898            * @param groupId the group ID
1899            * @param categoryId the category ID
1900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1901            * @return the previous, current, and next message-boards message
1902            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1903            * @throws SystemException if a system exception occurred
1904            */
1905            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_PrevAndNext(
1906                    long messageId, long groupId, long categoryId,
1907                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1908                    throws com.liferay.portal.kernel.exception.SystemException,
1909                            com.liferay.portlet.messageboards.NoSuchMessageException {
1910                    return getPersistence()
1911                                       .filterFindByG_C_PrevAndNext(messageId, groupId, categoryId,
1912                            orderByComparator);
1913            }
1914    
1915            /**
1916            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; from the database.
1917            *
1918            * @param groupId the group ID
1919            * @param categoryId the category ID
1920            * @throws SystemException if a system exception occurred
1921            */
1922            public static void removeByG_C(long groupId, long categoryId)
1923                    throws com.liferay.portal.kernel.exception.SystemException {
1924                    getPersistence().removeByG_C(groupId, categoryId);
1925            }
1926    
1927            /**
1928            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63;.
1929            *
1930            * @param groupId the group ID
1931            * @param categoryId the category ID
1932            * @return the number of matching message-boards messages
1933            * @throws SystemException if a system exception occurred
1934            */
1935            public static int countByG_C(long groupId, long categoryId)
1936                    throws com.liferay.portal.kernel.exception.SystemException {
1937                    return getPersistence().countByG_C(groupId, categoryId);
1938            }
1939    
1940            /**
1941            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1942            *
1943            * @param groupId the group ID
1944            * @param categoryId the category ID
1945            * @return the number of matching message-boards messages that the user has permission to view
1946            * @throws SystemException if a system exception occurred
1947            */
1948            public static int filterCountByG_C(long groupId, long categoryId)
1949                    throws com.liferay.portal.kernel.exception.SystemException {
1950                    return getPersistence().filterCountByG_C(groupId, categoryId);
1951            }
1952    
1953            /**
1954            * Returns all the message-boards messages where groupId = &#63; and status = &#63;.
1955            *
1956            * @param groupId the group ID
1957            * @param status the status
1958            * @return the matching message-boards messages
1959            * @throws SystemException if a system exception occurred
1960            */
1961            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
1962                    long groupId, int status)
1963                    throws com.liferay.portal.kernel.exception.SystemException {
1964                    return getPersistence().findByG_S(groupId, status);
1965            }
1966    
1967            /**
1968            * Returns a range of all the message-boards messages where groupId = &#63; and status = &#63;.
1969            *
1970            * <p>
1971            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1972            * </p>
1973            *
1974            * @param groupId the group ID
1975            * @param status the status
1976            * @param start the lower bound of the range of message-boards messages
1977            * @param end the upper bound of the range of message-boards messages (not inclusive)
1978            * @return the range of matching message-boards messages
1979            * @throws SystemException if a system exception occurred
1980            */
1981            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
1982                    long groupId, int status, int start, int end)
1983                    throws com.liferay.portal.kernel.exception.SystemException {
1984                    return getPersistence().findByG_S(groupId, status, start, end);
1985            }
1986    
1987            /**
1988            * Returns an ordered range of all the message-boards messages where groupId = &#63; and status = &#63;.
1989            *
1990            * <p>
1991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
1992            * </p>
1993            *
1994            * @param groupId the group ID
1995            * @param status the status
1996            * @param start the lower bound of the range of message-boards messages
1997            * @param end the upper bound of the range of message-boards messages (not inclusive)
1998            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1999            * @return the ordered range of matching message-boards messages
2000            * @throws SystemException if a system exception occurred
2001            */
2002            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
2003                    long groupId, int status, int start, int end,
2004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2005                    throws com.liferay.portal.kernel.exception.SystemException {
2006                    return getPersistence()
2007                                       .findByG_S(groupId, status, start, end, orderByComparator);
2008            }
2009    
2010            /**
2011            * Returns the first message-boards message in the ordered set where groupId = &#63; and status = &#63;.
2012            *
2013            * @param groupId the group ID
2014            * @param status the status
2015            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2016            * @return the first matching message-boards message
2017            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2018            * @throws SystemException if a system exception occurred
2019            */
2020            public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_First(
2021                    long groupId, int status,
2022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2023                    throws com.liferay.portal.kernel.exception.SystemException,
2024                            com.liferay.portlet.messageboards.NoSuchMessageException {
2025                    return getPersistence()
2026                                       .findByG_S_First(groupId, status, orderByComparator);
2027            }
2028    
2029            /**
2030            * Returns the first message-boards message in the ordered set where groupId = &#63; and status = &#63;.
2031            *
2032            * @param groupId the group ID
2033            * @param status the status
2034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2035            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2036            * @throws SystemException if a system exception occurred
2037            */
2038            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_S_First(
2039                    long groupId, int status,
2040                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2041                    throws com.liferay.portal.kernel.exception.SystemException {
2042                    return getPersistence()
2043                                       .fetchByG_S_First(groupId, status, orderByComparator);
2044            }
2045    
2046            /**
2047            * Returns the last message-boards message in the ordered set where groupId = &#63; and status = &#63;.
2048            *
2049            * @param groupId the group ID
2050            * @param status the status
2051            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2052            * @return the last matching message-boards message
2053            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2054            * @throws SystemException if a system exception occurred
2055            */
2056            public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_Last(
2057                    long groupId, int status,
2058                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2059                    throws com.liferay.portal.kernel.exception.SystemException,
2060                            com.liferay.portlet.messageboards.NoSuchMessageException {
2061                    return getPersistence()
2062                                       .findByG_S_Last(groupId, status, orderByComparator);
2063            }
2064    
2065            /**
2066            * Returns the last message-boards message in the ordered set where groupId = &#63; and status = &#63;.
2067            *
2068            * @param groupId the group ID
2069            * @param status the status
2070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2071            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2072            * @throws SystemException if a system exception occurred
2073            */
2074            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_S_Last(
2075                    long groupId, int status,
2076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2077                    throws com.liferay.portal.kernel.exception.SystemException {
2078                    return getPersistence()
2079                                       .fetchByG_S_Last(groupId, status, orderByComparator);
2080            }
2081    
2082            /**
2083            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and status = &#63;.
2084            *
2085            * @param messageId the primary key of the current message-boards message
2086            * @param groupId the group ID
2087            * @param status the status
2088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2089            * @return the previous, current, and next message-boards message
2090            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2091            * @throws SystemException if a system exception occurred
2092            */
2093            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_S_PrevAndNext(
2094                    long messageId, long groupId, int status,
2095                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2096                    throws com.liferay.portal.kernel.exception.SystemException,
2097                            com.liferay.portlet.messageboards.NoSuchMessageException {
2098                    return getPersistence()
2099                                       .findByG_S_PrevAndNext(messageId, groupId, status,
2100                            orderByComparator);
2101            }
2102    
2103            /**
2104            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
2105            *
2106            * @param groupId the group ID
2107            * @param status the status
2108            * @return the matching message-boards messages that the user has permission to view
2109            * @throws SystemException if a system exception occurred
2110            */
2111            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
2112                    long groupId, int status)
2113                    throws com.liferay.portal.kernel.exception.SystemException {
2114                    return getPersistence().filterFindByG_S(groupId, status);
2115            }
2116    
2117            /**
2118            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
2119            *
2120            * <p>
2121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2122            * </p>
2123            *
2124            * @param groupId the group ID
2125            * @param status the status
2126            * @param start the lower bound of the range of message-boards messages
2127            * @param end the upper bound of the range of message-boards messages (not inclusive)
2128            * @return the range of matching message-boards messages that the user has permission to view
2129            * @throws SystemException if a system exception occurred
2130            */
2131            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
2132                    long groupId, int status, int start, int end)
2133                    throws com.liferay.portal.kernel.exception.SystemException {
2134                    return getPersistence().filterFindByG_S(groupId, status, start, end);
2135            }
2136    
2137            /**
2138            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and status = &#63;.
2139            *
2140            * <p>
2141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2142            * </p>
2143            *
2144            * @param groupId the group ID
2145            * @param status the status
2146            * @param start the lower bound of the range of message-boards messages
2147            * @param end the upper bound of the range of message-boards messages (not inclusive)
2148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2149            * @return the ordered range of matching message-boards messages that the user has permission to view
2150            * @throws SystemException if a system exception occurred
2151            */
2152            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
2153                    long groupId, int status, int start, int end,
2154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2155                    throws com.liferay.portal.kernel.exception.SystemException {
2156                    return getPersistence()
2157                                       .filterFindByG_S(groupId, status, start, end,
2158                            orderByComparator);
2159            }
2160    
2161            /**
2162            * 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;.
2163            *
2164            * @param messageId the primary key of the current message-boards message
2165            * @param groupId the group ID
2166            * @param status the status
2167            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2168            * @return the previous, current, and next message-boards message
2169            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2170            * @throws SystemException if a system exception occurred
2171            */
2172            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_S_PrevAndNext(
2173                    long messageId, long groupId, int status,
2174                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2175                    throws com.liferay.portal.kernel.exception.SystemException,
2176                            com.liferay.portlet.messageboards.NoSuchMessageException {
2177                    return getPersistence()
2178                                       .filterFindByG_S_PrevAndNext(messageId, groupId, status,
2179                            orderByComparator);
2180            }
2181    
2182            /**
2183            * Removes all the message-boards messages where groupId = &#63; and status = &#63; from the database.
2184            *
2185            * @param groupId the group ID
2186            * @param status the status
2187            * @throws SystemException if a system exception occurred
2188            */
2189            public static void removeByG_S(long groupId, int status)
2190                    throws com.liferay.portal.kernel.exception.SystemException {
2191                    getPersistence().removeByG_S(groupId, status);
2192            }
2193    
2194            /**
2195            * Returns the number of message-boards messages where groupId = &#63; and status = &#63;.
2196            *
2197            * @param groupId the group ID
2198            * @param status the status
2199            * @return the number of matching message-boards messages
2200            * @throws SystemException if a system exception occurred
2201            */
2202            public static int countByG_S(long groupId, int status)
2203                    throws com.liferay.portal.kernel.exception.SystemException {
2204                    return getPersistence().countByG_S(groupId, status);
2205            }
2206    
2207            /**
2208            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
2209            *
2210            * @param groupId the group ID
2211            * @param status the status
2212            * @return the number of matching message-boards messages that the user has permission to view
2213            * @throws SystemException if a system exception occurred
2214            */
2215            public static int filterCountByG_S(long groupId, int status)
2216                    throws com.liferay.portal.kernel.exception.SystemException {
2217                    return getPersistence().filterCountByG_S(groupId, status);
2218            }
2219    
2220            /**
2221            * Returns all the message-boards messages where companyId = &#63; and status = &#63;.
2222            *
2223            * @param companyId the company ID
2224            * @param status the status
2225            * @return the matching message-boards messages
2226            * @throws SystemException if a system exception occurred
2227            */
2228            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
2229                    long companyId, int status)
2230                    throws com.liferay.portal.kernel.exception.SystemException {
2231                    return getPersistence().findByC_S(companyId, status);
2232            }
2233    
2234            /**
2235            * Returns a range of all the message-boards messages where companyId = &#63; and status = &#63;.
2236            *
2237            * <p>
2238            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2239            * </p>
2240            *
2241            * @param companyId the company ID
2242            * @param status the status
2243            * @param start the lower bound of the range of message-boards messages
2244            * @param end the upper bound of the range of message-boards messages (not inclusive)
2245            * @return the range of matching message-boards messages
2246            * @throws SystemException if a system exception occurred
2247            */
2248            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
2249                    long companyId, int status, int start, int end)
2250                    throws com.liferay.portal.kernel.exception.SystemException {
2251                    return getPersistence().findByC_S(companyId, status, start, end);
2252            }
2253    
2254            /**
2255            * Returns an ordered range of all the message-boards messages where companyId = &#63; and status = &#63;.
2256            *
2257            * <p>
2258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2259            * </p>
2260            *
2261            * @param companyId the company ID
2262            * @param status the status
2263            * @param start the lower bound of the range of message-boards messages
2264            * @param end the upper bound of the range of message-boards messages (not inclusive)
2265            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2266            * @return the ordered range of matching message-boards messages
2267            * @throws SystemException if a system exception occurred
2268            */
2269            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
2270                    long companyId, int status, int start, int end,
2271                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2272                    throws com.liferay.portal.kernel.exception.SystemException {
2273                    return getPersistence()
2274                                       .findByC_S(companyId, status, start, end, orderByComparator);
2275            }
2276    
2277            /**
2278            * Returns the first message-boards message in the ordered set where companyId = &#63; and status = &#63;.
2279            *
2280            * @param companyId the company ID
2281            * @param status the status
2282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2283            * @return the first matching message-boards message
2284            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2285            * @throws SystemException if a system exception occurred
2286            */
2287            public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_First(
2288                    long companyId, int status,
2289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2290                    throws com.liferay.portal.kernel.exception.SystemException,
2291                            com.liferay.portlet.messageboards.NoSuchMessageException {
2292                    return getPersistence()
2293                                       .findByC_S_First(companyId, status, orderByComparator);
2294            }
2295    
2296            /**
2297            * Returns the first message-boards message in the ordered set where companyId = &#63; and status = &#63;.
2298            *
2299            * @param companyId the company ID
2300            * @param status the status
2301            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2302            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2303            * @throws SystemException if a system exception occurred
2304            */
2305            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_S_First(
2306                    long companyId, int status,
2307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2308                    throws com.liferay.portal.kernel.exception.SystemException {
2309                    return getPersistence()
2310                                       .fetchByC_S_First(companyId, status, orderByComparator);
2311            }
2312    
2313            /**
2314            * Returns the last message-boards message in the ordered set where companyId = &#63; and status = &#63;.
2315            *
2316            * @param companyId the company ID
2317            * @param status the status
2318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2319            * @return the last matching message-boards message
2320            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2321            * @throws SystemException if a system exception occurred
2322            */
2323            public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_Last(
2324                    long companyId, int status,
2325                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2326                    throws com.liferay.portal.kernel.exception.SystemException,
2327                            com.liferay.portlet.messageboards.NoSuchMessageException {
2328                    return getPersistence()
2329                                       .findByC_S_Last(companyId, status, orderByComparator);
2330            }
2331    
2332            /**
2333            * Returns the last message-boards message in the ordered set where companyId = &#63; and status = &#63;.
2334            *
2335            * @param companyId the company ID
2336            * @param status the status
2337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2338            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2339            * @throws SystemException if a system exception occurred
2340            */
2341            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_S_Last(
2342                    long companyId, int status,
2343                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2344                    throws com.liferay.portal.kernel.exception.SystemException {
2345                    return getPersistence()
2346                                       .fetchByC_S_Last(companyId, status, orderByComparator);
2347            }
2348    
2349            /**
2350            * Returns the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63; and status = &#63;.
2351            *
2352            * @param messageId the primary key of the current message-boards message
2353            * @param companyId the company ID
2354            * @param status the status
2355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2356            * @return the previous, current, and next message-boards message
2357            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2358            * @throws SystemException if a system exception occurred
2359            */
2360            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_S_PrevAndNext(
2361                    long messageId, long companyId, int status,
2362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2363                    throws com.liferay.portal.kernel.exception.SystemException,
2364                            com.liferay.portlet.messageboards.NoSuchMessageException {
2365                    return getPersistence()
2366                                       .findByC_S_PrevAndNext(messageId, companyId, status,
2367                            orderByComparator);
2368            }
2369    
2370            /**
2371            * Removes all the message-boards messages where companyId = &#63; and status = &#63; from the database.
2372            *
2373            * @param companyId the company ID
2374            * @param status the status
2375            * @throws SystemException if a system exception occurred
2376            */
2377            public static void removeByC_S(long companyId, int status)
2378                    throws com.liferay.portal.kernel.exception.SystemException {
2379                    getPersistence().removeByC_S(companyId, status);
2380            }
2381    
2382            /**
2383            * Returns the number of message-boards messages where companyId = &#63; and status = &#63;.
2384            *
2385            * @param companyId the company ID
2386            * @param status the status
2387            * @return the number of matching message-boards messages
2388            * @throws SystemException if a system exception occurred
2389            */
2390            public static int countByC_S(long companyId, int status)
2391                    throws com.liferay.portal.kernel.exception.SystemException {
2392                    return getPersistence().countByC_S(companyId, status);
2393            }
2394    
2395            /**
2396            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63;.
2397            *
2398            * @param userId the user ID
2399            * @param classNameId the class name ID
2400            * @return the matching message-boards messages
2401            * @throws SystemException if a system exception occurred
2402            */
2403            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2404                    long userId, long classNameId)
2405                    throws com.liferay.portal.kernel.exception.SystemException {
2406                    return getPersistence().findByU_C(userId, classNameId);
2407            }
2408    
2409            /**
2410            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63;.
2411            *
2412            * <p>
2413            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2414            * </p>
2415            *
2416            * @param userId the user ID
2417            * @param classNameId the class name ID
2418            * @param start the lower bound of the range of message-boards messages
2419            * @param end the upper bound of the range of message-boards messages (not inclusive)
2420            * @return the range of matching message-boards messages
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2424                    long userId, long classNameId, int start, int end)
2425                    throws com.liferay.portal.kernel.exception.SystemException {
2426                    return getPersistence().findByU_C(userId, classNameId, start, end);
2427            }
2428    
2429            /**
2430            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63;.
2431            *
2432            * <p>
2433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2434            * </p>
2435            *
2436            * @param userId the user ID
2437            * @param classNameId the class name ID
2438            * @param start the lower bound of the range of message-boards messages
2439            * @param end the upper bound of the range of message-boards messages (not inclusive)
2440            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2441            * @return the ordered range of matching message-boards messages
2442            * @throws SystemException if a system exception occurred
2443            */
2444            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2445                    long userId, long classNameId, int start, int end,
2446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2447                    throws com.liferay.portal.kernel.exception.SystemException {
2448                    return getPersistence()
2449                                       .findByU_C(userId, classNameId, start, end, orderByComparator);
2450            }
2451    
2452            /**
2453            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
2454            *
2455            * @param userId the user ID
2456            * @param classNameId the class name ID
2457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2458            * @return the first matching message-boards message
2459            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2460            * @throws SystemException if a system exception occurred
2461            */
2462            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_First(
2463                    long userId, long classNameId,
2464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2465                    throws com.liferay.portal.kernel.exception.SystemException,
2466                            com.liferay.portlet.messageboards.NoSuchMessageException {
2467                    return getPersistence()
2468                                       .findByU_C_First(userId, classNameId, orderByComparator);
2469            }
2470    
2471            /**
2472            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
2473            *
2474            * @param userId the user ID
2475            * @param classNameId the class name ID
2476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2477            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2478            * @throws SystemException if a system exception occurred
2479            */
2480            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_First(
2481                    long userId, long classNameId,
2482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2483                    throws com.liferay.portal.kernel.exception.SystemException {
2484                    return getPersistence()
2485                                       .fetchByU_C_First(userId, classNameId, orderByComparator);
2486            }
2487    
2488            /**
2489            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
2490            *
2491            * @param userId the user ID
2492            * @param classNameId the class name ID
2493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2494            * @return the last matching message-boards message
2495            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2496            * @throws SystemException if a system exception occurred
2497            */
2498            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_Last(
2499                    long userId, long classNameId,
2500                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2501                    throws com.liferay.portal.kernel.exception.SystemException,
2502                            com.liferay.portlet.messageboards.NoSuchMessageException {
2503                    return getPersistence()
2504                                       .findByU_C_Last(userId, classNameId, orderByComparator);
2505            }
2506    
2507            /**
2508            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
2509            *
2510            * @param userId the user ID
2511            * @param classNameId the class name ID
2512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2513            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2514            * @throws SystemException if a system exception occurred
2515            */
2516            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_Last(
2517                    long userId, long classNameId,
2518                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2519                    throws com.liferay.portal.kernel.exception.SystemException {
2520                    return getPersistence()
2521                                       .fetchByU_C_Last(userId, classNameId, orderByComparator);
2522            }
2523    
2524            /**
2525            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
2526            *
2527            * @param messageId the primary key of the current message-boards message
2528            * @param userId the user ID
2529            * @param classNameId the class name ID
2530            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2531            * @return the previous, current, and next message-boards message
2532            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2533            * @throws SystemException if a system exception occurred
2534            */
2535            public static com.liferay.portlet.messageboards.model.MBMessage[] findByU_C_PrevAndNext(
2536                    long messageId, long userId, long classNameId,
2537                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2538                    throws com.liferay.portal.kernel.exception.SystemException,
2539                            com.liferay.portlet.messageboards.NoSuchMessageException {
2540                    return getPersistence()
2541                                       .findByU_C_PrevAndNext(messageId, userId, classNameId,
2542                            orderByComparator);
2543            }
2544    
2545            /**
2546            * Returns all the message-boards messages where userId = &#63; and classNameId = any &#63;.
2547            *
2548            * <p>
2549            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2550            * </p>
2551            *
2552            * @param userId the user ID
2553            * @param classNameIds the class name IDs
2554            * @return the matching message-boards messages
2555            * @throws SystemException if a system exception occurred
2556            */
2557            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2558                    long userId, long[] classNameIds)
2559                    throws com.liferay.portal.kernel.exception.SystemException {
2560                    return getPersistence().findByU_C(userId, classNameIds);
2561            }
2562    
2563            /**
2564            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = any &#63;.
2565            *
2566            * <p>
2567            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2568            * </p>
2569            *
2570            * @param userId the user ID
2571            * @param classNameIds the class name IDs
2572            * @param start the lower bound of the range of message-boards messages
2573            * @param end the upper bound of the range of message-boards messages (not inclusive)
2574            * @return the range of matching message-boards messages
2575            * @throws SystemException if a system exception occurred
2576            */
2577            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2578                    long userId, long[] classNameIds, int start, int end)
2579                    throws com.liferay.portal.kernel.exception.SystemException {
2580                    return getPersistence().findByU_C(userId, classNameIds, start, end);
2581            }
2582    
2583            /**
2584            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = any &#63;.
2585            *
2586            * <p>
2587            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2588            * </p>
2589            *
2590            * @param userId the user ID
2591            * @param classNameIds the class name IDs
2592            * @param start the lower bound of the range of message-boards messages
2593            * @param end the upper bound of the range of message-boards messages (not inclusive)
2594            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2595            * @return the ordered range of matching message-boards messages
2596            * @throws SystemException if a system exception occurred
2597            */
2598            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C(
2599                    long userId, long[] classNameIds, int start, int end,
2600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2601                    throws com.liferay.portal.kernel.exception.SystemException {
2602                    return getPersistence()
2603                                       .findByU_C(userId, classNameIds, start, end,
2604                            orderByComparator);
2605            }
2606    
2607            /**
2608            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; from the database.
2609            *
2610            * @param userId the user ID
2611            * @param classNameId the class name ID
2612            * @throws SystemException if a system exception occurred
2613            */
2614            public static void removeByU_C(long userId, long classNameId)
2615                    throws com.liferay.portal.kernel.exception.SystemException {
2616                    getPersistence().removeByU_C(userId, classNameId);
2617            }
2618    
2619            /**
2620            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63;.
2621            *
2622            * @param userId the user ID
2623            * @param classNameId the class name ID
2624            * @return the number of matching message-boards messages
2625            * @throws SystemException if a system exception occurred
2626            */
2627            public static int countByU_C(long userId, long classNameId)
2628                    throws com.liferay.portal.kernel.exception.SystemException {
2629                    return getPersistence().countByU_C(userId, classNameId);
2630            }
2631    
2632            /**
2633            * Returns the number of message-boards messages where userId = &#63; and classNameId = any &#63;.
2634            *
2635            * @param userId the user ID
2636            * @param classNameIds the class name IDs
2637            * @return the number of matching message-boards messages
2638            * @throws SystemException if a system exception occurred
2639            */
2640            public static int countByU_C(long userId, long[] classNameIds)
2641                    throws com.liferay.portal.kernel.exception.SystemException {
2642                    return getPersistence().countByU_C(userId, classNameIds);
2643            }
2644    
2645            /**
2646            * Returns all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2647            *
2648            * @param classNameId the class name ID
2649            * @param classPK the class p k
2650            * @return the matching message-boards messages
2651            * @throws SystemException if a system exception occurred
2652            */
2653            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
2654                    long classNameId, long classPK)
2655                    throws com.liferay.portal.kernel.exception.SystemException {
2656                    return getPersistence().findByC_C(classNameId, classPK);
2657            }
2658    
2659            /**
2660            * Returns a range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2661            *
2662            * <p>
2663            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2664            * </p>
2665            *
2666            * @param classNameId the class name ID
2667            * @param classPK the class p k
2668            * @param start the lower bound of the range of message-boards messages
2669            * @param end the upper bound of the range of message-boards messages (not inclusive)
2670            * @return the range of matching message-boards messages
2671            * @throws SystemException if a system exception occurred
2672            */
2673            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
2674                    long classNameId, long classPK, int start, int end)
2675                    throws com.liferay.portal.kernel.exception.SystemException {
2676                    return getPersistence().findByC_C(classNameId, classPK, start, end);
2677            }
2678    
2679            /**
2680            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2681            *
2682            * <p>
2683            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2684            * </p>
2685            *
2686            * @param classNameId the class name ID
2687            * @param classPK the class p k
2688            * @param start the lower bound of the range of message-boards messages
2689            * @param end the upper bound of the range of message-boards messages (not inclusive)
2690            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2691            * @return the ordered range of matching message-boards messages
2692            * @throws SystemException if a system exception occurred
2693            */
2694            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
2695                    long classNameId, long classPK, int start, int end,
2696                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2697                    throws com.liferay.portal.kernel.exception.SystemException {
2698                    return getPersistence()
2699                                       .findByC_C(classNameId, classPK, start, end,
2700                            orderByComparator);
2701            }
2702    
2703            /**
2704            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2705            *
2706            * @param classNameId the class name ID
2707            * @param classPK the class p k
2708            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2709            * @return the first matching message-boards message
2710            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2711            * @throws SystemException if a system exception occurred
2712            */
2713            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_First(
2714                    long classNameId, long classPK,
2715                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2716                    throws com.liferay.portal.kernel.exception.SystemException,
2717                            com.liferay.portlet.messageboards.NoSuchMessageException {
2718                    return getPersistence()
2719                                       .findByC_C_First(classNameId, classPK, orderByComparator);
2720            }
2721    
2722            /**
2723            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2724            *
2725            * @param classNameId the class name ID
2726            * @param classPK the class p k
2727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2728            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2729            * @throws SystemException if a system exception occurred
2730            */
2731            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_C_First(
2732                    long classNameId, long classPK,
2733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2734                    throws com.liferay.portal.kernel.exception.SystemException {
2735                    return getPersistence()
2736                                       .fetchByC_C_First(classNameId, classPK, orderByComparator);
2737            }
2738    
2739            /**
2740            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2741            *
2742            * @param classNameId the class name ID
2743            * @param classPK the class p k
2744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2745            * @return the last matching message-boards message
2746            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2747            * @throws SystemException if a system exception occurred
2748            */
2749            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_Last(
2750                    long classNameId, long classPK,
2751                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2752                    throws com.liferay.portal.kernel.exception.SystemException,
2753                            com.liferay.portlet.messageboards.NoSuchMessageException {
2754                    return getPersistence()
2755                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
2756            }
2757    
2758            /**
2759            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2760            *
2761            * @param classNameId the class name ID
2762            * @param classPK the class p k
2763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2764            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2765            * @throws SystemException if a system exception occurred
2766            */
2767            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_C_Last(
2768                    long classNameId, long classPK,
2769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2770                    throws com.liferay.portal.kernel.exception.SystemException {
2771                    return getPersistence()
2772                                       .fetchByC_C_Last(classNameId, classPK, orderByComparator);
2773            }
2774    
2775            /**
2776            * Returns the message-boards messages before and after the current message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2777            *
2778            * @param messageId the primary key of the current message-boards message
2779            * @param classNameId the class name ID
2780            * @param classPK the class p k
2781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2782            * @return the previous, current, and next message-boards message
2783            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2784            * @throws SystemException if a system exception occurred
2785            */
2786            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_PrevAndNext(
2787                    long messageId, long classNameId, long classPK,
2788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2789                    throws com.liferay.portal.kernel.exception.SystemException,
2790                            com.liferay.portlet.messageboards.NoSuchMessageException {
2791                    return getPersistence()
2792                                       .findByC_C_PrevAndNext(messageId, classNameId, classPK,
2793                            orderByComparator);
2794            }
2795    
2796            /**
2797            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; from the database.
2798            *
2799            * @param classNameId the class name ID
2800            * @param classPK the class p k
2801            * @throws SystemException if a system exception occurred
2802            */
2803            public static void removeByC_C(long classNameId, long classPK)
2804                    throws com.liferay.portal.kernel.exception.SystemException {
2805                    getPersistence().removeByC_C(classNameId, classPK);
2806            }
2807    
2808            /**
2809            * Returns the number of message-boards messages where classNameId = &#63; and classPK = &#63;.
2810            *
2811            * @param classNameId the class name ID
2812            * @param classPK the class p k
2813            * @return the number of matching message-boards messages
2814            * @throws SystemException if a system exception occurred
2815            */
2816            public static int countByC_C(long classNameId, long classPK)
2817                    throws com.liferay.portal.kernel.exception.SystemException {
2818                    return getPersistence().countByC_C(classNameId, classPK);
2819            }
2820    
2821            /**
2822            * Returns all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2823            *
2824            * @param threadId the thread ID
2825            * @param parentMessageId the parent message ID
2826            * @return the matching message-boards messages
2827            * @throws SystemException if a system exception occurred
2828            */
2829            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
2830                    long threadId, long parentMessageId)
2831                    throws com.liferay.portal.kernel.exception.SystemException {
2832                    return getPersistence().findByT_P(threadId, parentMessageId);
2833            }
2834    
2835            /**
2836            * Returns a range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2837            *
2838            * <p>
2839            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2840            * </p>
2841            *
2842            * @param threadId the thread ID
2843            * @param parentMessageId the parent message ID
2844            * @param start the lower bound of the range of message-boards messages
2845            * @param end the upper bound of the range of message-boards messages (not inclusive)
2846            * @return the range of matching message-boards messages
2847            * @throws SystemException if a system exception occurred
2848            */
2849            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
2850                    long threadId, long parentMessageId, int start, int end)
2851                    throws com.liferay.portal.kernel.exception.SystemException {
2852                    return getPersistence().findByT_P(threadId, parentMessageId, start, end);
2853            }
2854    
2855            /**
2856            * Returns an ordered range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2857            *
2858            * <p>
2859            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
2860            * </p>
2861            *
2862            * @param threadId the thread ID
2863            * @param parentMessageId the parent message ID
2864            * @param start the lower bound of the range of message-boards messages
2865            * @param end the upper bound of the range of message-boards messages (not inclusive)
2866            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2867            * @return the ordered range of matching message-boards messages
2868            * @throws SystemException if a system exception occurred
2869            */
2870            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
2871                    long threadId, long parentMessageId, int start, int end,
2872                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2873                    throws com.liferay.portal.kernel.exception.SystemException {
2874                    return getPersistence()
2875                                       .findByT_P(threadId, parentMessageId, start, end,
2876                            orderByComparator);
2877            }
2878    
2879            /**
2880            * Returns the first message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2881            *
2882            * @param threadId the thread ID
2883            * @param parentMessageId the parent message ID
2884            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2885            * @return the first matching message-boards message
2886            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2887            * @throws SystemException if a system exception occurred
2888            */
2889            public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_First(
2890                    long threadId, long parentMessageId,
2891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2892                    throws com.liferay.portal.kernel.exception.SystemException,
2893                            com.liferay.portlet.messageboards.NoSuchMessageException {
2894                    return getPersistence()
2895                                       .findByT_P_First(threadId, parentMessageId, orderByComparator);
2896            }
2897    
2898            /**
2899            * Returns the first message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2900            *
2901            * @param threadId the thread ID
2902            * @param parentMessageId the parent message ID
2903            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2904            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2905            * @throws SystemException if a system exception occurred
2906            */
2907            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_P_First(
2908                    long threadId, long parentMessageId,
2909                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2910                    throws com.liferay.portal.kernel.exception.SystemException {
2911                    return getPersistence()
2912                                       .fetchByT_P_First(threadId, parentMessageId,
2913                            orderByComparator);
2914            }
2915    
2916            /**
2917            * Returns the last message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2918            *
2919            * @param threadId the thread ID
2920            * @param parentMessageId the parent message ID
2921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2922            * @return the last matching message-boards message
2923            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2924            * @throws SystemException if a system exception occurred
2925            */
2926            public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_Last(
2927                    long threadId, long parentMessageId,
2928                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2929                    throws com.liferay.portal.kernel.exception.SystemException,
2930                            com.liferay.portlet.messageboards.NoSuchMessageException {
2931                    return getPersistence()
2932                                       .findByT_P_Last(threadId, parentMessageId, orderByComparator);
2933            }
2934    
2935            /**
2936            * Returns the last message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2937            *
2938            * @param threadId the thread ID
2939            * @param parentMessageId the parent message ID
2940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2941            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2942            * @throws SystemException if a system exception occurred
2943            */
2944            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_P_Last(
2945                    long threadId, long parentMessageId,
2946                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2947                    throws com.liferay.portal.kernel.exception.SystemException {
2948                    return getPersistence()
2949                                       .fetchByT_P_Last(threadId, parentMessageId, orderByComparator);
2950            }
2951    
2952            /**
2953            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2954            *
2955            * @param messageId the primary key of the current message-boards message
2956            * @param threadId the thread ID
2957            * @param parentMessageId the parent message ID
2958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2959            * @return the previous, current, and next message-boards message
2960            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2961            * @throws SystemException if a system exception occurred
2962            */
2963            public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_P_PrevAndNext(
2964                    long messageId, long threadId, long parentMessageId,
2965                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2966                    throws com.liferay.portal.kernel.exception.SystemException,
2967                            com.liferay.portlet.messageboards.NoSuchMessageException {
2968                    return getPersistence()
2969                                       .findByT_P_PrevAndNext(messageId, threadId, parentMessageId,
2970                            orderByComparator);
2971            }
2972    
2973            /**
2974            * Removes all the message-boards messages where threadId = &#63; and parentMessageId = &#63; from the database.
2975            *
2976            * @param threadId the thread ID
2977            * @param parentMessageId the parent message ID
2978            * @throws SystemException if a system exception occurred
2979            */
2980            public static void removeByT_P(long threadId, long parentMessageId)
2981                    throws com.liferay.portal.kernel.exception.SystemException {
2982                    getPersistence().removeByT_P(threadId, parentMessageId);
2983            }
2984    
2985            /**
2986            * Returns the number of message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2987            *
2988            * @param threadId the thread ID
2989            * @param parentMessageId the parent message ID
2990            * @return the number of matching message-boards messages
2991            * @throws SystemException if a system exception occurred
2992            */
2993            public static int countByT_P(long threadId, long parentMessageId)
2994                    throws com.liferay.portal.kernel.exception.SystemException {
2995                    return getPersistence().countByT_P(threadId, parentMessageId);
2996            }
2997    
2998            /**
2999            * Returns all the message-boards messages where threadId = &#63; and answer = &#63;.
3000            *
3001            * @param threadId the thread ID
3002            * @param answer the answer
3003            * @return the matching message-boards messages
3004            * @throws SystemException if a system exception occurred
3005            */
3006            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_A(
3007                    long threadId, boolean answer)
3008                    throws com.liferay.portal.kernel.exception.SystemException {
3009                    return getPersistence().findByT_A(threadId, answer);
3010            }
3011    
3012            /**
3013            * Returns a range of all the message-boards messages where threadId = &#63; and answer = &#63;.
3014            *
3015            * <p>
3016            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3017            * </p>
3018            *
3019            * @param threadId the thread ID
3020            * @param answer the answer
3021            * @param start the lower bound of the range of message-boards messages
3022            * @param end the upper bound of the range of message-boards messages (not inclusive)
3023            * @return the range of matching message-boards messages
3024            * @throws SystemException if a system exception occurred
3025            */
3026            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_A(
3027                    long threadId, boolean answer, int start, int end)
3028                    throws com.liferay.portal.kernel.exception.SystemException {
3029                    return getPersistence().findByT_A(threadId, answer, start, end);
3030            }
3031    
3032            /**
3033            * Returns an ordered range of all the message-boards messages where threadId = &#63; and answer = &#63;.
3034            *
3035            * <p>
3036            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3037            * </p>
3038            *
3039            * @param threadId the thread ID
3040            * @param answer the answer
3041            * @param start the lower bound of the range of message-boards messages
3042            * @param end the upper bound of the range of message-boards messages (not inclusive)
3043            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3044            * @return the ordered range of matching message-boards messages
3045            * @throws SystemException if a system exception occurred
3046            */
3047            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_A(
3048                    long threadId, boolean answer, int start, int end,
3049                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3050                    throws com.liferay.portal.kernel.exception.SystemException {
3051                    return getPersistence()
3052                                       .findByT_A(threadId, answer, start, end, orderByComparator);
3053            }
3054    
3055            /**
3056            * Returns the first message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
3057            *
3058            * @param threadId the thread ID
3059            * @param answer the answer
3060            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3061            * @return the first matching message-boards message
3062            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3063            * @throws SystemException if a system exception occurred
3064            */
3065            public static com.liferay.portlet.messageboards.model.MBMessage findByT_A_First(
3066                    long threadId, boolean answer,
3067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3068                    throws com.liferay.portal.kernel.exception.SystemException,
3069                            com.liferay.portlet.messageboards.NoSuchMessageException {
3070                    return getPersistence()
3071                                       .findByT_A_First(threadId, answer, orderByComparator);
3072            }
3073    
3074            /**
3075            * Returns the first message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
3076            *
3077            * @param threadId the thread ID
3078            * @param answer the answer
3079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3080            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3081            * @throws SystemException if a system exception occurred
3082            */
3083            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_A_First(
3084                    long threadId, boolean answer,
3085                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3086                    throws com.liferay.portal.kernel.exception.SystemException {
3087                    return getPersistence()
3088                                       .fetchByT_A_First(threadId, answer, orderByComparator);
3089            }
3090    
3091            /**
3092            * Returns the last message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
3093            *
3094            * @param threadId the thread ID
3095            * @param answer the answer
3096            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3097            * @return the last matching message-boards message
3098            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3099            * @throws SystemException if a system exception occurred
3100            */
3101            public static com.liferay.portlet.messageboards.model.MBMessage findByT_A_Last(
3102                    long threadId, boolean answer,
3103                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3104                    throws com.liferay.portal.kernel.exception.SystemException,
3105                            com.liferay.portlet.messageboards.NoSuchMessageException {
3106                    return getPersistence()
3107                                       .findByT_A_Last(threadId, answer, orderByComparator);
3108            }
3109    
3110            /**
3111            * Returns the last message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
3112            *
3113            * @param threadId the thread ID
3114            * @param answer the answer
3115            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3116            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3117            * @throws SystemException if a system exception occurred
3118            */
3119            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_A_Last(
3120                    long threadId, boolean answer,
3121                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3122                    throws com.liferay.portal.kernel.exception.SystemException {
3123                    return getPersistence()
3124                                       .fetchByT_A_Last(threadId, answer, orderByComparator);
3125            }
3126    
3127            /**
3128            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
3129            *
3130            * @param messageId the primary key of the current message-boards message
3131            * @param threadId the thread ID
3132            * @param answer the answer
3133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3134            * @return the previous, current, and next message-boards message
3135            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3136            * @throws SystemException if a system exception occurred
3137            */
3138            public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_A_PrevAndNext(
3139                    long messageId, long threadId, boolean answer,
3140                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3141                    throws com.liferay.portal.kernel.exception.SystemException,
3142                            com.liferay.portlet.messageboards.NoSuchMessageException {
3143                    return getPersistence()
3144                                       .findByT_A_PrevAndNext(messageId, threadId, answer,
3145                            orderByComparator);
3146            }
3147    
3148            /**
3149            * Removes all the message-boards messages where threadId = &#63; and answer = &#63; from the database.
3150            *
3151            * @param threadId the thread ID
3152            * @param answer the answer
3153            * @throws SystemException if a system exception occurred
3154            */
3155            public static void removeByT_A(long threadId, boolean answer)
3156                    throws com.liferay.portal.kernel.exception.SystemException {
3157                    getPersistence().removeByT_A(threadId, answer);
3158            }
3159    
3160            /**
3161            * Returns the number of message-boards messages where threadId = &#63; and answer = &#63;.
3162            *
3163            * @param threadId the thread ID
3164            * @param answer the answer
3165            * @return the number of matching message-boards messages
3166            * @throws SystemException if a system exception occurred
3167            */
3168            public static int countByT_A(long threadId, boolean answer)
3169                    throws com.liferay.portal.kernel.exception.SystemException {
3170                    return getPersistence().countByT_A(threadId, answer);
3171            }
3172    
3173            /**
3174            * Returns all the message-boards messages where threadId = &#63; and status = &#63;.
3175            *
3176            * @param threadId the thread ID
3177            * @param status the status
3178            * @return the matching message-boards messages
3179            * @throws SystemException if a system exception occurred
3180            */
3181            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
3182                    long threadId, int status)
3183                    throws com.liferay.portal.kernel.exception.SystemException {
3184                    return getPersistence().findByT_S(threadId, status);
3185            }
3186    
3187            /**
3188            * Returns a range of all the message-boards messages where threadId = &#63; and status = &#63;.
3189            *
3190            * <p>
3191            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3192            * </p>
3193            *
3194            * @param threadId the thread ID
3195            * @param status the status
3196            * @param start the lower bound of the range of message-boards messages
3197            * @param end the upper bound of the range of message-boards messages (not inclusive)
3198            * @return the range of matching message-boards messages
3199            * @throws SystemException if a system exception occurred
3200            */
3201            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
3202                    long threadId, int status, int start, int end)
3203                    throws com.liferay.portal.kernel.exception.SystemException {
3204                    return getPersistence().findByT_S(threadId, status, start, end);
3205            }
3206    
3207            /**
3208            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
3209            *
3210            * <p>
3211            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3212            * </p>
3213            *
3214            * @param threadId the thread ID
3215            * @param status the status
3216            * @param start the lower bound of the range of message-boards messages
3217            * @param end the upper bound of the range of message-boards messages (not inclusive)
3218            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3219            * @return the ordered range of matching message-boards messages
3220            * @throws SystemException if a system exception occurred
3221            */
3222            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
3223                    long threadId, int status, int start, int end,
3224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3225                    throws com.liferay.portal.kernel.exception.SystemException {
3226                    return getPersistence()
3227                                       .findByT_S(threadId, status, start, end, orderByComparator);
3228            }
3229    
3230            /**
3231            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3232            *
3233            * @param threadId the thread ID
3234            * @param status the status
3235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3236            * @return the first matching message-boards message
3237            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3238            * @throws SystemException if a system exception occurred
3239            */
3240            public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_First(
3241                    long threadId, int status,
3242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3243                    throws com.liferay.portal.kernel.exception.SystemException,
3244                            com.liferay.portlet.messageboards.NoSuchMessageException {
3245                    return getPersistence()
3246                                       .findByT_S_First(threadId, status, orderByComparator);
3247            }
3248    
3249            /**
3250            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3251            *
3252            * @param threadId the thread ID
3253            * @param status the status
3254            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3255            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3256            * @throws SystemException if a system exception occurred
3257            */
3258            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_S_First(
3259                    long threadId, int status,
3260                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3261                    throws com.liferay.portal.kernel.exception.SystemException {
3262                    return getPersistence()
3263                                       .fetchByT_S_First(threadId, status, orderByComparator);
3264            }
3265    
3266            /**
3267            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3268            *
3269            * @param threadId the thread ID
3270            * @param status the status
3271            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3272            * @return the last matching message-boards message
3273            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3274            * @throws SystemException if a system exception occurred
3275            */
3276            public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_Last(
3277                    long threadId, int status,
3278                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3279                    throws com.liferay.portal.kernel.exception.SystemException,
3280                            com.liferay.portlet.messageboards.NoSuchMessageException {
3281                    return getPersistence()
3282                                       .findByT_S_Last(threadId, status, orderByComparator);
3283            }
3284    
3285            /**
3286            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3287            *
3288            * @param threadId the thread ID
3289            * @param status the status
3290            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3291            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3292            * @throws SystemException if a system exception occurred
3293            */
3294            public static com.liferay.portlet.messageboards.model.MBMessage fetchByT_S_Last(
3295                    long threadId, int status,
3296                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3297                    throws com.liferay.portal.kernel.exception.SystemException {
3298                    return getPersistence()
3299                                       .fetchByT_S_Last(threadId, status, orderByComparator);
3300            }
3301    
3302            /**
3303            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3304            *
3305            * @param messageId the primary key of the current message-boards message
3306            * @param threadId the thread ID
3307            * @param status the status
3308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3309            * @return the previous, current, and next message-boards message
3310            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3311            * @throws SystemException if a system exception occurred
3312            */
3313            public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_S_PrevAndNext(
3314                    long messageId, long threadId, int status,
3315                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3316                    throws com.liferay.portal.kernel.exception.SystemException,
3317                            com.liferay.portlet.messageboards.NoSuchMessageException {
3318                    return getPersistence()
3319                                       .findByT_S_PrevAndNext(messageId, threadId, status,
3320                            orderByComparator);
3321            }
3322    
3323            /**
3324            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
3325            *
3326            * @param threadId the thread ID
3327            * @param status the status
3328            * @throws SystemException if a system exception occurred
3329            */
3330            public static void removeByT_S(long threadId, int status)
3331                    throws com.liferay.portal.kernel.exception.SystemException {
3332                    getPersistence().removeByT_S(threadId, status);
3333            }
3334    
3335            /**
3336            * Returns the number of message-boards messages where threadId = &#63; and status = &#63;.
3337            *
3338            * @param threadId the thread ID
3339            * @param status the status
3340            * @return the number of matching message-boards messages
3341            * @throws SystemException if a system exception occurred
3342            */
3343            public static int countByT_S(long threadId, int status)
3344                    throws com.liferay.portal.kernel.exception.SystemException {
3345                    return getPersistence().countByT_S(threadId, status);
3346            }
3347    
3348            /**
3349            * Returns all the message-boards messages where threadId = &#63; and status = &#63;.
3350            *
3351            * @param threadId the thread ID
3352            * @param status the status
3353            * @return the matching message-boards messages
3354            * @throws SystemException if a system exception occurred
3355            */
3356            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
3357                    long threadId, int status)
3358                    throws com.liferay.portal.kernel.exception.SystemException {
3359                    return getPersistence().findByTR_S(threadId, status);
3360            }
3361    
3362            /**
3363            * Returns a range of all the message-boards messages where threadId = &#63; and status = &#63;.
3364            *
3365            * <p>
3366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3367            * </p>
3368            *
3369            * @param threadId the thread ID
3370            * @param status the status
3371            * @param start the lower bound of the range of message-boards messages
3372            * @param end the upper bound of the range of message-boards messages (not inclusive)
3373            * @return the range of matching message-boards messages
3374            * @throws SystemException if a system exception occurred
3375            */
3376            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
3377                    long threadId, int status, int start, int end)
3378                    throws com.liferay.portal.kernel.exception.SystemException {
3379                    return getPersistence().findByTR_S(threadId, status, start, end);
3380            }
3381    
3382            /**
3383            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
3384            *
3385            * <p>
3386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3387            * </p>
3388            *
3389            * @param threadId the thread ID
3390            * @param status the status
3391            * @param start the lower bound of the range of message-boards messages
3392            * @param end the upper bound of the range of message-boards messages (not inclusive)
3393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3394            * @return the ordered range of matching message-boards messages
3395            * @throws SystemException if a system exception occurred
3396            */
3397            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
3398                    long threadId, int status, int start, int end,
3399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3400                    throws com.liferay.portal.kernel.exception.SystemException {
3401                    return getPersistence()
3402                                       .findByTR_S(threadId, status, start, end, orderByComparator);
3403            }
3404    
3405            /**
3406            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3407            *
3408            * @param threadId the thread ID
3409            * @param status the status
3410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3411            * @return the first matching message-boards message
3412            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3413            * @throws SystemException if a system exception occurred
3414            */
3415            public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_First(
3416                    long threadId, int status,
3417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3418                    throws com.liferay.portal.kernel.exception.SystemException,
3419                            com.liferay.portlet.messageboards.NoSuchMessageException {
3420                    return getPersistence()
3421                                       .findByTR_S_First(threadId, status, orderByComparator);
3422            }
3423    
3424            /**
3425            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3426            *
3427            * @param threadId the thread ID
3428            * @param status the status
3429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3430            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3431            * @throws SystemException if a system exception occurred
3432            */
3433            public static com.liferay.portlet.messageboards.model.MBMessage fetchByTR_S_First(
3434                    long threadId, int status,
3435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3436                    throws com.liferay.portal.kernel.exception.SystemException {
3437                    return getPersistence()
3438                                       .fetchByTR_S_First(threadId, status, orderByComparator);
3439            }
3440    
3441            /**
3442            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3443            *
3444            * @param threadId the thread ID
3445            * @param status the status
3446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3447            * @return the last matching message-boards message
3448            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3449            * @throws SystemException if a system exception occurred
3450            */
3451            public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_Last(
3452                    long threadId, int status,
3453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3454                    throws com.liferay.portal.kernel.exception.SystemException,
3455                            com.liferay.portlet.messageboards.NoSuchMessageException {
3456                    return getPersistence()
3457                                       .findByTR_S_Last(threadId, status, orderByComparator);
3458            }
3459    
3460            /**
3461            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3462            *
3463            * @param threadId the thread ID
3464            * @param status the status
3465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3466            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3467            * @throws SystemException if a system exception occurred
3468            */
3469            public static com.liferay.portlet.messageboards.model.MBMessage fetchByTR_S_Last(
3470                    long threadId, int status,
3471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3472                    throws com.liferay.portal.kernel.exception.SystemException {
3473                    return getPersistence()
3474                                       .fetchByTR_S_Last(threadId, status, orderByComparator);
3475            }
3476    
3477            /**
3478            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
3479            *
3480            * @param messageId the primary key of the current message-boards message
3481            * @param threadId the thread ID
3482            * @param status the status
3483            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3484            * @return the previous, current, and next message-boards message
3485            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3486            * @throws SystemException if a system exception occurred
3487            */
3488            public static com.liferay.portlet.messageboards.model.MBMessage[] findByTR_S_PrevAndNext(
3489                    long messageId, long threadId, int status,
3490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3491                    throws com.liferay.portal.kernel.exception.SystemException,
3492                            com.liferay.portlet.messageboards.NoSuchMessageException {
3493                    return getPersistence()
3494                                       .findByTR_S_PrevAndNext(messageId, threadId, status,
3495                            orderByComparator);
3496            }
3497    
3498            /**
3499            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
3500            *
3501            * @param threadId the thread ID
3502            * @param status the status
3503            * @throws SystemException if a system exception occurred
3504            */
3505            public static void removeByTR_S(long threadId, int status)
3506                    throws com.liferay.portal.kernel.exception.SystemException {
3507                    getPersistence().removeByTR_S(threadId, status);
3508            }
3509    
3510            /**
3511            * Returns the number of message-boards messages where threadId = &#63; and status = &#63;.
3512            *
3513            * @param threadId the thread ID
3514            * @param status the status
3515            * @return the number of matching message-boards messages
3516            * @throws SystemException if a system exception occurred
3517            */
3518            public static int countByTR_S(long threadId, int status)
3519                    throws com.liferay.portal.kernel.exception.SystemException {
3520                    return getPersistence().countByTR_S(threadId, status);
3521            }
3522    
3523            /**
3524            * Returns all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3525            *
3526            * @param groupId the group ID
3527            * @param userId the user ID
3528            * @param status the status
3529            * @return the matching message-boards messages
3530            * @throws SystemException if a system exception occurred
3531            */
3532            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
3533                    long groupId, long userId, int status)
3534                    throws com.liferay.portal.kernel.exception.SystemException {
3535                    return getPersistence().findByG_U_S(groupId, userId, status);
3536            }
3537    
3538            /**
3539            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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 groupId the group ID
3546            * @param userId the user ID
3547            * @param status the status
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            * @return the range of matching message-boards messages
3551            * @throws SystemException if a system exception occurred
3552            */
3553            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
3554                    long groupId, long userId, int status, int start, int end)
3555                    throws com.liferay.portal.kernel.exception.SystemException {
3556                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
3557            }
3558    
3559            /**
3560            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3561            *
3562            * <p>
3563            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3564            * </p>
3565            *
3566            * @param groupId the group ID
3567            * @param userId the user ID
3568            * @param status the status
3569            * @param start the lower bound of the range of message-boards messages
3570            * @param end the upper bound of the range of message-boards messages (not inclusive)
3571            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3572            * @return the ordered range of matching message-boards messages
3573            * @throws SystemException if a system exception occurred
3574            */
3575            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
3576                    long groupId, long userId, int status, int start, int end,
3577                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3578                    throws com.liferay.portal.kernel.exception.SystemException {
3579                    return getPersistence()
3580                                       .findByG_U_S(groupId, userId, status, start, end,
3581                            orderByComparator);
3582            }
3583    
3584            /**
3585            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3586            *
3587            * @param groupId the group ID
3588            * @param userId the user ID
3589            * @param status the status
3590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3591            * @return the first matching message-boards message
3592            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3593            * @throws SystemException if a system exception occurred
3594            */
3595            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_First(
3596                    long groupId, long userId, int status,
3597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3598                    throws com.liferay.portal.kernel.exception.SystemException,
3599                            com.liferay.portlet.messageboards.NoSuchMessageException {
3600                    return getPersistence()
3601                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
3602            }
3603    
3604            /**
3605            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3606            *
3607            * @param groupId the group ID
3608            * @param userId the user ID
3609            * @param status the status
3610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3611            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3612            * @throws SystemException if a system exception occurred
3613            */
3614            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_S_First(
3615                    long groupId, long userId, int status,
3616                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3617                    throws com.liferay.portal.kernel.exception.SystemException {
3618                    return getPersistence()
3619                                       .fetchByG_U_S_First(groupId, userId, status,
3620                            orderByComparator);
3621            }
3622    
3623            /**
3624            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3625            *
3626            * @param groupId the group ID
3627            * @param userId the user ID
3628            * @param status the status
3629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3630            * @return the last matching message-boards message
3631            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3632            * @throws SystemException if a system exception occurred
3633            */
3634            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_Last(
3635                    long groupId, long userId, int status,
3636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3637                    throws com.liferay.portal.kernel.exception.SystemException,
3638                            com.liferay.portlet.messageboards.NoSuchMessageException {
3639                    return getPersistence()
3640                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
3641            }
3642    
3643            /**
3644            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3645            *
3646            * @param groupId the group ID
3647            * @param userId the user ID
3648            * @param status the status
3649            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3650            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3651            * @throws SystemException if a system exception occurred
3652            */
3653            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_S_Last(
3654                    long groupId, long userId, int status,
3655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3656                    throws com.liferay.portal.kernel.exception.SystemException {
3657                    return getPersistence()
3658                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
3659            }
3660    
3661            /**
3662            * 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;.
3663            *
3664            * @param messageId the primary key of the current message-boards message
3665            * @param groupId the group ID
3666            * @param userId the user ID
3667            * @param status the status
3668            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3669            * @return the previous, current, and next message-boards message
3670            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3671            * @throws SystemException if a system exception occurred
3672            */
3673            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_S_PrevAndNext(
3674                    long messageId, long groupId, long userId, int status,
3675                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3676                    throws com.liferay.portal.kernel.exception.SystemException,
3677                            com.liferay.portlet.messageboards.NoSuchMessageException {
3678                    return getPersistence()
3679                                       .findByG_U_S_PrevAndNext(messageId, groupId, userId, status,
3680                            orderByComparator);
3681            }
3682    
3683            /**
3684            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3685            *
3686            * @param groupId the group ID
3687            * @param userId the user ID
3688            * @param status the status
3689            * @return the matching message-boards messages that the user has permission to view
3690            * @throws SystemException if a system exception occurred
3691            */
3692            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
3693                    long groupId, long userId, int status)
3694                    throws com.liferay.portal.kernel.exception.SystemException {
3695                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
3696            }
3697    
3698            /**
3699            * 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;.
3700            *
3701            * <p>
3702            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3703            * </p>
3704            *
3705            * @param groupId the group ID
3706            * @param userId the user ID
3707            * @param status the status
3708            * @param start the lower bound of the range of message-boards messages
3709            * @param end the upper bound of the range of message-boards messages (not inclusive)
3710            * @return the range of matching message-boards messages that the user has permission to view
3711            * @throws SystemException if a system exception occurred
3712            */
3713            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
3714                    long groupId, long userId, int status, int start, int end)
3715                    throws com.liferay.portal.kernel.exception.SystemException {
3716                    return getPersistence()
3717                                       .filterFindByG_U_S(groupId, userId, status, start, end);
3718            }
3719    
3720            /**
3721            * 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;.
3722            *
3723            * <p>
3724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3725            * </p>
3726            *
3727            * @param groupId the group ID
3728            * @param userId the user ID
3729            * @param status the status
3730            * @param start the lower bound of the range of message-boards messages
3731            * @param end the upper bound of the range of message-boards messages (not inclusive)
3732            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3733            * @return the ordered range of matching message-boards messages that the user has permission to view
3734            * @throws SystemException if a system exception occurred
3735            */
3736            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
3737                    long groupId, long userId, int status, int start, int end,
3738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3739                    throws com.liferay.portal.kernel.exception.SystemException {
3740                    return getPersistence()
3741                                       .filterFindByG_U_S(groupId, userId, status, start, end,
3742                            orderByComparator);
3743            }
3744    
3745            /**
3746            * 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;.
3747            *
3748            * @param messageId the primary key of the current message-boards message
3749            * @param groupId the group ID
3750            * @param userId the user ID
3751            * @param status the status
3752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3753            * @return the previous, current, and next message-boards message
3754            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3755            * @throws SystemException if a system exception occurred
3756            */
3757            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_U_S_PrevAndNext(
3758                    long messageId, long groupId, long userId, int status,
3759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3760                    throws com.liferay.portal.kernel.exception.SystemException,
3761                            com.liferay.portlet.messageboards.NoSuchMessageException {
3762                    return getPersistence()
3763                                       .filterFindByG_U_S_PrevAndNext(messageId, groupId, userId,
3764                            status, orderByComparator);
3765            }
3766    
3767            /**
3768            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63; from the database.
3769            *
3770            * @param groupId the group ID
3771            * @param userId the user ID
3772            * @param status the status
3773            * @throws SystemException if a system exception occurred
3774            */
3775            public static void removeByG_U_S(long groupId, long userId, int status)
3776                    throws com.liferay.portal.kernel.exception.SystemException {
3777                    getPersistence().removeByG_U_S(groupId, userId, status);
3778            }
3779    
3780            /**
3781            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3782            *
3783            * @param groupId the group ID
3784            * @param userId the user ID
3785            * @param status the status
3786            * @return the number of matching message-boards messages
3787            * @throws SystemException if a system exception occurred
3788            */
3789            public static int countByG_U_S(long groupId, long userId, int status)
3790                    throws com.liferay.portal.kernel.exception.SystemException {
3791                    return getPersistence().countByG_U_S(groupId, userId, status);
3792            }
3793    
3794            /**
3795            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3796            *
3797            * @param groupId the group ID
3798            * @param userId the user ID
3799            * @param status the status
3800            * @return the number of matching message-boards messages that the user has permission to view
3801            * @throws SystemException if a system exception occurred
3802            */
3803            public static int filterCountByG_U_S(long groupId, long userId, int status)
3804                    throws com.liferay.portal.kernel.exception.SystemException {
3805                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
3806            }
3807    
3808            /**
3809            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3810            *
3811            * @param groupId the group ID
3812            * @param categoryId the category ID
3813            * @param threadId the thread ID
3814            * @return the matching message-boards messages
3815            * @throws SystemException if a system exception occurred
3816            */
3817            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
3818                    long groupId, long categoryId, long threadId)
3819                    throws com.liferay.portal.kernel.exception.SystemException {
3820                    return getPersistence().findByG_C_T(groupId, categoryId, threadId);
3821            }
3822    
3823            /**
3824            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3825            *
3826            * <p>
3827            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3828            * </p>
3829            *
3830            * @param groupId the group ID
3831            * @param categoryId the category ID
3832            * @param threadId the thread ID
3833            * @param start the lower bound of the range of message-boards messages
3834            * @param end the upper bound of the range of message-boards messages (not inclusive)
3835            * @return the range of matching message-boards messages
3836            * @throws SystemException if a system exception occurred
3837            */
3838            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
3839                    long groupId, long categoryId, long threadId, int start, int end)
3840                    throws com.liferay.portal.kernel.exception.SystemException {
3841                    return getPersistence()
3842                                       .findByG_C_T(groupId, categoryId, threadId, start, end);
3843            }
3844    
3845            /**
3846            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3847            *
3848            * <p>
3849            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3850            * </p>
3851            *
3852            * @param groupId the group ID
3853            * @param categoryId the category ID
3854            * @param threadId the thread ID
3855            * @param start the lower bound of the range of message-boards messages
3856            * @param end the upper bound of the range of message-boards messages (not inclusive)
3857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3858            * @return the ordered range of matching message-boards messages
3859            * @throws SystemException if a system exception occurred
3860            */
3861            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
3862                    long groupId, long categoryId, long threadId, int start, int end,
3863                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3864                    throws com.liferay.portal.kernel.exception.SystemException {
3865                    return getPersistence()
3866                                       .findByG_C_T(groupId, categoryId, threadId, start, end,
3867                            orderByComparator);
3868            }
3869    
3870            /**
3871            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3872            *
3873            * @param groupId the group ID
3874            * @param categoryId the category ID
3875            * @param threadId the thread ID
3876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3877            * @return the first matching message-boards message
3878            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3879            * @throws SystemException if a system exception occurred
3880            */
3881            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_First(
3882                    long groupId, long categoryId, long threadId,
3883                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3884                    throws com.liferay.portal.kernel.exception.SystemException,
3885                            com.liferay.portlet.messageboards.NoSuchMessageException {
3886                    return getPersistence()
3887                                       .findByG_C_T_First(groupId, categoryId, threadId,
3888                            orderByComparator);
3889            }
3890    
3891            /**
3892            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3893            *
3894            * @param groupId the group ID
3895            * @param categoryId the category ID
3896            * @param threadId the thread ID
3897            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3898            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3899            * @throws SystemException if a system exception occurred
3900            */
3901            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_First(
3902                    long groupId, long categoryId, long threadId,
3903                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3904                    throws com.liferay.portal.kernel.exception.SystemException {
3905                    return getPersistence()
3906                                       .fetchByG_C_T_First(groupId, categoryId, threadId,
3907                            orderByComparator);
3908            }
3909    
3910            /**
3911            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3912            *
3913            * @param groupId the group ID
3914            * @param categoryId the category ID
3915            * @param threadId the thread ID
3916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3917            * @return the last matching message-boards message
3918            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3919            * @throws SystemException if a system exception occurred
3920            */
3921            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_Last(
3922                    long groupId, long categoryId, long threadId,
3923                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3924                    throws com.liferay.portal.kernel.exception.SystemException,
3925                            com.liferay.portlet.messageboards.NoSuchMessageException {
3926                    return getPersistence()
3927                                       .findByG_C_T_Last(groupId, categoryId, threadId,
3928                            orderByComparator);
3929            }
3930    
3931            /**
3932            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3933            *
3934            * @param groupId the group ID
3935            * @param categoryId the category ID
3936            * @param threadId the thread ID
3937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3938            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3939            * @throws SystemException if a system exception occurred
3940            */
3941            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_Last(
3942                    long groupId, long categoryId, long threadId,
3943                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3944                    throws com.liferay.portal.kernel.exception.SystemException {
3945                    return getPersistence()
3946                                       .fetchByG_C_T_Last(groupId, categoryId, threadId,
3947                            orderByComparator);
3948            }
3949    
3950            /**
3951            * 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;.
3952            *
3953            * @param messageId the primary key of the current message-boards message
3954            * @param groupId the group ID
3955            * @param categoryId the category ID
3956            * @param threadId the thread ID
3957            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3958            * @return the previous, current, and next message-boards message
3959            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3960            * @throws SystemException if a system exception occurred
3961            */
3962            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_PrevAndNext(
3963                    long messageId, long groupId, long categoryId, long threadId,
3964                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3965                    throws com.liferay.portal.kernel.exception.SystemException,
3966                            com.liferay.portlet.messageboards.NoSuchMessageException {
3967                    return getPersistence()
3968                                       .findByG_C_T_PrevAndNext(messageId, groupId, categoryId,
3969                            threadId, orderByComparator);
3970            }
3971    
3972            /**
3973            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3974            *
3975            * @param groupId the group ID
3976            * @param categoryId the category ID
3977            * @param threadId the thread ID
3978            * @return the matching message-boards messages that the user has permission to view
3979            * @throws SystemException if a system exception occurred
3980            */
3981            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
3982                    long groupId, long categoryId, long threadId)
3983                    throws com.liferay.portal.kernel.exception.SystemException {
3984                    return getPersistence().filterFindByG_C_T(groupId, categoryId, threadId);
3985            }
3986    
3987            /**
3988            * 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;.
3989            *
3990            * <p>
3991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
3992            * </p>
3993            *
3994            * @param groupId the group ID
3995            * @param categoryId the category ID
3996            * @param threadId the thread ID
3997            * @param start the lower bound of the range of message-boards messages
3998            * @param end the upper bound of the range of message-boards messages (not inclusive)
3999            * @return the range of matching message-boards messages that the user has permission to view
4000            * @throws SystemException if a system exception occurred
4001            */
4002            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
4003                    long groupId, long categoryId, long threadId, int start, int end)
4004                    throws com.liferay.portal.kernel.exception.SystemException {
4005                    return getPersistence()
4006                                       .filterFindByG_C_T(groupId, categoryId, threadId, start, end);
4007            }
4008    
4009            /**
4010            * 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;.
4011            *
4012            * <p>
4013            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4014            * </p>
4015            *
4016            * @param groupId the group ID
4017            * @param categoryId the category ID
4018            * @param threadId the thread ID
4019            * @param start the lower bound of the range of message-boards messages
4020            * @param end the upper bound of the range of message-boards messages (not inclusive)
4021            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4022            * @return the ordered range of matching message-boards messages that the user has permission to view
4023            * @throws SystemException if a system exception occurred
4024            */
4025            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
4026                    long groupId, long categoryId, long threadId, int start, int end,
4027                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4028                    throws com.liferay.portal.kernel.exception.SystemException {
4029                    return getPersistence()
4030                                       .filterFindByG_C_T(groupId, categoryId, threadId, start,
4031                            end, orderByComparator);
4032            }
4033    
4034            /**
4035            * 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;.
4036            *
4037            * @param messageId the primary key of the current message-boards message
4038            * @param groupId the group ID
4039            * @param categoryId the category ID
4040            * @param threadId the thread ID
4041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4042            * @return the previous, current, and next message-boards message
4043            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
4044            * @throws SystemException if a system exception occurred
4045            */
4046            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_T_PrevAndNext(
4047                    long messageId, long groupId, long categoryId, long threadId,
4048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4049                    throws com.liferay.portal.kernel.exception.SystemException,
4050                            com.liferay.portlet.messageboards.NoSuchMessageException {
4051                    return getPersistence()
4052                                       .filterFindByG_C_T_PrevAndNext(messageId, groupId,
4053                            categoryId, threadId, orderByComparator);
4054            }
4055    
4056            /**
4057            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; from the database.
4058            *
4059            * @param groupId the group ID
4060            * @param categoryId the category ID
4061            * @param threadId the thread ID
4062            * @throws SystemException if a system exception occurred
4063            */
4064            public static void removeByG_C_T(long groupId, long categoryId,
4065                    long threadId)
4066                    throws com.liferay.portal.kernel.exception.SystemException {
4067                    getPersistence().removeByG_C_T(groupId, categoryId, threadId);
4068            }
4069    
4070            /**
4071            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
4072            *
4073            * @param groupId the group ID
4074            * @param categoryId the category ID
4075            * @param threadId the thread ID
4076            * @return the number of matching message-boards messages
4077            * @throws SystemException if a system exception occurred
4078            */
4079            public static int countByG_C_T(long groupId, long categoryId, long threadId)
4080                    throws com.liferay.portal.kernel.exception.SystemException {
4081                    return getPersistence().countByG_C_T(groupId, categoryId, threadId);
4082            }
4083    
4084            /**
4085            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
4086            *
4087            * @param groupId the group ID
4088            * @param categoryId the category ID
4089            * @param threadId the thread ID
4090            * @return the number of matching message-boards messages that the user has permission to view
4091            * @throws SystemException if a system exception occurred
4092            */
4093            public static int filterCountByG_C_T(long groupId, long categoryId,
4094                    long threadId)
4095                    throws com.liferay.portal.kernel.exception.SystemException {
4096                    return getPersistence().filterCountByG_C_T(groupId, categoryId, threadId);
4097            }
4098    
4099            /**
4100            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
4101            *
4102            * @param groupId the group ID
4103            * @param categoryId the category ID
4104            * @param status the status
4105            * @return the matching message-boards messages
4106            * @throws SystemException if a system exception occurred
4107            */
4108            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
4109                    long groupId, long categoryId, int status)
4110                    throws com.liferay.portal.kernel.exception.SystemException {
4111                    return getPersistence().findByG_C_S(groupId, categoryId, status);
4112            }
4113    
4114            /**
4115            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
4116            *
4117            * <p>
4118            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4119            * </p>
4120            *
4121            * @param groupId the group ID
4122            * @param categoryId the category ID
4123            * @param status the status
4124            * @param start the lower bound of the range of message-boards messages
4125            * @param end the upper bound of the range of message-boards messages (not inclusive)
4126            * @return the range of matching message-boards messages
4127            * @throws SystemException if a system exception occurred
4128            */
4129            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
4130                    long groupId, long categoryId, int status, int start, int end)
4131                    throws com.liferay.portal.kernel.exception.SystemException {
4132                    return getPersistence()
4133                                       .findByG_C_S(groupId, categoryId, status, start, end);
4134            }
4135    
4136            /**
4137            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
4138            *
4139            * <p>
4140            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4141            * </p>
4142            *
4143            * @param groupId the group ID
4144            * @param categoryId the category ID
4145            * @param status the status
4146            * @param start the lower bound of the range of message-boards messages
4147            * @param end the upper bound of the range of message-boards messages (not inclusive)
4148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4149            * @return the ordered range of matching message-boards messages
4150            * @throws SystemException if a system exception occurred
4151            */
4152            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
4153                    long groupId, long categoryId, int status, int start, int end,
4154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4155                    throws com.liferay.portal.kernel.exception.SystemException {
4156                    return getPersistence()
4157                                       .findByG_C_S(groupId, categoryId, status, start, end,
4158                            orderByComparator);
4159            }
4160    
4161            /**
4162            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
4163            *
4164            * @param groupId the group ID
4165            * @param categoryId the category ID
4166            * @param status the status
4167            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4168            * @return the first matching message-boards message
4169            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4170            * @throws SystemException if a system exception occurred
4171            */
4172            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_First(
4173                    long groupId, long categoryId, int status,
4174                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4175                    throws com.liferay.portal.kernel.exception.SystemException,
4176                            com.liferay.portlet.messageboards.NoSuchMessageException {
4177                    return getPersistence()
4178                                       .findByG_C_S_First(groupId, categoryId, status,
4179                            orderByComparator);
4180            }
4181    
4182            /**
4183            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
4184            *
4185            * @param groupId the group ID
4186            * @param categoryId the category ID
4187            * @param status the status
4188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4189            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4190            * @throws SystemException if a system exception occurred
4191            */
4192            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_S_First(
4193                    long groupId, long categoryId, int status,
4194                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4195                    throws com.liferay.portal.kernel.exception.SystemException {
4196                    return getPersistence()
4197                                       .fetchByG_C_S_First(groupId, categoryId, status,
4198                            orderByComparator);
4199            }
4200    
4201            /**
4202            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
4203            *
4204            * @param groupId the group ID
4205            * @param categoryId the category ID
4206            * @param status the status
4207            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4208            * @return the last matching message-boards message
4209            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4210            * @throws SystemException if a system exception occurred
4211            */
4212            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_Last(
4213                    long groupId, long categoryId, int status,
4214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4215                    throws com.liferay.portal.kernel.exception.SystemException,
4216                            com.liferay.portlet.messageboards.NoSuchMessageException {
4217                    return getPersistence()
4218                                       .findByG_C_S_Last(groupId, categoryId, status,
4219                            orderByComparator);
4220            }
4221    
4222            /**
4223            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
4224            *
4225            * @param groupId the group ID
4226            * @param categoryId the category ID
4227            * @param status the status
4228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4229            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4230            * @throws SystemException if a system exception occurred
4231            */
4232            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_S_Last(
4233                    long groupId, long categoryId, int status,
4234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4235                    throws com.liferay.portal.kernel.exception.SystemException {
4236                    return getPersistence()
4237                                       .fetchByG_C_S_Last(groupId, categoryId, status,
4238                            orderByComparator);
4239            }
4240    
4241            /**
4242            * 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;.
4243            *
4244            * @param messageId the primary key of the current message-boards message
4245            * @param groupId the group ID
4246            * @param categoryId the category ID
4247            * @param status the status
4248            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4249            * @return the previous, current, and next message-boards message
4250            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
4251            * @throws SystemException if a system exception occurred
4252            */
4253            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_S_PrevAndNext(
4254                    long messageId, long groupId, long categoryId, int status,
4255                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4256                    throws com.liferay.portal.kernel.exception.SystemException,
4257                            com.liferay.portlet.messageboards.NoSuchMessageException {
4258                    return getPersistence()
4259                                       .findByG_C_S_PrevAndNext(messageId, groupId, categoryId,
4260                            status, orderByComparator);
4261            }
4262    
4263            /**
4264            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
4265            *
4266            * @param groupId the group ID
4267            * @param categoryId the category ID
4268            * @param status the status
4269            * @return the matching message-boards messages that the user has permission to view
4270            * @throws SystemException if a system exception occurred
4271            */
4272            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
4273                    long groupId, long categoryId, int status)
4274                    throws com.liferay.portal.kernel.exception.SystemException {
4275                    return getPersistence().filterFindByG_C_S(groupId, categoryId, status);
4276            }
4277    
4278            /**
4279            * 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;.
4280            *
4281            * <p>
4282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4283            * </p>
4284            *
4285            * @param groupId the group ID
4286            * @param categoryId the category ID
4287            * @param status the status
4288            * @param start the lower bound of the range of message-boards messages
4289            * @param end the upper bound of the range of message-boards messages (not inclusive)
4290            * @return the range of matching message-boards messages that the user has permission to view
4291            * @throws SystemException if a system exception occurred
4292            */
4293            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
4294                    long groupId, long categoryId, int status, int start, int end)
4295                    throws com.liferay.portal.kernel.exception.SystemException {
4296                    return getPersistence()
4297                                       .filterFindByG_C_S(groupId, categoryId, status, start, end);
4298            }
4299    
4300            /**
4301            * 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;.
4302            *
4303            * <p>
4304            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4305            * </p>
4306            *
4307            * @param groupId the group ID
4308            * @param categoryId the category ID
4309            * @param status the status
4310            * @param start the lower bound of the range of message-boards messages
4311            * @param end the upper bound of the range of message-boards messages (not inclusive)
4312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4313            * @return the ordered range of matching message-boards messages that the user has permission to view
4314            * @throws SystemException if a system exception occurred
4315            */
4316            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
4317                    long groupId, long categoryId, int status, int start, int end,
4318                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4319                    throws com.liferay.portal.kernel.exception.SystemException {
4320                    return getPersistence()
4321                                       .filterFindByG_C_S(groupId, categoryId, status, start, end,
4322                            orderByComparator);
4323            }
4324    
4325            /**
4326            * 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;.
4327            *
4328            * @param messageId the primary key of the current message-boards message
4329            * @param groupId the group ID
4330            * @param categoryId the category ID
4331            * @param status the status
4332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4333            * @return the previous, current, and next message-boards message
4334            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
4335            * @throws SystemException if a system exception occurred
4336            */
4337            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_S_PrevAndNext(
4338                    long messageId, long groupId, long categoryId, int status,
4339                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4340                    throws com.liferay.portal.kernel.exception.SystemException,
4341                            com.liferay.portlet.messageboards.NoSuchMessageException {
4342                    return getPersistence()
4343                                       .filterFindByG_C_S_PrevAndNext(messageId, groupId,
4344                            categoryId, status, orderByComparator);
4345            }
4346    
4347            /**
4348            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
4349            *
4350            * @param groupId the group ID
4351            * @param categoryId the category ID
4352            * @param status the status
4353            * @throws SystemException if a system exception occurred
4354            */
4355            public static void removeByG_C_S(long groupId, long categoryId, int status)
4356                    throws com.liferay.portal.kernel.exception.SystemException {
4357                    getPersistence().removeByG_C_S(groupId, categoryId, status);
4358            }
4359    
4360            /**
4361            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
4362            *
4363            * @param groupId the group ID
4364            * @param categoryId the category ID
4365            * @param status the status
4366            * @return the number of matching message-boards messages
4367            * @throws SystemException if a system exception occurred
4368            */
4369            public static int countByG_C_S(long groupId, long categoryId, int status)
4370                    throws com.liferay.portal.kernel.exception.SystemException {
4371                    return getPersistence().countByG_C_S(groupId, categoryId, status);
4372            }
4373    
4374            /**
4375            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
4376            *
4377            * @param groupId the group ID
4378            * @param categoryId the category ID
4379            * @param status the status
4380            * @return the number of matching message-boards messages that the user has permission to view
4381            * @throws SystemException if a system exception occurred
4382            */
4383            public static int filterCountByG_C_S(long groupId, long categoryId,
4384                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4385                    return getPersistence().filterCountByG_C_S(groupId, categoryId, status);
4386            }
4387    
4388            /**
4389            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4390            *
4391            * @param userId the user ID
4392            * @param classNameId the class name ID
4393            * @param classPK the class p k
4394            * @return the matching message-boards messages
4395            * @throws SystemException if a system exception occurred
4396            */
4397            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C(
4398                    long userId, long classNameId, long classPK)
4399                    throws com.liferay.portal.kernel.exception.SystemException {
4400                    return getPersistence().findByU_C_C(userId, classNameId, classPK);
4401            }
4402    
4403            /**
4404            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4405            *
4406            * <p>
4407            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4408            * </p>
4409            *
4410            * @param userId the user ID
4411            * @param classNameId the class name ID
4412            * @param classPK the class p k
4413            * @param start the lower bound of the range of message-boards messages
4414            * @param end the upper bound of the range of message-boards messages (not inclusive)
4415            * @return the range of matching message-boards messages
4416            * @throws SystemException if a system exception occurred
4417            */
4418            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C(
4419                    long userId, long classNameId, long classPK, int start, int end)
4420                    throws com.liferay.portal.kernel.exception.SystemException {
4421                    return getPersistence()
4422                                       .findByU_C_C(userId, classNameId, classPK, start, end);
4423            }
4424    
4425            /**
4426            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4427            *
4428            * <p>
4429            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4430            * </p>
4431            *
4432            * @param userId the user ID
4433            * @param classNameId the class name ID
4434            * @param classPK the class p k
4435            * @param start the lower bound of the range of message-boards messages
4436            * @param end the upper bound of the range of message-boards messages (not inclusive)
4437            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4438            * @return the ordered range of matching message-boards messages
4439            * @throws SystemException if a system exception occurred
4440            */
4441            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C(
4442                    long userId, long classNameId, long classPK, int start, int end,
4443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4444                    throws com.liferay.portal.kernel.exception.SystemException {
4445                    return getPersistence()
4446                                       .findByU_C_C(userId, classNameId, classPK, start, end,
4447                            orderByComparator);
4448            }
4449    
4450            /**
4451            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4452            *
4453            * @param userId the user ID
4454            * @param classNameId the class name ID
4455            * @param classPK the class p k
4456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4457            * @return the first matching message-boards message
4458            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4459            * @throws SystemException if a system exception occurred
4460            */
4461            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_C_First(
4462                    long userId, long classNameId, long classPK,
4463                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4464                    throws com.liferay.portal.kernel.exception.SystemException,
4465                            com.liferay.portlet.messageboards.NoSuchMessageException {
4466                    return getPersistence()
4467                                       .findByU_C_C_First(userId, classNameId, classPK,
4468                            orderByComparator);
4469            }
4470    
4471            /**
4472            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4473            *
4474            * @param userId the user ID
4475            * @param classNameId the class name ID
4476            * @param classPK the class p k
4477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4478            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4479            * @throws SystemException if a system exception occurred
4480            */
4481            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_C_First(
4482                    long userId, long classNameId, long classPK,
4483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4484                    throws com.liferay.portal.kernel.exception.SystemException {
4485                    return getPersistence()
4486                                       .fetchByU_C_C_First(userId, classNameId, classPK,
4487                            orderByComparator);
4488            }
4489    
4490            /**
4491            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4492            *
4493            * @param userId the user ID
4494            * @param classNameId the class name ID
4495            * @param classPK the class p k
4496            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4497            * @return the last matching message-boards message
4498            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4499            * @throws SystemException if a system exception occurred
4500            */
4501            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_C_Last(
4502                    long userId, long classNameId, long classPK,
4503                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4504                    throws com.liferay.portal.kernel.exception.SystemException,
4505                            com.liferay.portlet.messageboards.NoSuchMessageException {
4506                    return getPersistence()
4507                                       .findByU_C_C_Last(userId, classNameId, classPK,
4508                            orderByComparator);
4509            }
4510    
4511            /**
4512            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4513            *
4514            * @param userId the user ID
4515            * @param classNameId the class name ID
4516            * @param classPK the class p k
4517            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4518            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4519            * @throws SystemException if a system exception occurred
4520            */
4521            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_C_Last(
4522                    long userId, long classNameId, long classPK,
4523                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4524                    throws com.liferay.portal.kernel.exception.SystemException {
4525                    return getPersistence()
4526                                       .fetchByU_C_C_Last(userId, classNameId, classPK,
4527                            orderByComparator);
4528            }
4529    
4530            /**
4531            * 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;.
4532            *
4533            * @param messageId the primary key of the current message-boards message
4534            * @param userId the user ID
4535            * @param classNameId the class name ID
4536            * @param classPK the class p k
4537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4538            * @return the previous, current, and next message-boards message
4539            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
4540            * @throws SystemException if a system exception occurred
4541            */
4542            public static com.liferay.portlet.messageboards.model.MBMessage[] findByU_C_C_PrevAndNext(
4543                    long messageId, long userId, long classNameId, long classPK,
4544                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4545                    throws com.liferay.portal.kernel.exception.SystemException,
4546                            com.liferay.portlet.messageboards.NoSuchMessageException {
4547                    return getPersistence()
4548                                       .findByU_C_C_PrevAndNext(messageId, userId, classNameId,
4549                            classPK, orderByComparator);
4550            }
4551    
4552            /**
4553            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
4554            *
4555            * @param userId the user ID
4556            * @param classNameId the class name ID
4557            * @param classPK the class p k
4558            * @throws SystemException if a system exception occurred
4559            */
4560            public static void removeByU_C_C(long userId, long classNameId, long classPK)
4561                    throws com.liferay.portal.kernel.exception.SystemException {
4562                    getPersistence().removeByU_C_C(userId, classNameId, classPK);
4563            }
4564    
4565            /**
4566            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
4567            *
4568            * @param userId the user ID
4569            * @param classNameId the class name ID
4570            * @param classPK the class p k
4571            * @return the number of matching message-boards messages
4572            * @throws SystemException if a system exception occurred
4573            */
4574            public static int countByU_C_C(long userId, long classNameId, long classPK)
4575                    throws com.liferay.portal.kernel.exception.SystemException {
4576                    return getPersistence().countByU_C_C(userId, classNameId, classPK);
4577            }
4578    
4579            /**
4580            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
4581            *
4582            * @param userId the user ID
4583            * @param classNameId the class name ID
4584            * @param status the status
4585            * @return the matching message-boards messages
4586            * @throws SystemException if a system exception occurred
4587            */
4588            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4589                    long userId, long classNameId, int status)
4590                    throws com.liferay.portal.kernel.exception.SystemException {
4591                    return getPersistence().findByU_C_S(userId, classNameId, status);
4592            }
4593    
4594            /**
4595            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
4596            *
4597            * <p>
4598            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4599            * </p>
4600            *
4601            * @param userId the user ID
4602            * @param classNameId the class name ID
4603            * @param status the status
4604            * @param start the lower bound of the range of message-boards messages
4605            * @param end the upper bound of the range of message-boards messages (not inclusive)
4606            * @return the range of matching message-boards messages
4607            * @throws SystemException if a system exception occurred
4608            */
4609            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4610                    long userId, long classNameId, int status, int start, int end)
4611                    throws com.liferay.portal.kernel.exception.SystemException {
4612                    return getPersistence()
4613                                       .findByU_C_S(userId, classNameId, status, start, end);
4614            }
4615    
4616            /**
4617            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
4618            *
4619            * <p>
4620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4621            * </p>
4622            *
4623            * @param userId the user ID
4624            * @param classNameId the class name ID
4625            * @param status the status
4626            * @param start the lower bound of the range of message-boards messages
4627            * @param end the upper bound of the range of message-boards messages (not inclusive)
4628            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4629            * @return the ordered range of matching message-boards messages
4630            * @throws SystemException if a system exception occurred
4631            */
4632            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4633                    long userId, long classNameId, int status, int start, int end,
4634                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4635                    throws com.liferay.portal.kernel.exception.SystemException {
4636                    return getPersistence()
4637                                       .findByU_C_S(userId, classNameId, status, start, end,
4638                            orderByComparator);
4639            }
4640    
4641            /**
4642            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
4643            *
4644            * @param userId the user ID
4645            * @param classNameId the class name ID
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
4649            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4650            * @throws SystemException if a system exception occurred
4651            */
4652            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_S_First(
4653                    long userId, long classNameId, int status,
4654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4655                    throws com.liferay.portal.kernel.exception.SystemException,
4656                            com.liferay.portlet.messageboards.NoSuchMessageException {
4657                    return getPersistence()
4658                                       .findByU_C_S_First(userId, classNameId, status,
4659                            orderByComparator);
4660            }
4661    
4662            /**
4663            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
4664            *
4665            * @param userId the user ID
4666            * @param classNameId the class name ID
4667            * @param status the status
4668            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4669            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4670            * @throws SystemException if a system exception occurred
4671            */
4672            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_S_First(
4673                    long userId, long classNameId, int status,
4674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4675                    throws com.liferay.portal.kernel.exception.SystemException {
4676                    return getPersistence()
4677                                       .fetchByU_C_S_First(userId, classNameId, status,
4678                            orderByComparator);
4679            }
4680    
4681            /**
4682            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
4683            *
4684            * @param userId the user ID
4685            * @param classNameId the class name ID
4686            * @param status the status
4687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4688            * @return the last matching message-boards message
4689            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4690            * @throws SystemException if a system exception occurred
4691            */
4692            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_S_Last(
4693                    long userId, long classNameId, int status,
4694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4695                    throws com.liferay.portal.kernel.exception.SystemException,
4696                            com.liferay.portlet.messageboards.NoSuchMessageException {
4697                    return getPersistence()
4698                                       .findByU_C_S_Last(userId, classNameId, status,
4699                            orderByComparator);
4700            }
4701    
4702            /**
4703            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
4704            *
4705            * @param userId the user ID
4706            * @param classNameId the class name ID
4707            * @param status the status
4708            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4709            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4710            * @throws SystemException if a system exception occurred
4711            */
4712            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_S_Last(
4713                    long userId, long classNameId, int status,
4714                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4715                    throws com.liferay.portal.kernel.exception.SystemException {
4716                    return getPersistence()
4717                                       .fetchByU_C_S_Last(userId, classNameId, status,
4718                            orderByComparator);
4719            }
4720    
4721            /**
4722            * 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;.
4723            *
4724            * @param messageId the primary key of the current message-boards message
4725            * @param userId the user ID
4726            * @param classNameId the class name ID
4727            * @param status the status
4728            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4729            * @return the previous, current, and next message-boards message
4730            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
4731            * @throws SystemException if a system exception occurred
4732            */
4733            public static com.liferay.portlet.messageboards.model.MBMessage[] findByU_C_S_PrevAndNext(
4734                    long messageId, long userId, long classNameId, int status,
4735                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4736                    throws com.liferay.portal.kernel.exception.SystemException,
4737                            com.liferay.portlet.messageboards.NoSuchMessageException {
4738                    return getPersistence()
4739                                       .findByU_C_S_PrevAndNext(messageId, userId, classNameId,
4740                            status, orderByComparator);
4741            }
4742    
4743            /**
4744            * Returns all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
4745            *
4746            * <p>
4747            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4748            * </p>
4749            *
4750            * @param userId the user ID
4751            * @param classNameIds the class name IDs
4752            * @param status the status
4753            * @return the matching message-boards messages
4754            * @throws SystemException if a system exception occurred
4755            */
4756            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4757                    long userId, long[] classNameIds, int status)
4758                    throws com.liferay.portal.kernel.exception.SystemException {
4759                    return getPersistence().findByU_C_S(userId, classNameIds, status);
4760            }
4761    
4762            /**
4763            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
4764            *
4765            * <p>
4766            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4767            * </p>
4768            *
4769            * @param userId the user ID
4770            * @param classNameIds the class name IDs
4771            * @param status the status
4772            * @param start the lower bound of the range of message-boards messages
4773            * @param end the upper bound of the range of message-boards messages (not inclusive)
4774            * @return the range of matching message-boards messages
4775            * @throws SystemException if a system exception occurred
4776            */
4777            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4778                    long userId, long[] classNameIds, int status, int start, int end)
4779                    throws com.liferay.portal.kernel.exception.SystemException {
4780                    return getPersistence()
4781                                       .findByU_C_S(userId, classNameIds, status, start, end);
4782            }
4783    
4784            /**
4785            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
4786            *
4787            * <p>
4788            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4789            * </p>
4790            *
4791            * @param userId the user ID
4792            * @param classNameIds the class name IDs
4793            * @param status the status
4794            * @param start the lower bound of the range of message-boards messages
4795            * @param end the upper bound of the range of message-boards messages (not inclusive)
4796            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4797            * @return the ordered range of matching message-boards messages
4798            * @throws SystemException if a system exception occurred
4799            */
4800            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_S(
4801                    long userId, long[] classNameIds, int status, int start, int end,
4802                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4803                    throws com.liferay.portal.kernel.exception.SystemException {
4804                    return getPersistence()
4805                                       .findByU_C_S(userId, classNameIds, status, start, end,
4806                            orderByComparator);
4807            }
4808    
4809            /**
4810            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63; from the database.
4811            *
4812            * @param userId the user ID
4813            * @param classNameId the class name ID
4814            * @param status the status
4815            * @throws SystemException if a system exception occurred
4816            */
4817            public static void removeByU_C_S(long userId, long classNameId, int status)
4818                    throws com.liferay.portal.kernel.exception.SystemException {
4819                    getPersistence().removeByU_C_S(userId, classNameId, status);
4820            }
4821    
4822            /**
4823            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
4824            *
4825            * @param userId the user ID
4826            * @param classNameId the class name ID
4827            * @param status the status
4828            * @return the number of matching message-boards messages
4829            * @throws SystemException if a system exception occurred
4830            */
4831            public static int countByU_C_S(long userId, long classNameId, int status)
4832                    throws com.liferay.portal.kernel.exception.SystemException {
4833                    return getPersistence().countByU_C_S(userId, classNameId, status);
4834            }
4835    
4836            /**
4837            * Returns the number of message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
4838            *
4839            * @param userId the user ID
4840            * @param classNameIds the class name IDs
4841            * @param status the status
4842            * @return the number of matching message-boards messages
4843            * @throws SystemException if a system exception occurred
4844            */
4845            public static int countByU_C_S(long userId, long[] classNameIds, int status)
4846                    throws com.liferay.portal.kernel.exception.SystemException {
4847                    return getPersistence().countByU_C_S(userId, classNameIds, status);
4848            }
4849    
4850            /**
4851            * Returns all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
4852            *
4853            * @param classNameId the class name ID
4854            * @param classPK the class p k
4855            * @param status the status
4856            * @return the matching message-boards messages
4857            * @throws SystemException if a system exception occurred
4858            */
4859            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
4860                    long classNameId, long classPK, int status)
4861                    throws com.liferay.portal.kernel.exception.SystemException {
4862                    return getPersistence().findByC_C_S(classNameId, classPK, status);
4863            }
4864    
4865            /**
4866            * Returns a range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
4867            *
4868            * <p>
4869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4870            * </p>
4871            *
4872            * @param classNameId the class name ID
4873            * @param classPK the class p k
4874            * @param status the status
4875            * @param start the lower bound of the range of message-boards messages
4876            * @param end the upper bound of the range of message-boards messages (not inclusive)
4877            * @return the range of matching message-boards messages
4878            * @throws SystemException if a system exception occurred
4879            */
4880            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
4881                    long classNameId, long classPK, int status, int start, int end)
4882                    throws com.liferay.portal.kernel.exception.SystemException {
4883                    return getPersistence()
4884                                       .findByC_C_S(classNameId, classPK, status, start, end);
4885            }
4886    
4887            /**
4888            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
4889            *
4890            * <p>
4891            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
4892            * </p>
4893            *
4894            * @param classNameId the class name ID
4895            * @param classPK the class p k
4896            * @param status the status
4897            * @param start the lower bound of the range of message-boards messages
4898            * @param end the upper bound of the range of message-boards messages (not inclusive)
4899            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4900            * @return the ordered range of matching message-boards messages
4901            * @throws SystemException if a system exception occurred
4902            */
4903            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
4904                    long classNameId, long classPK, int status, int start, int end,
4905                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4906                    throws com.liferay.portal.kernel.exception.SystemException {
4907                    return getPersistence()
4908                                       .findByC_C_S(classNameId, classPK, status, start, end,
4909                            orderByComparator);
4910            }
4911    
4912            /**
4913            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4914            *
4915            * @param classNameId the class name ID
4916            * @param classPK the class p k
4917            * @param status the status
4918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4919            * @return the first matching message-boards message
4920            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4921            * @throws SystemException if a system exception occurred
4922            */
4923            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_First(
4924                    long classNameId, long classPK, int status,
4925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4926                    throws com.liferay.portal.kernel.exception.SystemException,
4927                            com.liferay.portlet.messageboards.NoSuchMessageException {
4928                    return getPersistence()
4929                                       .findByC_C_S_First(classNameId, classPK, status,
4930                            orderByComparator);
4931            }
4932    
4933            /**
4934            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4935            *
4936            * @param classNameId the class name ID
4937            * @param classPK the class p k
4938            * @param status the status
4939            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4940            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4941            * @throws SystemException if a system exception occurred
4942            */
4943            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_C_S_First(
4944                    long classNameId, long classPK, int status,
4945                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4946                    throws com.liferay.portal.kernel.exception.SystemException {
4947                    return getPersistence()
4948                                       .fetchByC_C_S_First(classNameId, classPK, status,
4949                            orderByComparator);
4950            }
4951    
4952            /**
4953            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4954            *
4955            * @param classNameId the class name ID
4956            * @param classPK the class p k
4957            * @param status the status
4958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4959            * @return the last matching message-boards message
4960            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
4961            * @throws SystemException if a system exception occurred
4962            */
4963            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_Last(
4964                    long classNameId, long classPK, int status,
4965                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4966                    throws com.liferay.portal.kernel.exception.SystemException,
4967                            com.liferay.portlet.messageboards.NoSuchMessageException {
4968                    return getPersistence()
4969                                       .findByC_C_S_Last(classNameId, classPK, status,
4970                            orderByComparator);
4971            }
4972    
4973            /**
4974            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4975            *
4976            * @param classNameId the class name ID
4977            * @param classPK the class p k
4978            * @param status the status
4979            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4980            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4981            * @throws SystemException if a system exception occurred
4982            */
4983            public static com.liferay.portlet.messageboards.model.MBMessage fetchByC_C_S_Last(
4984                    long classNameId, long classPK, int status,
4985                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4986                    throws com.liferay.portal.kernel.exception.SystemException {
4987                    return getPersistence()
4988                                       .fetchByC_C_S_Last(classNameId, classPK, status,
4989                            orderByComparator);
4990            }
4991    
4992            /**
4993            * 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;.
4994            *
4995            * @param messageId the primary key of the current message-boards message
4996            * @param classNameId the class name ID
4997            * @param classPK the class p k
4998            * @param status the status
4999            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5000            * @return the previous, current, and next message-boards message
5001            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
5002            * @throws SystemException if a system exception occurred
5003            */
5004            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_S_PrevAndNext(
5005                    long messageId, long classNameId, long classPK, int status,
5006                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5007                    throws com.liferay.portal.kernel.exception.SystemException,
5008                            com.liferay.portlet.messageboards.NoSuchMessageException {
5009                    return getPersistence()
5010                                       .findByC_C_S_PrevAndNext(messageId, classNameId, classPK,
5011                            status, orderByComparator);
5012            }
5013    
5014            /**
5015            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63; from the database.
5016            *
5017            * @param classNameId the class name ID
5018            * @param classPK the class p k
5019            * @param status the status
5020            * @throws SystemException if a system exception occurred
5021            */
5022            public static void removeByC_C_S(long classNameId, long classPK, int status)
5023                    throws com.liferay.portal.kernel.exception.SystemException {
5024                    getPersistence().removeByC_C_S(classNameId, classPK, status);
5025            }
5026    
5027            /**
5028            * Returns the number of message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
5029            *
5030            * @param classNameId the class name ID
5031            * @param classPK the class p k
5032            * @param status the status
5033            * @return the number of matching message-boards messages
5034            * @throws SystemException if a system exception occurred
5035            */
5036            public static int countByC_C_S(long classNameId, long classPK, int status)
5037                    throws com.liferay.portal.kernel.exception.SystemException {
5038                    return getPersistence().countByC_C_S(classNameId, classPK, status);
5039            }
5040    
5041            /**
5042            * Returns all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5043            *
5044            * @param groupId the group ID
5045            * @param userId the user ID
5046            * @param categoryId the category ID
5047            * @param status the status
5048            * @return the matching message-boards messages
5049            * @throws SystemException if a system exception occurred
5050            */
5051            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5052                    long groupId, long userId, long categoryId, int status)
5053                    throws com.liferay.portal.kernel.exception.SystemException {
5054                    return getPersistence()
5055                                       .findByG_U_C_S(groupId, userId, categoryId, status);
5056            }
5057    
5058            /**
5059            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5060            *
5061            * <p>
5062            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5063            * </p>
5064            *
5065            * @param groupId the group ID
5066            * @param userId the user ID
5067            * @param categoryId the category ID
5068            * @param status the status
5069            * @param start the lower bound of the range of message-boards messages
5070            * @param end the upper bound of the range of message-boards messages (not inclusive)
5071            * @return the range of matching message-boards messages
5072            * @throws SystemException if a system exception occurred
5073            */
5074            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5075                    long groupId, long userId, long categoryId, int status, int start,
5076                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5077                    return getPersistence()
5078                                       .findByG_U_C_S(groupId, userId, categoryId, status, start,
5079                            end);
5080            }
5081    
5082            /**
5083            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5084            *
5085            * <p>
5086            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5087            * </p>
5088            *
5089            * @param groupId the group ID
5090            * @param userId the user ID
5091            * @param categoryId the category ID
5092            * @param status the status
5093            * @param start the lower bound of the range of message-boards messages
5094            * @param end the upper bound of the range of message-boards messages (not inclusive)
5095            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5096            * @return the ordered range of matching message-boards messages
5097            * @throws SystemException if a system exception occurred
5098            */
5099            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5100                    long groupId, long userId, long categoryId, int status, int start,
5101                    int end,
5102                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5103                    throws com.liferay.portal.kernel.exception.SystemException {
5104                    return getPersistence()
5105                                       .findByG_U_C_S(groupId, userId, categoryId, status, start,
5106                            end, orderByComparator);
5107            }
5108    
5109            /**
5110            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5111            *
5112            * @param groupId the group ID
5113            * @param userId the user ID
5114            * @param categoryId the category ID
5115            * @param status the status
5116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5117            * @return the first matching message-boards message
5118            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5119            * @throws SystemException if a system exception occurred
5120            */
5121            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_C_S_First(
5122                    long groupId, long userId, long categoryId, int status,
5123                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5124                    throws com.liferay.portal.kernel.exception.SystemException,
5125                            com.liferay.portlet.messageboards.NoSuchMessageException {
5126                    return getPersistence()
5127                                       .findByG_U_C_S_First(groupId, userId, categoryId, status,
5128                            orderByComparator);
5129            }
5130    
5131            /**
5132            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5133            *
5134            * @param groupId the group ID
5135            * @param userId the user ID
5136            * @param categoryId the category ID
5137            * @param status the status
5138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5139            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5140            * @throws SystemException if a system exception occurred
5141            */
5142            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_C_S_First(
5143                    long groupId, long userId, long categoryId, int status,
5144                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5145                    throws com.liferay.portal.kernel.exception.SystemException {
5146                    return getPersistence()
5147                                       .fetchByG_U_C_S_First(groupId, userId, categoryId, status,
5148                            orderByComparator);
5149            }
5150    
5151            /**
5152            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5153            *
5154            * @param groupId the group ID
5155            * @param userId the user ID
5156            * @param categoryId the category ID
5157            * @param status the status
5158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5159            * @return the last matching message-boards message
5160            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5161            * @throws SystemException if a system exception occurred
5162            */
5163            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_C_S_Last(
5164                    long groupId, long userId, long categoryId, int status,
5165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5166                    throws com.liferay.portal.kernel.exception.SystemException,
5167                            com.liferay.portlet.messageboards.NoSuchMessageException {
5168                    return getPersistence()
5169                                       .findByG_U_C_S_Last(groupId, userId, categoryId, status,
5170                            orderByComparator);
5171            }
5172    
5173            /**
5174            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5175            *
5176            * @param groupId the group ID
5177            * @param userId the user ID
5178            * @param categoryId the category ID
5179            * @param status the status
5180            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5181            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5182            * @throws SystemException if a system exception occurred
5183            */
5184            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_U_C_S_Last(
5185                    long groupId, long userId, long categoryId, int status,
5186                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5187                    throws com.liferay.portal.kernel.exception.SystemException {
5188                    return getPersistence()
5189                                       .fetchByG_U_C_S_Last(groupId, userId, categoryId, status,
5190                            orderByComparator);
5191            }
5192    
5193            /**
5194            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5195            *
5196            * @param messageId the primary key of the current message-boards message
5197            * @param groupId the group ID
5198            * @param userId the user ID
5199            * @param categoryId the category ID
5200            * @param status the status
5201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5202            * @return the previous, current, and next message-boards message
5203            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
5204            * @throws SystemException if a system exception occurred
5205            */
5206            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_C_S_PrevAndNext(
5207                    long messageId, long groupId, long userId, long categoryId, int status,
5208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5209                    throws com.liferay.portal.kernel.exception.SystemException,
5210                            com.liferay.portlet.messageboards.NoSuchMessageException {
5211                    return getPersistence()
5212                                       .findByG_U_C_S_PrevAndNext(messageId, groupId, userId,
5213                            categoryId, status, orderByComparator);
5214            }
5215    
5216            /**
5217            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5218            *
5219            * @param groupId the group ID
5220            * @param userId the user ID
5221            * @param categoryId the category ID
5222            * @param status the status
5223            * @return the matching message-boards messages that the user has permission to view
5224            * @throws SystemException if a system exception occurred
5225            */
5226            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5227                    long groupId, long userId, long categoryId, int status)
5228                    throws com.liferay.portal.kernel.exception.SystemException {
5229                    return getPersistence()
5230                                       .filterFindByG_U_C_S(groupId, userId, categoryId, status);
5231            }
5232    
5233            /**
5234            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5235            *
5236            * <p>
5237            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5238            * </p>
5239            *
5240            * @param groupId the group ID
5241            * @param userId the user ID
5242            * @param categoryId the category ID
5243            * @param status the status
5244            * @param start the lower bound of the range of message-boards messages
5245            * @param end the upper bound of the range of message-boards messages (not inclusive)
5246            * @return the range of matching message-boards messages that the user has permission to view
5247            * @throws SystemException if a system exception occurred
5248            */
5249            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5250                    long groupId, long userId, long categoryId, int status, int start,
5251                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5252                    return getPersistence()
5253                                       .filterFindByG_U_C_S(groupId, userId, categoryId, status,
5254                            start, end);
5255            }
5256    
5257            /**
5258            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5259            *
5260            * <p>
5261            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5262            * </p>
5263            *
5264            * @param groupId the group ID
5265            * @param userId the user ID
5266            * @param categoryId the category ID
5267            * @param status the status
5268            * @param start the lower bound of the range of message-boards messages
5269            * @param end the upper bound of the range of message-boards messages (not inclusive)
5270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5271            * @return the ordered range of matching message-boards messages that the user has permission to view
5272            * @throws SystemException if a system exception occurred
5273            */
5274            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5275                    long groupId, long userId, long categoryId, int status, int start,
5276                    int end,
5277                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5278                    throws com.liferay.portal.kernel.exception.SystemException {
5279                    return getPersistence()
5280                                       .filterFindByG_U_C_S(groupId, userId, categoryId, status,
5281                            start, end, orderByComparator);
5282            }
5283    
5284            /**
5285            * 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 categoryId = &#63; and status = &#63;.
5286            *
5287            * @param messageId the primary key of the current message-boards message
5288            * @param groupId the group ID
5289            * @param userId the user ID
5290            * @param categoryId the category ID
5291            * @param status the status
5292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5293            * @return the previous, current, and next message-boards message
5294            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
5295            * @throws SystemException if a system exception occurred
5296            */
5297            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_U_C_S_PrevAndNext(
5298                    long messageId, long groupId, long userId, long categoryId, int status,
5299                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5300                    throws com.liferay.portal.kernel.exception.SystemException,
5301                            com.liferay.portlet.messageboards.NoSuchMessageException {
5302                    return getPersistence()
5303                                       .filterFindByG_U_C_S_PrevAndNext(messageId, groupId, userId,
5304                            categoryId, status, orderByComparator);
5305            }
5306    
5307            /**
5308            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5309            *
5310            * @param groupId the group ID
5311            * @param userId the user ID
5312            * @param categoryIds the category IDs
5313            * @param status the status
5314            * @return the matching message-boards messages that the user has permission to view
5315            * @throws SystemException if a system exception occurred
5316            */
5317            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5318                    long groupId, long userId, long[] categoryIds, int status)
5319                    throws com.liferay.portal.kernel.exception.SystemException {
5320                    return getPersistence()
5321                                       .filterFindByG_U_C_S(groupId, userId, categoryIds, status);
5322            }
5323    
5324            /**
5325            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5326            *
5327            * <p>
5328            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5329            * </p>
5330            *
5331            * @param groupId the group ID
5332            * @param userId the user ID
5333            * @param categoryIds the category IDs
5334            * @param status the status
5335            * @param start the lower bound of the range of message-boards messages
5336            * @param end the upper bound of the range of message-boards messages (not inclusive)
5337            * @return the range of matching message-boards messages that the user has permission to view
5338            * @throws SystemException if a system exception occurred
5339            */
5340            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5341                    long groupId, long userId, long[] categoryIds, int status, int start,
5342                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5343                    return getPersistence()
5344                                       .filterFindByG_U_C_S(groupId, userId, categoryIds, status,
5345                            start, end);
5346            }
5347    
5348            /**
5349            * Returns an ordered range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5350            *
5351            * <p>
5352            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5353            * </p>
5354            *
5355            * @param groupId the group ID
5356            * @param userId the user ID
5357            * @param categoryIds the category IDs
5358            * @param status the status
5359            * @param start the lower bound of the range of message-boards messages
5360            * @param end the upper bound of the range of message-boards messages (not inclusive)
5361            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5362            * @return the ordered range of matching message-boards messages that the user has permission to view
5363            * @throws SystemException if a system exception occurred
5364            */
5365            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_C_S(
5366                    long groupId, long userId, long[] categoryIds, int status, int start,
5367                    int end,
5368                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5369                    throws com.liferay.portal.kernel.exception.SystemException {
5370                    return getPersistence()
5371                                       .filterFindByG_U_C_S(groupId, userId, categoryIds, status,
5372                            start, end, orderByComparator);
5373            }
5374    
5375            /**
5376            * Returns all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5377            *
5378            * <p>
5379            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5380            * </p>
5381            *
5382            * @param groupId the group ID
5383            * @param userId the user ID
5384            * @param categoryIds the category IDs
5385            * @param status the status
5386            * @return the matching message-boards messages
5387            * @throws SystemException if a system exception occurred
5388            */
5389            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5390                    long groupId, long userId, long[] categoryIds, int status)
5391                    throws com.liferay.portal.kernel.exception.SystemException {
5392                    return getPersistence()
5393                                       .findByG_U_C_S(groupId, userId, categoryIds, status);
5394            }
5395    
5396            /**
5397            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5398            *
5399            * <p>
5400            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5401            * </p>
5402            *
5403            * @param groupId the group ID
5404            * @param userId the user ID
5405            * @param categoryIds the category IDs
5406            * @param status the status
5407            * @param start the lower bound of the range of message-boards messages
5408            * @param end the upper bound of the range of message-boards messages (not inclusive)
5409            * @return the range of matching message-boards messages
5410            * @throws SystemException if a system exception occurred
5411            */
5412            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5413                    long groupId, long userId, long[] categoryIds, int status, int start,
5414                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5415                    return getPersistence()
5416                                       .findByG_U_C_S(groupId, userId, categoryIds, status, start,
5417                            end);
5418            }
5419    
5420            /**
5421            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5422            *
5423            * <p>
5424            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5425            * </p>
5426            *
5427            * @param groupId the group ID
5428            * @param userId the user ID
5429            * @param categoryIds the category IDs
5430            * @param status the status
5431            * @param start the lower bound of the range of message-boards messages
5432            * @param end the upper bound of the range of message-boards messages (not inclusive)
5433            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5434            * @return the ordered range of matching message-boards messages
5435            * @throws SystemException if a system exception occurred
5436            */
5437            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_C_S(
5438                    long groupId, long userId, long[] categoryIds, int status, int start,
5439                    int end,
5440                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5441                    throws com.liferay.portal.kernel.exception.SystemException {
5442                    return getPersistence()
5443                                       .findByG_U_C_S(groupId, userId, categoryIds, status, start,
5444                            end, orderByComparator);
5445            }
5446    
5447            /**
5448            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63; from the database.
5449            *
5450            * @param groupId the group ID
5451            * @param userId the user ID
5452            * @param categoryId the category ID
5453            * @param status the status
5454            * @throws SystemException if a system exception occurred
5455            */
5456            public static void removeByG_U_C_S(long groupId, long userId,
5457                    long categoryId, int status)
5458                    throws com.liferay.portal.kernel.exception.SystemException {
5459                    getPersistence().removeByG_U_C_S(groupId, userId, categoryId, status);
5460            }
5461    
5462            /**
5463            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5464            *
5465            * @param groupId the group ID
5466            * @param userId the user ID
5467            * @param categoryId the category ID
5468            * @param status the status
5469            * @return the number of matching message-boards messages
5470            * @throws SystemException if a system exception occurred
5471            */
5472            public static int countByG_U_C_S(long groupId, long userId,
5473                    long categoryId, int status)
5474                    throws com.liferay.portal.kernel.exception.SystemException {
5475                    return getPersistence()
5476                                       .countByG_U_C_S(groupId, userId, categoryId, status);
5477            }
5478    
5479            /**
5480            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5481            *
5482            * @param groupId the group ID
5483            * @param userId the user ID
5484            * @param categoryIds the category IDs
5485            * @param status the status
5486            * @return the number of matching message-boards messages
5487            * @throws SystemException if a system exception occurred
5488            */
5489            public static int countByG_U_C_S(long groupId, long userId,
5490                    long[] categoryIds, int status)
5491                    throws com.liferay.portal.kernel.exception.SystemException {
5492                    return getPersistence()
5493                                       .countByG_U_C_S(groupId, userId, categoryIds, status);
5494            }
5495    
5496            /**
5497            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = &#63; and status = &#63;.
5498            *
5499            * @param groupId the group ID
5500            * @param userId the user ID
5501            * @param categoryId the category ID
5502            * @param status the status
5503            * @return the number of matching message-boards messages that the user has permission to view
5504            * @throws SystemException if a system exception occurred
5505            */
5506            public static int filterCountByG_U_C_S(long groupId, long userId,
5507                    long categoryId, int status)
5508                    throws com.liferay.portal.kernel.exception.SystemException {
5509                    return getPersistence()
5510                                       .filterCountByG_U_C_S(groupId, userId, categoryId, status);
5511            }
5512    
5513            /**
5514            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and categoryId = any &#63; and status = &#63;.
5515            *
5516            * @param groupId the group ID
5517            * @param userId the user ID
5518            * @param categoryIds the category IDs
5519            * @param status the status
5520            * @return the number of matching message-boards messages that the user has permission to view
5521            * @throws SystemException if a system exception occurred
5522            */
5523            public static int filterCountByG_U_C_S(long groupId, long userId,
5524                    long[] categoryIds, int status)
5525                    throws com.liferay.portal.kernel.exception.SystemException {
5526                    return getPersistence()
5527                                       .filterCountByG_U_C_S(groupId, userId, categoryIds, status);
5528            }
5529    
5530            /**
5531            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5532            *
5533            * @param groupId the group ID
5534            * @param categoryId the category ID
5535            * @param threadId the thread ID
5536            * @param answer the answer
5537            * @return the matching message-boards messages
5538            * @throws SystemException if a system exception occurred
5539            */
5540            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_A(
5541                    long groupId, long categoryId, long threadId, boolean answer)
5542                    throws com.liferay.portal.kernel.exception.SystemException {
5543                    return getPersistence()
5544                                       .findByG_C_T_A(groupId, categoryId, threadId, answer);
5545            }
5546    
5547            /**
5548            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5549            *
5550            * <p>
5551            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5552            * </p>
5553            *
5554            * @param groupId the group ID
5555            * @param categoryId the category ID
5556            * @param threadId the thread ID
5557            * @param answer the answer
5558            * @param start the lower bound of the range of message-boards messages
5559            * @param end the upper bound of the range of message-boards messages (not inclusive)
5560            * @return the range of matching message-boards messages
5561            * @throws SystemException if a system exception occurred
5562            */
5563            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_A(
5564                    long groupId, long categoryId, long threadId, boolean answer,
5565                    int start, int end)
5566                    throws com.liferay.portal.kernel.exception.SystemException {
5567                    return getPersistence()
5568                                       .findByG_C_T_A(groupId, categoryId, threadId, answer, start,
5569                            end);
5570            }
5571    
5572            /**
5573            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5574            *
5575            * <p>
5576            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5577            * </p>
5578            *
5579            * @param groupId the group ID
5580            * @param categoryId the category ID
5581            * @param threadId the thread ID
5582            * @param answer the answer
5583            * @param start the lower bound of the range of message-boards messages
5584            * @param end the upper bound of the range of message-boards messages (not inclusive)
5585            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5586            * @return the ordered range of matching message-boards messages
5587            * @throws SystemException if a system exception occurred
5588            */
5589            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_A(
5590                    long groupId, long categoryId, long threadId, boolean answer,
5591                    int start, int end,
5592                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5593                    throws com.liferay.portal.kernel.exception.SystemException {
5594                    return getPersistence()
5595                                       .findByG_C_T_A(groupId, categoryId, threadId, answer, start,
5596                            end, orderByComparator);
5597            }
5598    
5599            /**
5600            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5601            *
5602            * @param groupId the group ID
5603            * @param categoryId the category ID
5604            * @param threadId the thread ID
5605            * @param answer the answer
5606            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5607            * @return the first matching message-boards message
5608            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5609            * @throws SystemException if a system exception occurred
5610            */
5611            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_A_First(
5612                    long groupId, long categoryId, long threadId, boolean answer,
5613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5614                    throws com.liferay.portal.kernel.exception.SystemException,
5615                            com.liferay.portlet.messageboards.NoSuchMessageException {
5616                    return getPersistence()
5617                                       .findByG_C_T_A_First(groupId, categoryId, threadId, answer,
5618                            orderByComparator);
5619            }
5620    
5621            /**
5622            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5623            *
5624            * @param groupId the group ID
5625            * @param categoryId the category ID
5626            * @param threadId the thread ID
5627            * @param answer the answer
5628            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5629            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5630            * @throws SystemException if a system exception occurred
5631            */
5632            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_A_First(
5633                    long groupId, long categoryId, long threadId, boolean answer,
5634                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5635                    throws com.liferay.portal.kernel.exception.SystemException {
5636                    return getPersistence()
5637                                       .fetchByG_C_T_A_First(groupId, categoryId, threadId, answer,
5638                            orderByComparator);
5639            }
5640    
5641            /**
5642            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5643            *
5644            * @param groupId the group ID
5645            * @param categoryId the category ID
5646            * @param threadId the thread ID
5647            * @param answer the answer
5648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5649            * @return the last matching message-boards message
5650            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5651            * @throws SystemException if a system exception occurred
5652            */
5653            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_A_Last(
5654                    long groupId, long categoryId, long threadId, boolean answer,
5655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5656                    throws com.liferay.portal.kernel.exception.SystemException,
5657                            com.liferay.portlet.messageboards.NoSuchMessageException {
5658                    return getPersistence()
5659                                       .findByG_C_T_A_Last(groupId, categoryId, threadId, answer,
5660                            orderByComparator);
5661            }
5662    
5663            /**
5664            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5665            *
5666            * @param groupId the group ID
5667            * @param categoryId the category ID
5668            * @param threadId the thread ID
5669            * @param answer the answer
5670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5671            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5672            * @throws SystemException if a system exception occurred
5673            */
5674            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_A_Last(
5675                    long groupId, long categoryId, long threadId, boolean answer,
5676                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5677                    throws com.liferay.portal.kernel.exception.SystemException {
5678                    return getPersistence()
5679                                       .fetchByG_C_T_A_Last(groupId, categoryId, threadId, answer,
5680                            orderByComparator);
5681            }
5682    
5683            /**
5684            * 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;.
5685            *
5686            * @param messageId the primary key of the current message-boards message
5687            * @param groupId the group ID
5688            * @param categoryId the category ID
5689            * @param threadId the thread ID
5690            * @param answer the answer
5691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5692            * @return the previous, current, and next message-boards message
5693            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
5694            * @throws SystemException if a system exception occurred
5695            */
5696            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_A_PrevAndNext(
5697                    long messageId, long groupId, long categoryId, long threadId,
5698                    boolean answer,
5699                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5700                    throws com.liferay.portal.kernel.exception.SystemException,
5701                            com.liferay.portlet.messageboards.NoSuchMessageException {
5702                    return getPersistence()
5703                                       .findByG_C_T_A_PrevAndNext(messageId, groupId, categoryId,
5704                            threadId, answer, orderByComparator);
5705            }
5706    
5707            /**
5708            * 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;.
5709            *
5710            * @param groupId the group ID
5711            * @param categoryId the category ID
5712            * @param threadId the thread ID
5713            * @param answer the answer
5714            * @return the matching message-boards messages that the user has permission to view
5715            * @throws SystemException if a system exception occurred
5716            */
5717            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_A(
5718                    long groupId, long categoryId, long threadId, boolean answer)
5719                    throws com.liferay.portal.kernel.exception.SystemException {
5720                    return getPersistence()
5721                                       .filterFindByG_C_T_A(groupId, categoryId, threadId, answer);
5722            }
5723    
5724            /**
5725            * 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;.
5726            *
5727            * <p>
5728            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5729            * </p>
5730            *
5731            * @param groupId the group ID
5732            * @param categoryId the category ID
5733            * @param threadId the thread ID
5734            * @param answer the answer
5735            * @param start the lower bound of the range of message-boards messages
5736            * @param end the upper bound of the range of message-boards messages (not inclusive)
5737            * @return the range of matching message-boards messages that the user has permission to view
5738            * @throws SystemException if a system exception occurred
5739            */
5740            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_A(
5741                    long groupId, long categoryId, long threadId, boolean answer,
5742                    int start, int end)
5743                    throws com.liferay.portal.kernel.exception.SystemException {
5744                    return getPersistence()
5745                                       .filterFindByG_C_T_A(groupId, categoryId, threadId, answer,
5746                            start, end);
5747            }
5748    
5749            /**
5750            * 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;.
5751            *
5752            * <p>
5753            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5754            * </p>
5755            *
5756            * @param groupId the group ID
5757            * @param categoryId the category ID
5758            * @param threadId the thread ID
5759            * @param answer the answer
5760            * @param start the lower bound of the range of message-boards messages
5761            * @param end the upper bound of the range of message-boards messages (not inclusive)
5762            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5763            * @return the ordered range of matching message-boards messages that the user has permission to view
5764            * @throws SystemException if a system exception occurred
5765            */
5766            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_A(
5767                    long groupId, long categoryId, long threadId, boolean answer,
5768                    int start, int end,
5769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5770                    throws com.liferay.portal.kernel.exception.SystemException {
5771                    return getPersistence()
5772                                       .filterFindByG_C_T_A(groupId, categoryId, threadId, answer,
5773                            start, end, orderByComparator);
5774            }
5775    
5776            /**
5777            * 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;.
5778            *
5779            * @param messageId the primary key of the current message-boards message
5780            * @param groupId the group ID
5781            * @param categoryId the category ID
5782            * @param threadId the thread ID
5783            * @param answer the answer
5784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5785            * @return the previous, current, and next message-boards message
5786            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
5787            * @throws SystemException if a system exception occurred
5788            */
5789            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_T_A_PrevAndNext(
5790                    long messageId, long groupId, long categoryId, long threadId,
5791                    boolean answer,
5792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5793                    throws com.liferay.portal.kernel.exception.SystemException,
5794                            com.liferay.portlet.messageboards.NoSuchMessageException {
5795                    return getPersistence()
5796                                       .filterFindByG_C_T_A_PrevAndNext(messageId, groupId,
5797                            categoryId, threadId, answer, orderByComparator);
5798            }
5799    
5800            /**
5801            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63; from the database.
5802            *
5803            * @param groupId the group ID
5804            * @param categoryId the category ID
5805            * @param threadId the thread ID
5806            * @param answer the answer
5807            * @throws SystemException if a system exception occurred
5808            */
5809            public static void removeByG_C_T_A(long groupId, long categoryId,
5810                    long threadId, boolean answer)
5811                    throws com.liferay.portal.kernel.exception.SystemException {
5812                    getPersistence().removeByG_C_T_A(groupId, categoryId, threadId, answer);
5813            }
5814    
5815            /**
5816            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
5817            *
5818            * @param groupId the group ID
5819            * @param categoryId the category ID
5820            * @param threadId the thread ID
5821            * @param answer the answer
5822            * @return the number of matching message-boards messages
5823            * @throws SystemException if a system exception occurred
5824            */
5825            public static int countByG_C_T_A(long groupId, long categoryId,
5826                    long threadId, boolean answer)
5827                    throws com.liferay.portal.kernel.exception.SystemException {
5828                    return getPersistence()
5829                                       .countByG_C_T_A(groupId, categoryId, threadId, answer);
5830            }
5831    
5832            /**
5833            * 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;.
5834            *
5835            * @param groupId the group ID
5836            * @param categoryId the category ID
5837            * @param threadId the thread ID
5838            * @param answer the answer
5839            * @return the number of matching message-boards messages that the user has permission to view
5840            * @throws SystemException if a system exception occurred
5841            */
5842            public static int filterCountByG_C_T_A(long groupId, long categoryId,
5843                    long threadId, boolean answer)
5844                    throws com.liferay.portal.kernel.exception.SystemException {
5845                    return getPersistence()
5846                                       .filterCountByG_C_T_A(groupId, categoryId, threadId, answer);
5847            }
5848    
5849            /**
5850            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5851            *
5852            * @param groupId the group ID
5853            * @param categoryId the category ID
5854            * @param threadId the thread ID
5855            * @param status the status
5856            * @return the matching message-boards messages
5857            * @throws SystemException if a system exception occurred
5858            */
5859            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
5860                    long groupId, long categoryId, long threadId, int status)
5861                    throws com.liferay.portal.kernel.exception.SystemException {
5862                    return getPersistence()
5863                                       .findByG_C_T_S(groupId, categoryId, threadId, status);
5864            }
5865    
5866            /**
5867            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5868            *
5869            * <p>
5870            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5871            * </p>
5872            *
5873            * @param groupId the group ID
5874            * @param categoryId the category ID
5875            * @param threadId the thread ID
5876            * @param status the status
5877            * @param start the lower bound of the range of message-boards messages
5878            * @param end the upper bound of the range of message-boards messages (not inclusive)
5879            * @return the range of matching message-boards messages
5880            * @throws SystemException if a system exception occurred
5881            */
5882            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
5883                    long groupId, long categoryId, long threadId, int status, int start,
5884                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5885                    return getPersistence()
5886                                       .findByG_C_T_S(groupId, categoryId, threadId, status, start,
5887                            end);
5888            }
5889    
5890            /**
5891            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5892            *
5893            * <p>
5894            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
5895            * </p>
5896            *
5897            * @param groupId the group ID
5898            * @param categoryId the category ID
5899            * @param threadId the thread ID
5900            * @param status the status
5901            * @param start the lower bound of the range of message-boards messages
5902            * @param end the upper bound of the range of message-boards messages (not inclusive)
5903            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5904            * @return the ordered range of matching message-boards messages
5905            * @throws SystemException if a system exception occurred
5906            */
5907            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
5908                    long groupId, long categoryId, long threadId, int status, int start,
5909                    int end,
5910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5911                    throws com.liferay.portal.kernel.exception.SystemException {
5912                    return getPersistence()
5913                                       .findByG_C_T_S(groupId, categoryId, threadId, status, start,
5914                            end, orderByComparator);
5915            }
5916    
5917            /**
5918            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5919            *
5920            * @param groupId the group ID
5921            * @param categoryId the category ID
5922            * @param threadId the thread ID
5923            * @param status the status
5924            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5925            * @return the first matching message-boards message
5926            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5927            * @throws SystemException if a system exception occurred
5928            */
5929            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_First(
5930                    long groupId, long categoryId, long threadId, int status,
5931                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5932                    throws com.liferay.portal.kernel.exception.SystemException,
5933                            com.liferay.portlet.messageboards.NoSuchMessageException {
5934                    return getPersistence()
5935                                       .findByG_C_T_S_First(groupId, categoryId, threadId, status,
5936                            orderByComparator);
5937            }
5938    
5939            /**
5940            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5941            *
5942            * @param groupId the group ID
5943            * @param categoryId the category ID
5944            * @param threadId the thread ID
5945            * @param status the status
5946            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5947            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5948            * @throws SystemException if a system exception occurred
5949            */
5950            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_S_First(
5951                    long groupId, long categoryId, long threadId, int status,
5952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5953                    throws com.liferay.portal.kernel.exception.SystemException {
5954                    return getPersistence()
5955                                       .fetchByG_C_T_S_First(groupId, categoryId, threadId, status,
5956                            orderByComparator);
5957            }
5958    
5959            /**
5960            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5961            *
5962            * @param groupId the group ID
5963            * @param categoryId the category ID
5964            * @param threadId the thread ID
5965            * @param status the status
5966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5967            * @return the last matching message-boards message
5968            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
5969            * @throws SystemException if a system exception occurred
5970            */
5971            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_Last(
5972                    long groupId, long categoryId, long threadId, int status,
5973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5974                    throws com.liferay.portal.kernel.exception.SystemException,
5975                            com.liferay.portlet.messageboards.NoSuchMessageException {
5976                    return getPersistence()
5977                                       .findByG_C_T_S_Last(groupId, categoryId, threadId, status,
5978                            orderByComparator);
5979            }
5980    
5981            /**
5982            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
5983            *
5984            * @param groupId the group ID
5985            * @param categoryId the category ID
5986            * @param threadId the thread ID
5987            * @param status the status
5988            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5989            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
5990            * @throws SystemException if a system exception occurred
5991            */
5992            public static com.liferay.portlet.messageboards.model.MBMessage fetchByG_C_T_S_Last(
5993                    long groupId, long categoryId, long threadId, int status,
5994                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5995                    throws com.liferay.portal.kernel.exception.SystemException {
5996                    return getPersistence()
5997                                       .fetchByG_C_T_S_Last(groupId, categoryId, threadId, status,
5998                            orderByComparator);
5999            }
6000    
6001            /**
6002            * 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;.
6003            *
6004            * @param messageId the primary key of the current message-boards message
6005            * @param groupId the group ID
6006            * @param categoryId the category ID
6007            * @param threadId the thread ID
6008            * @param status the status
6009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6010            * @return the previous, current, and next message-boards message
6011            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
6012            * @throws SystemException if a system exception occurred
6013            */
6014            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_S_PrevAndNext(
6015                    long messageId, long groupId, long categoryId, long threadId,
6016                    int status,
6017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6018                    throws com.liferay.portal.kernel.exception.SystemException,
6019                            com.liferay.portlet.messageboards.NoSuchMessageException {
6020                    return getPersistence()
6021                                       .findByG_C_T_S_PrevAndNext(messageId, groupId, categoryId,
6022                            threadId, status, orderByComparator);
6023            }
6024    
6025            /**
6026            * 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;.
6027            *
6028            * @param groupId the group ID
6029            * @param categoryId the category ID
6030            * @param threadId the thread ID
6031            * @param status the status
6032            * @return the matching message-boards messages that the user has permission to view
6033            * @throws SystemException if a system exception occurred
6034            */
6035            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
6036                    long groupId, long categoryId, long threadId, int status)
6037                    throws com.liferay.portal.kernel.exception.SystemException {
6038                    return getPersistence()
6039                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status);
6040            }
6041    
6042            /**
6043            * 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;.
6044            *
6045            * <p>
6046            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6047            * </p>
6048            *
6049            * @param groupId the group ID
6050            * @param categoryId the category ID
6051            * @param threadId the thread ID
6052            * @param status the status
6053            * @param start the lower bound of the range of message-boards messages
6054            * @param end the upper bound of the range of message-boards messages (not inclusive)
6055            * @return the range of matching message-boards messages that the user has permission to view
6056            * @throws SystemException if a system exception occurred
6057            */
6058            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
6059                    long groupId, long categoryId, long threadId, int status, int start,
6060                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6061                    return getPersistence()
6062                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status,
6063                            start, end);
6064            }
6065    
6066            /**
6067            * 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;.
6068            *
6069            * <p>
6070            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6071            * </p>
6072            *
6073            * @param groupId the group ID
6074            * @param categoryId the category ID
6075            * @param threadId the thread ID
6076            * @param status the status
6077            * @param start the lower bound of the range of message-boards messages
6078            * @param end the upper bound of the range of message-boards messages (not inclusive)
6079            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6080            * @return the ordered range of matching message-boards messages that the user has permission to view
6081            * @throws SystemException if a system exception occurred
6082            */
6083            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
6084                    long groupId, long categoryId, long threadId, int status, int start,
6085                    int end,
6086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6087                    throws com.liferay.portal.kernel.exception.SystemException {
6088                    return getPersistence()
6089                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status,
6090                            start, end, orderByComparator);
6091            }
6092    
6093            /**
6094            * 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;.
6095            *
6096            * @param messageId the primary key of the current message-boards message
6097            * @param groupId the group ID
6098            * @param categoryId the category ID
6099            * @param threadId the thread ID
6100            * @param status the status
6101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6102            * @return the previous, current, and next message-boards message
6103            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
6104            * @throws SystemException if a system exception occurred
6105            */
6106            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_T_S_PrevAndNext(
6107                    long messageId, long groupId, long categoryId, long threadId,
6108                    int status,
6109                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6110                    throws com.liferay.portal.kernel.exception.SystemException,
6111                            com.liferay.portlet.messageboards.NoSuchMessageException {
6112                    return getPersistence()
6113                                       .filterFindByG_C_T_S_PrevAndNext(messageId, groupId,
6114                            categoryId, threadId, status, orderByComparator);
6115            }
6116    
6117            /**
6118            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63; from the database.
6119            *
6120            * @param groupId the group ID
6121            * @param categoryId the category ID
6122            * @param threadId the thread ID
6123            * @param status the status
6124            * @throws SystemException if a system exception occurred
6125            */
6126            public static void removeByG_C_T_S(long groupId, long categoryId,
6127                    long threadId, int status)
6128                    throws com.liferay.portal.kernel.exception.SystemException {
6129                    getPersistence().removeByG_C_T_S(groupId, categoryId, threadId, status);
6130            }
6131    
6132            /**
6133            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
6134            *
6135            * @param groupId the group ID
6136            * @param categoryId the category ID
6137            * @param threadId the thread ID
6138            * @param status the status
6139            * @return the number of matching message-boards messages
6140            * @throws SystemException if a system exception occurred
6141            */
6142            public static int countByG_C_T_S(long groupId, long categoryId,
6143                    long threadId, int status)
6144                    throws com.liferay.portal.kernel.exception.SystemException {
6145                    return getPersistence()
6146                                       .countByG_C_T_S(groupId, categoryId, threadId, status);
6147            }
6148    
6149            /**
6150            * 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;.
6151            *
6152            * @param groupId the group ID
6153            * @param categoryId the category ID
6154            * @param threadId the thread ID
6155            * @param status the status
6156            * @return the number of matching message-boards messages that the user has permission to view
6157            * @throws SystemException if a system exception occurred
6158            */
6159            public static int filterCountByG_C_T_S(long groupId, long categoryId,
6160                    long threadId, int status)
6161                    throws com.liferay.portal.kernel.exception.SystemException {
6162                    return getPersistence()
6163                                       .filterCountByG_C_T_S(groupId, categoryId, threadId, status);
6164            }
6165    
6166            /**
6167            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6168            *
6169            * @param userId the user ID
6170            * @param classNameId the class name ID
6171            * @param classPK the class p k
6172            * @param status the status
6173            * @return the matching message-boards messages
6174            * @throws SystemException if a system exception occurred
6175            */
6176            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C_S(
6177                    long userId, long classNameId, long classPK, int status)
6178                    throws com.liferay.portal.kernel.exception.SystemException {
6179                    return getPersistence()
6180                                       .findByU_C_C_S(userId, classNameId, classPK, status);
6181            }
6182    
6183            /**
6184            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6185            *
6186            * <p>
6187            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6188            * </p>
6189            *
6190            * @param userId the user ID
6191            * @param classNameId the class name ID
6192            * @param classPK the class p k
6193            * @param status the status
6194            * @param start the lower bound of the range of message-boards messages
6195            * @param end the upper bound of the range of message-boards messages (not inclusive)
6196            * @return the range of matching message-boards messages
6197            * @throws SystemException if a system exception occurred
6198            */
6199            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C_S(
6200                    long userId, long classNameId, long classPK, int status, int start,
6201                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6202                    return getPersistence()
6203                                       .findByU_C_C_S(userId, classNameId, classPK, status, start,
6204                            end);
6205            }
6206    
6207            /**
6208            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6209            *
6210            * <p>
6211            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6212            * </p>
6213            *
6214            * @param userId the user ID
6215            * @param classNameId the class name ID
6216            * @param classPK the class p k
6217            * @param status the status
6218            * @param start the lower bound of the range of message-boards messages
6219            * @param end the upper bound of the range of message-boards messages (not inclusive)
6220            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6221            * @return the ordered range of matching message-boards messages
6222            * @throws SystemException if a system exception occurred
6223            */
6224            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByU_C_C_S(
6225                    long userId, long classNameId, long classPK, int status, int start,
6226                    int end,
6227                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6228                    throws com.liferay.portal.kernel.exception.SystemException {
6229                    return getPersistence()
6230                                       .findByU_C_C_S(userId, classNameId, classPK, status, start,
6231                            end, orderByComparator);
6232            }
6233    
6234            /**
6235            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6236            *
6237            * @param userId the user ID
6238            * @param classNameId the class name ID
6239            * @param classPK the class p k
6240            * @param status the status
6241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6242            * @return the first matching message-boards message
6243            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
6244            * @throws SystemException if a system exception occurred
6245            */
6246            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_C_S_First(
6247                    long userId, long classNameId, long classPK, int status,
6248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6249                    throws com.liferay.portal.kernel.exception.SystemException,
6250                            com.liferay.portlet.messageboards.NoSuchMessageException {
6251                    return getPersistence()
6252                                       .findByU_C_C_S_First(userId, classNameId, classPK, status,
6253                            orderByComparator);
6254            }
6255    
6256            /**
6257            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6258            *
6259            * @param userId the user ID
6260            * @param classNameId the class name ID
6261            * @param classPK the class p k
6262            * @param status the status
6263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6264            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
6265            * @throws SystemException if a system exception occurred
6266            */
6267            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_C_S_First(
6268                    long userId, long classNameId, long classPK, int status,
6269                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6270                    throws com.liferay.portal.kernel.exception.SystemException {
6271                    return getPersistence()
6272                                       .fetchByU_C_C_S_First(userId, classNameId, classPK, status,
6273                            orderByComparator);
6274            }
6275    
6276            /**
6277            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6278            *
6279            * @param userId the user ID
6280            * @param classNameId the class name ID
6281            * @param classPK the class p k
6282            * @param status the status
6283            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6284            * @return the last matching message-boards message
6285            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
6286            * @throws SystemException if a system exception occurred
6287            */
6288            public static com.liferay.portlet.messageboards.model.MBMessage findByU_C_C_S_Last(
6289                    long userId, long classNameId, long classPK, int status,
6290                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6291                    throws com.liferay.portal.kernel.exception.SystemException,
6292                            com.liferay.portlet.messageboards.NoSuchMessageException {
6293                    return getPersistence()
6294                                       .findByU_C_C_S_Last(userId, classNameId, classPK, status,
6295                            orderByComparator);
6296            }
6297    
6298            /**
6299            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6300            *
6301            * @param userId the user ID
6302            * @param classNameId the class name ID
6303            * @param classPK the class p k
6304            * @param status the status
6305            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6306            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
6307            * @throws SystemException if a system exception occurred
6308            */
6309            public static com.liferay.portlet.messageboards.model.MBMessage fetchByU_C_C_S_Last(
6310                    long userId, long classNameId, long classPK, int status,
6311                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6312                    throws com.liferay.portal.kernel.exception.SystemException {
6313                    return getPersistence()
6314                                       .fetchByU_C_C_S_Last(userId, classNameId, classPK, status,
6315                            orderByComparator);
6316            }
6317    
6318            /**
6319            * 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;.
6320            *
6321            * @param messageId the primary key of the current message-boards message
6322            * @param userId the user ID
6323            * @param classNameId the class name ID
6324            * @param classPK the class p k
6325            * @param status the status
6326            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6327            * @return the previous, current, and next message-boards message
6328            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
6329            * @throws SystemException if a system exception occurred
6330            */
6331            public static com.liferay.portlet.messageboards.model.MBMessage[] findByU_C_C_S_PrevAndNext(
6332                    long messageId, long userId, long classNameId, long classPK,
6333                    int status,
6334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6335                    throws com.liferay.portal.kernel.exception.SystemException,
6336                            com.liferay.portlet.messageboards.NoSuchMessageException {
6337                    return getPersistence()
6338                                       .findByU_C_C_S_PrevAndNext(messageId, userId, classNameId,
6339                            classPK, status, orderByComparator);
6340            }
6341    
6342            /**
6343            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63; from the database.
6344            *
6345            * @param userId the user ID
6346            * @param classNameId the class name ID
6347            * @param classPK the class p k
6348            * @param status the status
6349            * @throws SystemException if a system exception occurred
6350            */
6351            public static void removeByU_C_C_S(long userId, long classNameId,
6352                    long classPK, int status)
6353                    throws com.liferay.portal.kernel.exception.SystemException {
6354                    getPersistence().removeByU_C_C_S(userId, classNameId, classPK, status);
6355            }
6356    
6357            /**
6358            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
6359            *
6360            * @param userId the user ID
6361            * @param classNameId the class name ID
6362            * @param classPK the class p k
6363            * @param status the status
6364            * @return the number of matching message-boards messages
6365            * @throws SystemException if a system exception occurred
6366            */
6367            public static int countByU_C_C_S(long userId, long classNameId,
6368                    long classPK, int status)
6369                    throws com.liferay.portal.kernel.exception.SystemException {
6370                    return getPersistence()
6371                                       .countByU_C_C_S(userId, classNameId, classPK, status);
6372            }
6373    
6374            /**
6375            * Caches the message-boards message in the entity cache if it is enabled.
6376            *
6377            * @param mbMessage the message-boards message
6378            */
6379            public static void cacheResult(
6380                    com.liferay.portlet.messageboards.model.MBMessage mbMessage) {
6381                    getPersistence().cacheResult(mbMessage);
6382            }
6383    
6384            /**
6385            * Caches the message-boards messages in the entity cache if it is enabled.
6386            *
6387            * @param mbMessages the message-boards messages
6388            */
6389            public static void cacheResult(
6390                    java.util.List<com.liferay.portlet.messageboards.model.MBMessage> mbMessages) {
6391                    getPersistence().cacheResult(mbMessages);
6392            }
6393    
6394            /**
6395            * Creates a new message-boards message with the primary key. Does not add the message-boards message to the database.
6396            *
6397            * @param messageId the primary key for the new message-boards message
6398            * @return the new message-boards message
6399            */
6400            public static com.liferay.portlet.messageboards.model.MBMessage create(
6401                    long messageId) {
6402                    return getPersistence().create(messageId);
6403            }
6404    
6405            /**
6406            * Removes the message-boards message with the primary key from the database. Also notifies the appropriate model listeners.
6407            *
6408            * @param messageId the primary key of the message-boards message
6409            * @return the message-boards message that was removed
6410            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
6411            * @throws SystemException if a system exception occurred
6412            */
6413            public static com.liferay.portlet.messageboards.model.MBMessage remove(
6414                    long messageId)
6415                    throws com.liferay.portal.kernel.exception.SystemException,
6416                            com.liferay.portlet.messageboards.NoSuchMessageException {
6417                    return getPersistence().remove(messageId);
6418            }
6419    
6420            public static com.liferay.portlet.messageboards.model.MBMessage updateImpl(
6421                    com.liferay.portlet.messageboards.model.MBMessage mbMessage)
6422                    throws com.liferay.portal.kernel.exception.SystemException {
6423                    return getPersistence().updateImpl(mbMessage);
6424            }
6425    
6426            /**
6427            * Returns the message-boards message with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchMessageException} if it could not be found.
6428            *
6429            * @param messageId the primary key of the message-boards message
6430            * @return the message-boards message
6431            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
6432            * @throws SystemException if a system exception occurred
6433            */
6434            public static com.liferay.portlet.messageboards.model.MBMessage findByPrimaryKey(
6435                    long messageId)
6436                    throws com.liferay.portal.kernel.exception.SystemException,
6437                            com.liferay.portlet.messageboards.NoSuchMessageException {
6438                    return getPersistence().findByPrimaryKey(messageId);
6439            }
6440    
6441            /**
6442            * Returns the message-boards message with the primary key or returns <code>null</code> if it could not be found.
6443            *
6444            * @param messageId the primary key of the message-boards message
6445            * @return the message-boards message, or <code>null</code> if a message-boards message with the primary key could not be found
6446            * @throws SystemException if a system exception occurred
6447            */
6448            public static com.liferay.portlet.messageboards.model.MBMessage fetchByPrimaryKey(
6449                    long messageId)
6450                    throws com.liferay.portal.kernel.exception.SystemException {
6451                    return getPersistence().fetchByPrimaryKey(messageId);
6452            }
6453    
6454            /**
6455            * Returns all the message-boards messages.
6456            *
6457            * @return the message-boards messages
6458            * @throws SystemException if a system exception occurred
6459            */
6460            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll()
6461                    throws com.liferay.portal.kernel.exception.SystemException {
6462                    return getPersistence().findAll();
6463            }
6464    
6465            /**
6466            * Returns a range of all the message-boards messages.
6467            *
6468            * <p>
6469            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6470            * </p>
6471            *
6472            * @param start the lower bound of the range of message-boards messages
6473            * @param end the upper bound of the range of message-boards messages (not inclusive)
6474            * @return the range of message-boards messages
6475            * @throws SystemException if a system exception occurred
6476            */
6477            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll(
6478                    int start, int end)
6479                    throws com.liferay.portal.kernel.exception.SystemException {
6480                    return getPersistence().findAll(start, end);
6481            }
6482    
6483            /**
6484            * Returns an ordered range of all the message-boards messages.
6485            *
6486            * <p>
6487            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.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.
6488            * </p>
6489            *
6490            * @param start the lower bound of the range of message-boards messages
6491            * @param end the upper bound of the range of message-boards messages (not inclusive)
6492            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6493            * @return the ordered range of message-boards messages
6494            * @throws SystemException if a system exception occurred
6495            */
6496            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll(
6497                    int start, int end,
6498                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6499                    throws com.liferay.portal.kernel.exception.SystemException {
6500                    return getPersistence().findAll(start, end, orderByComparator);
6501            }
6502    
6503            /**
6504            * Removes all the message-boards messages from the database.
6505            *
6506            * @throws SystemException if a system exception occurred
6507            */
6508            public static void removeAll()
6509                    throws com.liferay.portal.kernel.exception.SystemException {
6510                    getPersistence().removeAll();
6511            }
6512    
6513            /**
6514            * Returns the number of message-boards messages.
6515            *
6516            * @return the number of message-boards messages
6517            * @throws SystemException if a system exception occurred
6518            */
6519            public static int countAll()
6520                    throws com.liferay.portal.kernel.exception.SystemException {
6521                    return getPersistence().countAll();
6522            }
6523    
6524            public static MBMessagePersistence getPersistence() {
6525                    if (_persistence == null) {
6526                            _persistence = (MBMessagePersistence)PortalBeanLocatorUtil.locate(MBMessagePersistence.class.getName());
6527    
6528                            ReferenceRegistry.registerReference(MBMessageUtil.class,
6529                                    "_persistence");
6530                    }
6531    
6532                    return _persistence;
6533            }
6534    
6535            /**
6536             * @deprecated As of 6.2.0
6537             */
6538            public void setPersistence(MBMessagePersistence persistence) {
6539            }
6540    
6541            private static MBMessagePersistence _persistence;
6542    }