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