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