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