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