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