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