001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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 to cache
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 to cache
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 to remove
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            * Finds 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 to find
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            * Finds 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 to find
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            * Finds all the message-boards messages where uuid = &#63;.
204            *
205            * @param uuid the uuid to search with
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            * Finds 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 to search with
223            * @param start the lower bound of the range of message-boards messages to return
224            * @param end the upper bound of the range of message-boards messages to return (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            * Finds 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 to search with
242            * @param start the lower bound of the range of message-boards messages to return
243            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
244            * @param orderByComparator the comparator to order the results by
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            * Finds 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 to search with
263            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
284            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
306            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
324            * @param groupId the group ID to search with
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            * Finds 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 to search with
340            * @param groupId the group ID to search with
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            * Finds 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 to search with
354            * @param groupId the group ID to search with
355            * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
356            * @throws SystemException if a system exception occurred
357            */
358            public static com.liferay.portlet.messageboards.model.MBMessage fetchByUUID_G(
359                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
360                    throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
362            }
363    
364            /**
365            * Finds all the message-boards messages where groupId = &#63;.
366            *
367            * @param groupId the group ID to search with
368            * @return the matching message-boards messages
369            * @throws SystemException if a system exception occurred
370            */
371            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
372                    long groupId)
373                    throws com.liferay.portal.kernel.exception.SystemException {
374                    return getPersistence().findByGroupId(groupId);
375            }
376    
377            /**
378            * Finds a range of all the message-boards messages where groupId = &#63;.
379            *
380            * <p>
381            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
382            * </p>
383            *
384            * @param groupId the group ID to search with
385            * @param start the lower bound of the range of message-boards messages to return
386            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
387            * @return the range of matching message-boards messages
388            * @throws SystemException if a system exception occurred
389            */
390            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
391                    long groupId, int start, int end)
392                    throws com.liferay.portal.kernel.exception.SystemException {
393                    return getPersistence().findByGroupId(groupId, start, end);
394            }
395    
396            /**
397            * Finds an ordered range of all the message-boards messages where groupId = &#63;.
398            *
399            * <p>
400            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
401            * </p>
402            *
403            * @param groupId the group ID to search with
404            * @param start the lower bound of the range of message-boards messages to return
405            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
406            * @param orderByComparator the comparator to order the results by
407            * @return the ordered range of matching message-boards messages
408            * @throws SystemException if a system exception occurred
409            */
410            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId(
411                    long groupId, int start, int end,
412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
413                    throws com.liferay.portal.kernel.exception.SystemException {
414                    return getPersistence()
415                                       .findByGroupId(groupId, start, end, orderByComparator);
416            }
417    
418            /**
419            * Finds the first message-boards message in the ordered set where groupId = &#63;.
420            *
421            * <p>
422            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
423            * </p>
424            *
425            * @param groupId the group ID to search with
426            * @param orderByComparator the comparator to order the set by
427            * @return the first matching message-boards message
428            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
429            * @throws SystemException if a system exception occurred
430            */
431            public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_First(
432                    long groupId,
433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
434                    throws com.liferay.portal.kernel.exception.SystemException,
435                            com.liferay.portlet.messageboards.NoSuchMessageException {
436                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
437            }
438    
439            /**
440            * Finds the last message-boards message in the ordered set where groupId = &#63;.
441            *
442            * <p>
443            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
444            * </p>
445            *
446            * @param groupId the group ID to search with
447            * @param orderByComparator the comparator to order the set by
448            * @return the last matching message-boards message
449            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
450            * @throws SystemException if a system exception occurred
451            */
452            public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_Last(
453                    long groupId,
454                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
455                    throws com.liferay.portal.kernel.exception.SystemException,
456                            com.liferay.portlet.messageboards.NoSuchMessageException {
457                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
458            }
459    
460            /**
461            * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63;.
462            *
463            * <p>
464            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
465            * </p>
466            *
467            * @param messageId the primary key of the current message-boards message
468            * @param groupId the group ID to search with
469            * @param orderByComparator the comparator to order the set by
470            * @return the previous, current, and next message-boards message
471            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
472            * @throws SystemException if a system exception occurred
473            */
474            public static com.liferay.portlet.messageboards.model.MBMessage[] findByGroupId_PrevAndNext(
475                    long messageId, long groupId,
476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
477                    throws com.liferay.portal.kernel.exception.SystemException,
478                            com.liferay.portlet.messageboards.NoSuchMessageException {
479                    return getPersistence()
480                                       .findByGroupId_PrevAndNext(messageId, groupId,
481                            orderByComparator);
482            }
483    
484            /**
485            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63;.
486            *
487            * @param groupId the group ID to search with
488            * @return the matching message-boards messages that the user has permission to view
489            * @throws SystemException if a system exception occurred
490            */
491            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
492                    long groupId)
493                    throws com.liferay.portal.kernel.exception.SystemException {
494                    return getPersistence().filterFindByGroupId(groupId);
495            }
496    
497            /**
498            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63;.
499            *
500            * <p>
501            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
502            * </p>
503            *
504            * @param groupId the group ID to search with
505            * @param start the lower bound of the range of message-boards messages to return
506            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
507            * @return the range of matching message-boards messages that the user has permission to view
508            * @throws SystemException if a system exception occurred
509            */
510            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
511                    long groupId, int start, int end)
512                    throws com.liferay.portal.kernel.exception.SystemException {
513                    return getPersistence().filterFindByGroupId(groupId, start, end);
514            }
515    
516            /**
517            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63;.
518            *
519            * <p>
520            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
521            * </p>
522            *
523            * @param groupId the group ID to search with
524            * @param start the lower bound of the range of message-boards messages to return
525            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
526            * @param orderByComparator the comparator to order the results by
527            * @return the ordered range of matching message-boards messages that the user has permission to view
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId(
531                    long groupId, int start, int end,
532                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
533                    throws com.liferay.portal.kernel.exception.SystemException {
534                    return getPersistence()
535                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
536            }
537    
538            /**
539            * Filters the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63;.
540            *
541            * <p>
542            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
543            * </p>
544            *
545            * @param messageId the primary key of the current message-boards message
546            * @param groupId the group ID to search with
547            * @param orderByComparator the comparator to order the set by
548            * @return the previous, current, and next message-boards message
549            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
550            * @throws SystemException if a system exception occurred
551            */
552            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByGroupId_PrevAndNext(
553                    long messageId, long groupId,
554                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
555                    throws com.liferay.portal.kernel.exception.SystemException,
556                            com.liferay.portlet.messageboards.NoSuchMessageException {
557                    return getPersistence()
558                                       .filterFindByGroupId_PrevAndNext(messageId, groupId,
559                            orderByComparator);
560            }
561    
562            /**
563            * Finds all the message-boards messages where companyId = &#63;.
564            *
565            * @param companyId the company ID to search with
566            * @return the matching message-boards messages
567            * @throws SystemException if a system exception occurred
568            */
569            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
570                    long companyId)
571                    throws com.liferay.portal.kernel.exception.SystemException {
572                    return getPersistence().findByCompanyId(companyId);
573            }
574    
575            /**
576            * Finds a range of all the message-boards messages where companyId = &#63;.
577            *
578            * <p>
579            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
580            * </p>
581            *
582            * @param companyId the company ID to search with
583            * @param start the lower bound of the range of message-boards messages to return
584            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
585            * @return the range of matching message-boards messages
586            * @throws SystemException if a system exception occurred
587            */
588            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
589                    long companyId, int start, int end)
590                    throws com.liferay.portal.kernel.exception.SystemException {
591                    return getPersistence().findByCompanyId(companyId, start, end);
592            }
593    
594            /**
595            * Finds an ordered range of all the message-boards messages where companyId = &#63;.
596            *
597            * <p>
598            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
599            * </p>
600            *
601            * @param companyId the company ID to search with
602            * @param start the lower bound of the range of message-boards messages to return
603            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
604            * @param orderByComparator the comparator to order the results by
605            * @return the ordered range of matching message-boards messages
606            * @throws SystemException if a system exception occurred
607            */
608            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId(
609                    long companyId, int start, int end,
610                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
611                    throws com.liferay.portal.kernel.exception.SystemException {
612                    return getPersistence()
613                                       .findByCompanyId(companyId, start, end, orderByComparator);
614            }
615    
616            /**
617            * Finds the first message-boards message in the ordered set where companyId = &#63;.
618            *
619            * <p>
620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
621            * </p>
622            *
623            * @param companyId the company ID to search with
624            * @param orderByComparator the comparator to order the set by
625            * @return the first matching message-boards message
626            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
627            * @throws SystemException if a system exception occurred
628            */
629            public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_First(
630                    long companyId,
631                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
632                    throws com.liferay.portal.kernel.exception.SystemException,
633                            com.liferay.portlet.messageboards.NoSuchMessageException {
634                    return getPersistence()
635                                       .findByCompanyId_First(companyId, orderByComparator);
636            }
637    
638            /**
639            * Finds the last message-boards message in the ordered set where companyId = &#63;.
640            *
641            * <p>
642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
643            * </p>
644            *
645            * @param companyId the company ID to search with
646            * @param orderByComparator the comparator to order the set by
647            * @return the last matching message-boards message
648            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
649            * @throws SystemException if a system exception occurred
650            */
651            public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_Last(
652                    long companyId,
653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
654                    throws com.liferay.portal.kernel.exception.SystemException,
655                            com.liferay.portlet.messageboards.NoSuchMessageException {
656                    return getPersistence()
657                                       .findByCompanyId_Last(companyId, orderByComparator);
658            }
659    
660            /**
661            * Finds the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63;.
662            *
663            * <p>
664            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
665            * </p>
666            *
667            * @param messageId the primary key of the current message-boards message
668            * @param companyId the company ID to search with
669            * @param orderByComparator the comparator to order the set by
670            * @return the previous, current, and next message-boards message
671            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
672            * @throws SystemException if a system exception occurred
673            */
674            public static com.liferay.portlet.messageboards.model.MBMessage[] findByCompanyId_PrevAndNext(
675                    long messageId, long companyId,
676                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
677                    throws com.liferay.portal.kernel.exception.SystemException,
678                            com.liferay.portlet.messageboards.NoSuchMessageException {
679                    return getPersistence()
680                                       .findByCompanyId_PrevAndNext(messageId, companyId,
681                            orderByComparator);
682            }
683    
684            /**
685            * Finds all the message-boards messages where threadId = &#63;.
686            *
687            * @param threadId the thread ID to search with
688            * @return the matching message-boards messages
689            * @throws SystemException if a system exception occurred
690            */
691            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
692                    long threadId)
693                    throws com.liferay.portal.kernel.exception.SystemException {
694                    return getPersistence().findByThreadId(threadId);
695            }
696    
697            /**
698            * Finds a range of all the message-boards messages where threadId = &#63;.
699            *
700            * <p>
701            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
702            * </p>
703            *
704            * @param threadId the thread ID to search with
705            * @param start the lower bound of the range of message-boards messages to return
706            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
707            * @return the range of matching message-boards messages
708            * @throws SystemException if a system exception occurred
709            */
710            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
711                    long threadId, int start, int end)
712                    throws com.liferay.portal.kernel.exception.SystemException {
713                    return getPersistence().findByThreadId(threadId, start, end);
714            }
715    
716            /**
717            * Finds an ordered range of all the message-boards messages where threadId = &#63;.
718            *
719            * <p>
720            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
721            * </p>
722            *
723            * @param threadId the thread ID to search with
724            * @param start the lower bound of the range of message-boards messages to return
725            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
726            * @param orderByComparator the comparator to order the results by
727            * @return the ordered range of matching message-boards messages
728            * @throws SystemException if a system exception occurred
729            */
730            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId(
731                    long threadId, int start, int end,
732                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
733                    throws com.liferay.portal.kernel.exception.SystemException {
734                    return getPersistence()
735                                       .findByThreadId(threadId, start, end, orderByComparator);
736            }
737    
738            /**
739            * Finds the first message-boards message in the ordered set where threadId = &#63;.
740            *
741            * <p>
742            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
743            * </p>
744            *
745            * @param threadId the thread ID to search with
746            * @param orderByComparator the comparator to order the set by
747            * @return the first matching message-boards message
748            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
749            * @throws SystemException if a system exception occurred
750            */
751            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_First(
752                    long threadId,
753                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
754                    throws com.liferay.portal.kernel.exception.SystemException,
755                            com.liferay.portlet.messageboards.NoSuchMessageException {
756                    return getPersistence().findByThreadId_First(threadId, orderByComparator);
757            }
758    
759            /**
760            * Finds the last message-boards message in the ordered set where threadId = &#63;.
761            *
762            * <p>
763            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
764            * </p>
765            *
766            * @param threadId the thread ID to search with
767            * @param orderByComparator the comparator to order the set by
768            * @return the last matching message-boards message
769            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
770            * @throws SystemException if a system exception occurred
771            */
772            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_Last(
773                    long threadId,
774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
775                    throws com.liferay.portal.kernel.exception.SystemException,
776                            com.liferay.portlet.messageboards.NoSuchMessageException {
777                    return getPersistence().findByThreadId_Last(threadId, orderByComparator);
778            }
779    
780            /**
781            * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
782            *
783            * <p>
784            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
785            * </p>
786            *
787            * @param messageId the primary key of the current message-boards message
788            * @param threadId the thread ID to search with
789            * @param orderByComparator the comparator to order the set by
790            * @return the previous, current, and next message-boards message
791            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
792            * @throws SystemException if a system exception occurred
793            */
794            public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadId_PrevAndNext(
795                    long messageId, long threadId,
796                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
797                    throws com.liferay.portal.kernel.exception.SystemException,
798                            com.liferay.portlet.messageboards.NoSuchMessageException {
799                    return getPersistence()
800                                       .findByThreadId_PrevAndNext(messageId, threadId,
801                            orderByComparator);
802            }
803    
804            /**
805            * Finds all the message-boards messages where threadId = &#63;.
806            *
807            * @param threadId the thread ID to search with
808            * @return the matching message-boards messages
809            * @throws SystemException if a system exception occurred
810            */
811            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
812                    long threadId)
813                    throws com.liferay.portal.kernel.exception.SystemException {
814                    return getPersistence().findByThreadReplies(threadId);
815            }
816    
817            /**
818            * Finds a range of all the message-boards messages where threadId = &#63;.
819            *
820            * <p>
821            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
822            * </p>
823            *
824            * @param threadId the thread ID to search with
825            * @param start the lower bound of the range of message-boards messages to return
826            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
827            * @return the range of matching message-boards messages
828            * @throws SystemException if a system exception occurred
829            */
830            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
831                    long threadId, int start, int end)
832                    throws com.liferay.portal.kernel.exception.SystemException {
833                    return getPersistence().findByThreadReplies(threadId, start, end);
834            }
835    
836            /**
837            * Finds an ordered range of all the message-boards messages where threadId = &#63;.
838            *
839            * <p>
840            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
841            * </p>
842            *
843            * @param threadId the thread ID to search with
844            * @param start the lower bound of the range of message-boards messages to return
845            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
846            * @param orderByComparator the comparator to order the results by
847            * @return the ordered range of matching message-boards messages
848            * @throws SystemException if a system exception occurred
849            */
850            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies(
851                    long threadId, int start, int end,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence()
855                                       .findByThreadReplies(threadId, start, end, orderByComparator);
856            }
857    
858            /**
859            * Finds the first message-boards message in the ordered set where threadId = &#63;.
860            *
861            * <p>
862            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
863            * </p>
864            *
865            * @param threadId the thread ID to search with
866            * @param orderByComparator the comparator to order the set by
867            * @return the first matching message-boards message
868            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
869            * @throws SystemException if a system exception occurred
870            */
871            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_First(
872                    long threadId,
873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
874                    throws com.liferay.portal.kernel.exception.SystemException,
875                            com.liferay.portlet.messageboards.NoSuchMessageException {
876                    return getPersistence()
877                                       .findByThreadReplies_First(threadId, orderByComparator);
878            }
879    
880            /**
881            * Finds the last message-boards message in the ordered set where threadId = &#63;.
882            *
883            * <p>
884            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
885            * </p>
886            *
887            * @param threadId the thread ID to search with
888            * @param orderByComparator the comparator to order the set by
889            * @return the last matching message-boards message
890            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
891            * @throws SystemException if a system exception occurred
892            */
893            public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_Last(
894                    long threadId,
895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
896                    throws com.liferay.portal.kernel.exception.SystemException,
897                            com.liferay.portlet.messageboards.NoSuchMessageException {
898                    return getPersistence()
899                                       .findByThreadReplies_Last(threadId, orderByComparator);
900            }
901    
902            /**
903            * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
904            *
905            * <p>
906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
907            * </p>
908            *
909            * @param messageId the primary key of the current message-boards message
910            * @param threadId the thread ID to search with
911            * @param orderByComparator the comparator to order the set by
912            * @return the previous, current, and next message-boards message
913            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
914            * @throws SystemException if a system exception occurred
915            */
916            public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadReplies_PrevAndNext(
917                    long messageId, long threadId,
918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
919                    throws com.liferay.portal.kernel.exception.SystemException,
920                            com.liferay.portlet.messageboards.NoSuchMessageException {
921                    return getPersistence()
922                                       .findByThreadReplies_PrevAndNext(messageId, threadId,
923                            orderByComparator);
924            }
925    
926            /**
927            * Finds all the message-boards messages where userId = &#63;.
928            *
929            * @param userId the user ID to search with
930            * @return the matching message-boards messages
931            * @throws SystemException if a system exception occurred
932            */
933            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
934                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
935                    return getPersistence().findByUserId(userId);
936            }
937    
938            /**
939            * Finds a range of all the message-boards messages where userId = &#63;.
940            *
941            * <p>
942            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
943            * </p>
944            *
945            * @param userId the user ID to search with
946            * @param start the lower bound of the range of message-boards messages to return
947            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
948            * @return the range of matching message-boards messages
949            * @throws SystemException if a system exception occurred
950            */
951            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
952                    long userId, int start, int end)
953                    throws com.liferay.portal.kernel.exception.SystemException {
954                    return getPersistence().findByUserId(userId, start, end);
955            }
956    
957            /**
958            * Finds an ordered range of all the message-boards messages where userId = &#63;.
959            *
960            * <p>
961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
962            * </p>
963            *
964            * @param userId the user ID to search with
965            * @param start the lower bound of the range of message-boards messages to return
966            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
967            * @param orderByComparator the comparator to order the results by
968            * @return the ordered range of matching message-boards messages
969            * @throws SystemException if a system exception occurred
970            */
971            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId(
972                    long userId, int start, int end,
973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
974                    throws com.liferay.portal.kernel.exception.SystemException {
975                    return getPersistence()
976                                       .findByUserId(userId, start, end, orderByComparator);
977            }
978    
979            /**
980            * Finds the first message-boards message in the ordered set where userId = &#63;.
981            *
982            * <p>
983            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
984            * </p>
985            *
986            * @param userId the user ID to search with
987            * @param orderByComparator the comparator to order the set by
988            * @return the first matching message-boards message
989            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
990            * @throws SystemException if a system exception occurred
991            */
992            public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_First(
993                    long userId,
994                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
995                    throws com.liferay.portal.kernel.exception.SystemException,
996                            com.liferay.portlet.messageboards.NoSuchMessageException {
997                    return getPersistence().findByUserId_First(userId, orderByComparator);
998            }
999    
1000            /**
1001            * Finds the last message-boards message in the ordered set where userId = &#63;.
1002            *
1003            * <p>
1004            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1005            * </p>
1006            *
1007            * @param userId the user ID to search with
1008            * @param orderByComparator the comparator to order the set by
1009            * @return the last matching message-boards message
1010            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1011            * @throws SystemException if a system exception occurred
1012            */
1013            public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_Last(
1014                    long userId,
1015                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1016                    throws com.liferay.portal.kernel.exception.SystemException,
1017                            com.liferay.portlet.messageboards.NoSuchMessageException {
1018                    return getPersistence().findByUserId_Last(userId, orderByComparator);
1019            }
1020    
1021            /**
1022            * Finds the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63;.
1023            *
1024            * <p>
1025            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1026            * </p>
1027            *
1028            * @param messageId the primary key of the current message-boards message
1029            * @param userId the user ID to search with
1030            * @param orderByComparator the comparator to order the set by
1031            * @return the previous, current, and next message-boards message
1032            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static com.liferay.portlet.messageboards.model.MBMessage[] findByUserId_PrevAndNext(
1036                    long messageId, long userId,
1037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.SystemException,
1039                            com.liferay.portlet.messageboards.NoSuchMessageException {
1040                    return getPersistence()
1041                                       .findByUserId_PrevAndNext(messageId, userId,
1042                            orderByComparator);
1043            }
1044    
1045            /**
1046            * Finds all the message-boards messages where groupId = &#63; and userId = &#63;.
1047            *
1048            * @param groupId the group ID to search with
1049            * @param userId the user ID to search with
1050            * @return the matching message-boards messages
1051            * @throws SystemException if a system exception occurred
1052            */
1053            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1054                    long groupId, long userId)
1055                    throws com.liferay.portal.kernel.exception.SystemException {
1056                    return getPersistence().findByG_U(groupId, userId);
1057            }
1058    
1059            /**
1060            * Finds a range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1061            *
1062            * <p>
1063            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1064            * </p>
1065            *
1066            * @param groupId the group ID to search with
1067            * @param userId the user ID to search with
1068            * @param start the lower bound of the range of message-boards messages to return
1069            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1070            * @return the range of matching message-boards messages
1071            * @throws SystemException if a system exception occurred
1072            */
1073            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1074                    long groupId, long userId, int start, int end)
1075                    throws com.liferay.portal.kernel.exception.SystemException {
1076                    return getPersistence().findByG_U(groupId, userId, start, end);
1077            }
1078    
1079            /**
1080            * Finds an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1081            *
1082            * <p>
1083            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1084            * </p>
1085            *
1086            * @param groupId the group ID to search with
1087            * @param userId the user ID to search with
1088            * @param start the lower bound of the range of message-boards messages to return
1089            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1090            * @param orderByComparator the comparator to order the results by
1091            * @return the ordered range of matching message-boards messages
1092            * @throws SystemException if a system exception occurred
1093            */
1094            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U(
1095                    long groupId, long userId, int start, int end,
1096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1097                    throws com.liferay.portal.kernel.exception.SystemException {
1098                    return getPersistence()
1099                                       .findByG_U(groupId, userId, start, end, orderByComparator);
1100            }
1101    
1102            /**
1103            * Finds the first message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1104            *
1105            * <p>
1106            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1107            * </p>
1108            *
1109            * @param groupId the group ID to search with
1110            * @param userId the user ID to search with
1111            * @param orderByComparator the comparator to order the set by
1112            * @return the first matching message-boards message
1113            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1114            * @throws SystemException if a system exception occurred
1115            */
1116            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_First(
1117                    long groupId, long userId,
1118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1119                    throws com.liferay.portal.kernel.exception.SystemException,
1120                            com.liferay.portlet.messageboards.NoSuchMessageException {
1121                    return getPersistence()
1122                                       .findByG_U_First(groupId, userId, orderByComparator);
1123            }
1124    
1125            /**
1126            * Finds the last message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1127            *
1128            * <p>
1129            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1130            * </p>
1131            *
1132            * @param groupId the group ID to search with
1133            * @param userId the user ID to search with
1134            * @param orderByComparator the comparator to order the set by
1135            * @return the last matching message-boards message
1136            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1137            * @throws SystemException if a system exception occurred
1138            */
1139            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_Last(
1140                    long groupId, long userId,
1141                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1142                    throws com.liferay.portal.kernel.exception.SystemException,
1143                            com.liferay.portlet.messageboards.NoSuchMessageException {
1144                    return getPersistence()
1145                                       .findByG_U_Last(groupId, userId, orderByComparator);
1146            }
1147    
1148            /**
1149            * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1150            *
1151            * <p>
1152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1153            * </p>
1154            *
1155            * @param messageId the primary key of the current message-boards message
1156            * @param groupId the group ID to search with
1157            * @param userId the user ID to search with
1158            * @param orderByComparator the comparator to order the set by
1159            * @return the previous, current, and next message-boards message
1160            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1161            * @throws SystemException if a system exception occurred
1162            */
1163            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_PrevAndNext(
1164                    long messageId, long groupId, long userId,
1165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1166                    throws com.liferay.portal.kernel.exception.SystemException,
1167                            com.liferay.portlet.messageboards.NoSuchMessageException {
1168                    return getPersistence()
1169                                       .findByG_U_PrevAndNext(messageId, groupId, userId,
1170                            orderByComparator);
1171            }
1172    
1173            /**
1174            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and userId = &#63;.
1175            *
1176            * @param groupId the group ID to search with
1177            * @param userId the user ID to search with
1178            * @return the matching message-boards messages that the user has permission to view
1179            * @throws SystemException if a system exception occurred
1180            */
1181            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1182                    long groupId, long userId)
1183                    throws com.liferay.portal.kernel.exception.SystemException {
1184                    return getPersistence().filterFindByG_U(groupId, userId);
1185            }
1186    
1187            /**
1188            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1189            *
1190            * <p>
1191            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1192            * </p>
1193            *
1194            * @param groupId the group ID to search with
1195            * @param userId the user ID to search with
1196            * @param start the lower bound of the range of message-boards messages to return
1197            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1198            * @return the range of matching message-boards messages that the user has permission to view
1199            * @throws SystemException if a system exception occurred
1200            */
1201            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1202                    long groupId, long userId, int start, int end)
1203                    throws com.liferay.portal.kernel.exception.SystemException {
1204                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
1205            }
1206    
1207            /**
1208            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1209            *
1210            * <p>
1211            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1212            * </p>
1213            *
1214            * @param groupId the group ID to search with
1215            * @param userId the user ID to search with
1216            * @param start the lower bound of the range of message-boards messages to return
1217            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1218            * @param orderByComparator the comparator to order the results by
1219            * @return the ordered range of matching message-boards messages that the user has permission to view
1220            * @throws SystemException if a system exception occurred
1221            */
1222            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U(
1223                    long groupId, long userId, int start, int end,
1224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1225                    throws com.liferay.portal.kernel.exception.SystemException {
1226                    return getPersistence()
1227                                       .filterFindByG_U(groupId, userId, start, end,
1228                            orderByComparator);
1229            }
1230    
1231            /**
1232            * Filters the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1233            *
1234            * <p>
1235            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1236            * </p>
1237            *
1238            * @param messageId the primary key of the current message-boards message
1239            * @param groupId the group ID to search with
1240            * @param userId the user ID to search with
1241            * @param orderByComparator the comparator to order the set by
1242            * @return the previous, current, and next message-boards message
1243            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1244            * @throws SystemException if a system exception occurred
1245            */
1246            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_U_PrevAndNext(
1247                    long messageId, long groupId, long userId,
1248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1249                    throws com.liferay.portal.kernel.exception.SystemException,
1250                            com.liferay.portlet.messageboards.NoSuchMessageException {
1251                    return getPersistence()
1252                                       .filterFindByG_U_PrevAndNext(messageId, groupId, userId,
1253                            orderByComparator);
1254            }
1255    
1256            /**
1257            * Finds all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1258            *
1259            * @param groupId the group ID to search with
1260            * @param categoryId the category ID to search with
1261            * @return the matching message-boards messages
1262            * @throws SystemException if a system exception occurred
1263            */
1264            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1265                    long groupId, long categoryId)
1266                    throws com.liferay.portal.kernel.exception.SystemException {
1267                    return getPersistence().findByG_C(groupId, categoryId);
1268            }
1269    
1270            /**
1271            * Finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1272            *
1273            * <p>
1274            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1275            * </p>
1276            *
1277            * @param groupId the group ID to search with
1278            * @param categoryId the category ID to search with
1279            * @param start the lower bound of the range of message-boards messages to return
1280            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1281            * @return the range of matching message-boards messages
1282            * @throws SystemException if a system exception occurred
1283            */
1284            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1285                    long groupId, long categoryId, int start, int end)
1286                    throws com.liferay.portal.kernel.exception.SystemException {
1287                    return getPersistence().findByG_C(groupId, categoryId, start, end);
1288            }
1289    
1290            /**
1291            * Finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1292            *
1293            * <p>
1294            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1295            * </p>
1296            *
1297            * @param groupId the group ID to search with
1298            * @param categoryId the category ID to search with
1299            * @param start the lower bound of the range of message-boards messages to return
1300            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1301            * @param orderByComparator the comparator to order the results by
1302            * @return the ordered range of matching message-boards messages
1303            * @throws SystemException if a system exception occurred
1304            */
1305            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C(
1306                    long groupId, long categoryId, int start, int end,
1307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1308                    throws com.liferay.portal.kernel.exception.SystemException {
1309                    return getPersistence()
1310                                       .findByG_C(groupId, categoryId, start, end, orderByComparator);
1311            }
1312    
1313            /**
1314            * Finds the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1315            *
1316            * <p>
1317            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1318            * </p>
1319            *
1320            * @param groupId the group ID to search with
1321            * @param categoryId the category ID to search with
1322            * @param orderByComparator the comparator to order the set by
1323            * @return the first matching message-boards message
1324            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1325            * @throws SystemException if a system exception occurred
1326            */
1327            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_First(
1328                    long groupId, long categoryId,
1329                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1330                    throws com.liferay.portal.kernel.exception.SystemException,
1331                            com.liferay.portlet.messageboards.NoSuchMessageException {
1332                    return getPersistence()
1333                                       .findByG_C_First(groupId, categoryId, orderByComparator);
1334            }
1335    
1336            /**
1337            * Finds the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1338            *
1339            * <p>
1340            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1341            * </p>
1342            *
1343            * @param groupId the group ID to search with
1344            * @param categoryId the category ID to search with
1345            * @param orderByComparator the comparator to order the set by
1346            * @return the last matching message-boards message
1347            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1348            * @throws SystemException if a system exception occurred
1349            */
1350            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_Last(
1351                    long groupId, long categoryId,
1352                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1353                    throws com.liferay.portal.kernel.exception.SystemException,
1354                            com.liferay.portlet.messageboards.NoSuchMessageException {
1355                    return getPersistence()
1356                                       .findByG_C_Last(groupId, categoryId, orderByComparator);
1357            }
1358    
1359            /**
1360            * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1361            *
1362            * <p>
1363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1364            * </p>
1365            *
1366            * @param messageId the primary key of the current message-boards message
1367            * @param groupId the group ID to search with
1368            * @param categoryId the category ID to search with
1369            * @param orderByComparator the comparator to order the set by
1370            * @return the previous, current, and next message-boards message
1371            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1372            * @throws SystemException if a system exception occurred
1373            */
1374            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_PrevAndNext(
1375                    long messageId, long groupId, long categoryId,
1376                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1377                    throws com.liferay.portal.kernel.exception.SystemException,
1378                            com.liferay.portlet.messageboards.NoSuchMessageException {
1379                    return getPersistence()
1380                                       .findByG_C_PrevAndNext(messageId, groupId, categoryId,
1381                            orderByComparator);
1382            }
1383    
1384            /**
1385            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1386            *
1387            * @param groupId the group ID to search with
1388            * @param categoryId the category ID to search with
1389            * @return the matching message-boards messages that the user has permission to view
1390            * @throws SystemException if a system exception occurred
1391            */
1392            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1393                    long groupId, long categoryId)
1394                    throws com.liferay.portal.kernel.exception.SystemException {
1395                    return getPersistence().filterFindByG_C(groupId, categoryId);
1396            }
1397    
1398            /**
1399            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1400            *
1401            * <p>
1402            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1403            * </p>
1404            *
1405            * @param groupId the group ID to search with
1406            * @param categoryId the category ID to search with
1407            * @param start the lower bound of the range of message-boards messages to return
1408            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1409            * @return the range of matching message-boards messages that the user has permission to view
1410            * @throws SystemException if a system exception occurred
1411            */
1412            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1413                    long groupId, long categoryId, int start, int end)
1414                    throws com.liferay.portal.kernel.exception.SystemException {
1415                    return getPersistence().filterFindByG_C(groupId, categoryId, start, end);
1416            }
1417    
1418            /**
1419            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1420            *
1421            * <p>
1422            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1423            * </p>
1424            *
1425            * @param groupId the group ID to search with
1426            * @param categoryId the category ID to search with
1427            * @param start the lower bound of the range of message-boards messages to return
1428            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1429            * @param orderByComparator the comparator to order the results by
1430            * @return the ordered range of matching message-boards messages that the user has permission to view
1431            * @throws SystemException if a system exception occurred
1432            */
1433            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C(
1434                    long groupId, long categoryId, int start, int end,
1435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1436                    throws com.liferay.portal.kernel.exception.SystemException {
1437                    return getPersistence()
1438                                       .filterFindByG_C(groupId, categoryId, start, end,
1439                            orderByComparator);
1440            }
1441    
1442            /**
1443            * Filters the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1444            *
1445            * <p>
1446            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1447            * </p>
1448            *
1449            * @param messageId the primary key of the current message-boards message
1450            * @param groupId the group ID to search with
1451            * @param categoryId the category ID to search with
1452            * @param orderByComparator the comparator to order the set by
1453            * @return the previous, current, and next message-boards message
1454            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1455            * @throws SystemException if a system exception occurred
1456            */
1457            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_PrevAndNext(
1458                    long messageId, long groupId, long categoryId,
1459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1460                    throws com.liferay.portal.kernel.exception.SystemException,
1461                            com.liferay.portlet.messageboards.NoSuchMessageException {
1462                    return getPersistence()
1463                                       .filterFindByG_C_PrevAndNext(messageId, groupId, categoryId,
1464                            orderByComparator);
1465            }
1466    
1467            /**
1468            * Finds all the message-boards messages where groupId = &#63; and status = &#63;.
1469            *
1470            * @param groupId the group ID to search with
1471            * @param status the status to search with
1472            * @return the matching message-boards messages
1473            * @throws SystemException if a system exception occurred
1474            */
1475            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
1476                    long groupId, int status)
1477                    throws com.liferay.portal.kernel.exception.SystemException {
1478                    return getPersistence().findByG_S(groupId, status);
1479            }
1480    
1481            /**
1482            * Finds a range of all the message-boards messages where groupId = &#63; and status = &#63;.
1483            *
1484            * <p>
1485            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1486            * </p>
1487            *
1488            * @param groupId the group ID to search with
1489            * @param status the status to search with
1490            * @param start the lower bound of the range of message-boards messages to return
1491            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1492            * @return the range of matching message-boards messages
1493            * @throws SystemException if a system exception occurred
1494            */
1495            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
1496                    long groupId, int status, int start, int end)
1497                    throws com.liferay.portal.kernel.exception.SystemException {
1498                    return getPersistence().findByG_S(groupId, status, start, end);
1499            }
1500    
1501            /**
1502            * Finds an ordered range of all the message-boards messages where groupId = &#63; and status = &#63;.
1503            *
1504            * <p>
1505            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1506            * </p>
1507            *
1508            * @param groupId the group ID to search with
1509            * @param status the status to search with
1510            * @param start the lower bound of the range of message-boards messages to return
1511            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1512            * @param orderByComparator the comparator to order the results by
1513            * @return the ordered range of matching message-boards messages
1514            * @throws SystemException if a system exception occurred
1515            */
1516            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S(
1517                    long groupId, int status, int start, int end,
1518                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1519                    throws com.liferay.portal.kernel.exception.SystemException {
1520                    return getPersistence()
1521                                       .findByG_S(groupId, status, start, end, orderByComparator);
1522            }
1523    
1524            /**
1525            * Finds the first message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1526            *
1527            * <p>
1528            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1529            * </p>
1530            *
1531            * @param groupId the group ID to search with
1532            * @param status the status to search with
1533            * @param orderByComparator the comparator to order the set by
1534            * @return the first matching message-boards message
1535            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1536            * @throws SystemException if a system exception occurred
1537            */
1538            public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_First(
1539                    long groupId, int status,
1540                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1541                    throws com.liferay.portal.kernel.exception.SystemException,
1542                            com.liferay.portlet.messageboards.NoSuchMessageException {
1543                    return getPersistence()
1544                                       .findByG_S_First(groupId, status, orderByComparator);
1545            }
1546    
1547            /**
1548            * Finds the last message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1549            *
1550            * <p>
1551            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1552            * </p>
1553            *
1554            * @param groupId the group ID to search with
1555            * @param status the status to search with
1556            * @param orderByComparator the comparator to order the set by
1557            * @return the last matching message-boards message
1558            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1559            * @throws SystemException if a system exception occurred
1560            */
1561            public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_Last(
1562                    long groupId, int status,
1563                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1564                    throws com.liferay.portal.kernel.exception.SystemException,
1565                            com.liferay.portlet.messageboards.NoSuchMessageException {
1566                    return getPersistence()
1567                                       .findByG_S_Last(groupId, status, orderByComparator);
1568            }
1569    
1570            /**
1571            * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1572            *
1573            * <p>
1574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1575            * </p>
1576            *
1577            * @param messageId the primary key of the current message-boards message
1578            * @param groupId the group ID to search with
1579            * @param status the status to search with
1580            * @param orderByComparator the comparator to order the set by
1581            * @return the previous, current, and next message-boards message
1582            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1583            * @throws SystemException if a system exception occurred
1584            */
1585            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_S_PrevAndNext(
1586                    long messageId, long groupId, int status,
1587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1588                    throws com.liferay.portal.kernel.exception.SystemException,
1589                            com.liferay.portlet.messageboards.NoSuchMessageException {
1590                    return getPersistence()
1591                                       .findByG_S_PrevAndNext(messageId, groupId, status,
1592                            orderByComparator);
1593            }
1594    
1595            /**
1596            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and status = &#63;.
1597            *
1598            * @param groupId the group ID to search with
1599            * @param status the status to search with
1600            * @return the matching message-boards messages that the user has permission to view
1601            * @throws SystemException if a system exception occurred
1602            */
1603            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
1604                    long groupId, int status)
1605                    throws com.liferay.portal.kernel.exception.SystemException {
1606                    return getPersistence().filterFindByG_S(groupId, status);
1607            }
1608    
1609            /**
1610            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and status = &#63;.
1611            *
1612            * <p>
1613            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1614            * </p>
1615            *
1616            * @param groupId the group ID to search with
1617            * @param status the status to search with
1618            * @param start the lower bound of the range of message-boards messages to return
1619            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1620            * @return the range of matching message-boards messages that the user has permission to view
1621            * @throws SystemException if a system exception occurred
1622            */
1623            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
1624                    long groupId, int status, int start, int end)
1625                    throws com.liferay.portal.kernel.exception.SystemException {
1626                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1627            }
1628    
1629            /**
1630            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and status = &#63;.
1631            *
1632            * <p>
1633            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1634            * </p>
1635            *
1636            * @param groupId the group ID to search with
1637            * @param status the status to search with
1638            * @param start the lower bound of the range of message-boards messages to return
1639            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1640            * @param orderByComparator the comparator to order the results by
1641            * @return the ordered range of matching message-boards messages that the user has permission to view
1642            * @throws SystemException if a system exception occurred
1643            */
1644            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S(
1645                    long groupId, int status, int start, int end,
1646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1647                    throws com.liferay.portal.kernel.exception.SystemException {
1648                    return getPersistence()
1649                                       .filterFindByG_S(groupId, status, start, end,
1650                            orderByComparator);
1651            }
1652    
1653            /**
1654            * Filters the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1655            *
1656            * <p>
1657            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1658            * </p>
1659            *
1660            * @param messageId the primary key of the current message-boards message
1661            * @param groupId the group ID to search with
1662            * @param status the status to search with
1663            * @param orderByComparator the comparator to order the set by
1664            * @return the previous, current, and next message-boards message
1665            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1666            * @throws SystemException if a system exception occurred
1667            */
1668            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_S_PrevAndNext(
1669                    long messageId, long groupId, int status,
1670                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1671                    throws com.liferay.portal.kernel.exception.SystemException,
1672                            com.liferay.portlet.messageboards.NoSuchMessageException {
1673                    return getPersistence()
1674                                       .filterFindByG_S_PrevAndNext(messageId, groupId, status,
1675                            orderByComparator);
1676            }
1677    
1678            /**
1679            * Finds all the message-boards messages where companyId = &#63; and status = &#63;.
1680            *
1681            * @param companyId the company ID to search with
1682            * @param status the status to search with
1683            * @return the matching message-boards messages
1684            * @throws SystemException if a system exception occurred
1685            */
1686            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
1687                    long companyId, int status)
1688                    throws com.liferay.portal.kernel.exception.SystemException {
1689                    return getPersistence().findByC_S(companyId, status);
1690            }
1691    
1692            /**
1693            * Finds a range of all the message-boards messages where companyId = &#63; and status = &#63;.
1694            *
1695            * <p>
1696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1697            * </p>
1698            *
1699            * @param companyId the company ID to search with
1700            * @param status the status to search with
1701            * @param start the lower bound of the range of message-boards messages to return
1702            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1703            * @return the range of matching message-boards messages
1704            * @throws SystemException if a system exception occurred
1705            */
1706            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
1707                    long companyId, int status, int start, int end)
1708                    throws com.liferay.portal.kernel.exception.SystemException {
1709                    return getPersistence().findByC_S(companyId, status, start, end);
1710            }
1711    
1712            /**
1713            * Finds an ordered range of all the message-boards messages where companyId = &#63; and status = &#63;.
1714            *
1715            * <p>
1716            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1717            * </p>
1718            *
1719            * @param companyId the company ID to search with
1720            * @param status the status to search with
1721            * @param start the lower bound of the range of message-boards messages to return
1722            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1723            * @param orderByComparator the comparator to order the results by
1724            * @return the ordered range of matching message-boards messages
1725            * @throws SystemException if a system exception occurred
1726            */
1727            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S(
1728                    long companyId, int status, int start, int end,
1729                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1730                    throws com.liferay.portal.kernel.exception.SystemException {
1731                    return getPersistence()
1732                                       .findByC_S(companyId, status, start, end, orderByComparator);
1733            }
1734    
1735            /**
1736            * Finds the first message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1737            *
1738            * <p>
1739            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1740            * </p>
1741            *
1742            * @param companyId the company ID to search with
1743            * @param status the status to search with
1744            * @param orderByComparator the comparator to order the set by
1745            * @return the first matching message-boards message
1746            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1747            * @throws SystemException if a system exception occurred
1748            */
1749            public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_First(
1750                    long companyId, int status,
1751                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1752                    throws com.liferay.portal.kernel.exception.SystemException,
1753                            com.liferay.portlet.messageboards.NoSuchMessageException {
1754                    return getPersistence()
1755                                       .findByC_S_First(companyId, status, orderByComparator);
1756            }
1757    
1758            /**
1759            * Finds the last message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1760            *
1761            * <p>
1762            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1763            * </p>
1764            *
1765            * @param companyId the company ID to search with
1766            * @param status the status to search with
1767            * @param orderByComparator the comparator to order the set by
1768            * @return the last matching message-boards message
1769            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1770            * @throws SystemException if a system exception occurred
1771            */
1772            public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_Last(
1773                    long companyId, int status,
1774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1775                    throws com.liferay.portal.kernel.exception.SystemException,
1776                            com.liferay.portlet.messageboards.NoSuchMessageException {
1777                    return getPersistence()
1778                                       .findByC_S_Last(companyId, status, orderByComparator);
1779            }
1780    
1781            /**
1782            * Finds the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1783            *
1784            * <p>
1785            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1786            * </p>
1787            *
1788            * @param messageId the primary key of the current message-boards message
1789            * @param companyId the company ID to search with
1790            * @param status the status to search with
1791            * @param orderByComparator the comparator to order the set by
1792            * @return the previous, current, and next message-boards message
1793            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1794            * @throws SystemException if a system exception occurred
1795            */
1796            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_S_PrevAndNext(
1797                    long messageId, long companyId, int status,
1798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1799                    throws com.liferay.portal.kernel.exception.SystemException,
1800                            com.liferay.portlet.messageboards.NoSuchMessageException {
1801                    return getPersistence()
1802                                       .findByC_S_PrevAndNext(messageId, companyId, status,
1803                            orderByComparator);
1804            }
1805    
1806            /**
1807            * Finds all the message-boards messages where classNameId = &#63; and classPK = &#63;.
1808            *
1809            * @param classNameId the class name ID to search with
1810            * @param classPK the class p k to search with
1811            * @return the matching message-boards messages
1812            * @throws SystemException if a system exception occurred
1813            */
1814            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
1815                    long classNameId, long classPK)
1816                    throws com.liferay.portal.kernel.exception.SystemException {
1817                    return getPersistence().findByC_C(classNameId, classPK);
1818            }
1819    
1820            /**
1821            * Finds a range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
1822            *
1823            * <p>
1824            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1825            * </p>
1826            *
1827            * @param classNameId the class name ID to search with
1828            * @param classPK the class p k to search with
1829            * @param start the lower bound of the range of message-boards messages to return
1830            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1831            * @return the range of matching message-boards messages
1832            * @throws SystemException if a system exception occurred
1833            */
1834            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
1835                    long classNameId, long classPK, int start, int end)
1836                    throws com.liferay.portal.kernel.exception.SystemException {
1837                    return getPersistence().findByC_C(classNameId, classPK, start, end);
1838            }
1839    
1840            /**
1841            * Finds an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
1842            *
1843            * <p>
1844            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1845            * </p>
1846            *
1847            * @param classNameId the class name ID to search with
1848            * @param classPK the class p k to search with
1849            * @param start the lower bound of the range of message-boards messages to return
1850            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1851            * @param orderByComparator the comparator to order the results by
1852            * @return the ordered range of matching message-boards messages
1853            * @throws SystemException if a system exception occurred
1854            */
1855            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C(
1856                    long classNameId, long classPK, int start, int end,
1857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1858                    throws com.liferay.portal.kernel.exception.SystemException {
1859                    return getPersistence()
1860                                       .findByC_C(classNameId, classPK, start, end,
1861                            orderByComparator);
1862            }
1863    
1864            /**
1865            * Finds the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
1866            *
1867            * <p>
1868            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1869            * </p>
1870            *
1871            * @param classNameId the class name ID to search with
1872            * @param classPK the class p k to search with
1873            * @param orderByComparator the comparator to order the set by
1874            * @return the first matching message-boards message
1875            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1876            * @throws SystemException if a system exception occurred
1877            */
1878            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_First(
1879                    long classNameId, long classPK,
1880                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1881                    throws com.liferay.portal.kernel.exception.SystemException,
1882                            com.liferay.portlet.messageboards.NoSuchMessageException {
1883                    return getPersistence()
1884                                       .findByC_C_First(classNameId, classPK, orderByComparator);
1885            }
1886    
1887            /**
1888            * Finds the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
1889            *
1890            * <p>
1891            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1892            * </p>
1893            *
1894            * @param classNameId the class name ID to search with
1895            * @param classPK the class p k to search with
1896            * @param orderByComparator the comparator to order the set by
1897            * @return the last matching message-boards message
1898            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
1899            * @throws SystemException if a system exception occurred
1900            */
1901            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_Last(
1902                    long classNameId, long classPK,
1903                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1904                    throws com.liferay.portal.kernel.exception.SystemException,
1905                            com.liferay.portlet.messageboards.NoSuchMessageException {
1906                    return getPersistence()
1907                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
1908            }
1909    
1910            /**
1911            * Finds the message-boards messages before and after the current message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
1912            *
1913            * <p>
1914            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1915            * </p>
1916            *
1917            * @param messageId the primary key of the current message-boards message
1918            * @param classNameId the class name ID to search with
1919            * @param classPK the class p k to search with
1920            * @param orderByComparator the comparator to order the set by
1921            * @return the previous, current, and next message-boards message
1922            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
1923            * @throws SystemException if a system exception occurred
1924            */
1925            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_PrevAndNext(
1926                    long messageId, long classNameId, long classPK,
1927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1928                    throws com.liferay.portal.kernel.exception.SystemException,
1929                            com.liferay.portlet.messageboards.NoSuchMessageException {
1930                    return getPersistence()
1931                                       .findByC_C_PrevAndNext(messageId, classNameId, classPK,
1932                            orderByComparator);
1933            }
1934    
1935            /**
1936            * Finds all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
1937            *
1938            * @param threadId the thread ID to search with
1939            * @param parentMessageId the parent message ID to search with
1940            * @return the matching message-boards messages
1941            * @throws SystemException if a system exception occurred
1942            */
1943            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
1944                    long threadId, long parentMessageId)
1945                    throws com.liferay.portal.kernel.exception.SystemException {
1946                    return getPersistence().findByT_P(threadId, parentMessageId);
1947            }
1948    
1949            /**
1950            * Finds a range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
1951            *
1952            * <p>
1953            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1954            * </p>
1955            *
1956            * @param threadId the thread ID to search with
1957            * @param parentMessageId the parent message ID to search with
1958            * @param start the lower bound of the range of message-boards messages to return
1959            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1960            * @return the range of matching message-boards messages
1961            * @throws SystemException if a system exception occurred
1962            */
1963            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
1964                    long threadId, long parentMessageId, int start, int end)
1965                    throws com.liferay.portal.kernel.exception.SystemException {
1966                    return getPersistence().findByT_P(threadId, parentMessageId, start, end);
1967            }
1968    
1969            /**
1970            * Finds an ordered range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
1971            *
1972            * <p>
1973            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1974            * </p>
1975            *
1976            * @param threadId the thread ID to search with
1977            * @param parentMessageId the parent message ID to search with
1978            * @param start the lower bound of the range of message-boards messages to return
1979            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
1980            * @param orderByComparator the comparator to order the results by
1981            * @return the ordered range of matching message-boards messages
1982            * @throws SystemException if a system exception occurred
1983            */
1984            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P(
1985                    long threadId, long parentMessageId, int start, int end,
1986                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1987                    throws com.liferay.portal.kernel.exception.SystemException {
1988                    return getPersistence()
1989                                       .findByT_P(threadId, parentMessageId, start, end,
1990                            orderByComparator);
1991            }
1992    
1993            /**
1994            * Finds the first message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
1995            *
1996            * <p>
1997            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1998            * </p>
1999            *
2000            * @param threadId the thread ID to search with
2001            * @param parentMessageId the parent message ID to search with
2002            * @param orderByComparator the comparator to order the set by
2003            * @return the first matching message-boards message
2004            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2005            * @throws SystemException if a system exception occurred
2006            */
2007            public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_First(
2008                    long threadId, long parentMessageId,
2009                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2010                    throws com.liferay.portal.kernel.exception.SystemException,
2011                            com.liferay.portlet.messageboards.NoSuchMessageException {
2012                    return getPersistence()
2013                                       .findByT_P_First(threadId, parentMessageId, orderByComparator);
2014            }
2015    
2016            /**
2017            * Finds the last message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2018            *
2019            * <p>
2020            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2021            * </p>
2022            *
2023            * @param threadId the thread ID to search with
2024            * @param parentMessageId the parent message ID to search with
2025            * @param orderByComparator the comparator to order the set by
2026            * @return the last matching message-boards message
2027            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2028            * @throws SystemException if a system exception occurred
2029            */
2030            public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_Last(
2031                    long threadId, long parentMessageId,
2032                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2033                    throws com.liferay.portal.kernel.exception.SystemException,
2034                            com.liferay.portlet.messageboards.NoSuchMessageException {
2035                    return getPersistence()
2036                                       .findByT_P_Last(threadId, parentMessageId, orderByComparator);
2037            }
2038    
2039            /**
2040            * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#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 messageId the primary key of the current message-boards message
2047            * @param threadId the thread ID to search with
2048            * @param parentMessageId the parent message ID to search with
2049            * @param orderByComparator the comparator to order the set by
2050            * @return the previous, current, and next message-boards message
2051            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2052            * @throws SystemException if a system exception occurred
2053            */
2054            public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_P_PrevAndNext(
2055                    long messageId, long threadId, long parentMessageId,
2056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2057                    throws com.liferay.portal.kernel.exception.SystemException,
2058                            com.liferay.portlet.messageboards.NoSuchMessageException {
2059                    return getPersistence()
2060                                       .findByT_P_PrevAndNext(messageId, threadId, parentMessageId,
2061                            orderByComparator);
2062            }
2063    
2064            /**
2065            * Finds all the message-boards messages where threadId = &#63; and status = &#63;.
2066            *
2067            * @param threadId the thread ID to search with
2068            * @param status the status to search with
2069            * @return the matching message-boards messages
2070            * @throws SystemException if a system exception occurred
2071            */
2072            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
2073                    long threadId, int status)
2074                    throws com.liferay.portal.kernel.exception.SystemException {
2075                    return getPersistence().findByT_S(threadId, status);
2076            }
2077    
2078            /**
2079            * Finds a range of all the message-boards messages where threadId = &#63; and status = &#63;.
2080            *
2081            * <p>
2082            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2083            * </p>
2084            *
2085            * @param threadId the thread ID to search with
2086            * @param status the status to search with
2087            * @param start the lower bound of the range of message-boards messages to return
2088            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2089            * @return the range of matching message-boards messages
2090            * @throws SystemException if a system exception occurred
2091            */
2092            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
2093                    long threadId, int status, int start, int end)
2094                    throws com.liferay.portal.kernel.exception.SystemException {
2095                    return getPersistence().findByT_S(threadId, status, start, end);
2096            }
2097    
2098            /**
2099            * Finds an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2100            *
2101            * <p>
2102            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2103            * </p>
2104            *
2105            * @param threadId the thread ID to search with
2106            * @param status the status to search with
2107            * @param start the lower bound of the range of message-boards messages to return
2108            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2109            * @param orderByComparator the comparator to order the results by
2110            * @return the ordered range of matching message-boards messages
2111            * @throws SystemException if a system exception occurred
2112            */
2113            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S(
2114                    long threadId, int status, int start, int end,
2115                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2116                    throws com.liferay.portal.kernel.exception.SystemException {
2117                    return getPersistence()
2118                                       .findByT_S(threadId, status, start, end, orderByComparator);
2119            }
2120    
2121            /**
2122            * Finds the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2123            *
2124            * <p>
2125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2126            * </p>
2127            *
2128            * @param threadId the thread ID to search with
2129            * @param status the status to search with
2130            * @param orderByComparator the comparator to order the set by
2131            * @return the first matching message-boards message
2132            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2133            * @throws SystemException if a system exception occurred
2134            */
2135            public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_First(
2136                    long threadId, int status,
2137                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2138                    throws com.liferay.portal.kernel.exception.SystemException,
2139                            com.liferay.portlet.messageboards.NoSuchMessageException {
2140                    return getPersistence()
2141                                       .findByT_S_First(threadId, status, orderByComparator);
2142            }
2143    
2144            /**
2145            * Finds the last message-boards message in the ordered set where threadId = &#63; and status = &#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 to search with
2152            * @param status the status to search with
2153            * @param orderByComparator the comparator to order the set by
2154            * @return the last matching message-boards message
2155            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2156            * @throws SystemException if a system exception occurred
2157            */
2158            public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_Last(
2159                    long threadId, int status,
2160                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2161                    throws com.liferay.portal.kernel.exception.SystemException,
2162                            com.liferay.portlet.messageboards.NoSuchMessageException {
2163                    return getPersistence()
2164                                       .findByT_S_Last(threadId, status, orderByComparator);
2165            }
2166    
2167            /**
2168            * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2169            *
2170            * <p>
2171            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2172            * </p>
2173            *
2174            * @param messageId the primary key of the current message-boards message
2175            * @param threadId the thread ID to search with
2176            * @param status the status to search with
2177            * @param orderByComparator the comparator to order the set by
2178            * @return the previous, current, and next message-boards message
2179            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2180            * @throws SystemException if a system exception occurred
2181            */
2182            public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_S_PrevAndNext(
2183                    long messageId, long threadId, int status,
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_S_PrevAndNext(messageId, threadId, status,
2189                            orderByComparator);
2190            }
2191    
2192            /**
2193            * Finds all the message-boards messages where threadId = &#63; and status = &#63;.
2194            *
2195            * @param threadId the thread ID to search with
2196            * @param status the status to search with
2197            * @return the matching message-boards messages
2198            * @throws SystemException if a system exception occurred
2199            */
2200            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
2201                    long threadId, int status)
2202                    throws com.liferay.portal.kernel.exception.SystemException {
2203                    return getPersistence().findByTR_S(threadId, status);
2204            }
2205    
2206            /**
2207            * Finds a range of all the message-boards messages where threadId = &#63; and status = &#63;.
2208            *
2209            * <p>
2210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2211            * </p>
2212            *
2213            * @param threadId the thread ID to search with
2214            * @param status the status to search with
2215            * @param start the lower bound of the range of message-boards messages to return
2216            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2217            * @return the range of matching message-boards messages
2218            * @throws SystemException if a system exception occurred
2219            */
2220            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
2221                    long threadId, int status, int start, int end)
2222                    throws com.liferay.portal.kernel.exception.SystemException {
2223                    return getPersistence().findByTR_S(threadId, status, start, end);
2224            }
2225    
2226            /**
2227            * Finds an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2228            *
2229            * <p>
2230            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2231            * </p>
2232            *
2233            * @param threadId the thread ID to search with
2234            * @param status the status to search with
2235            * @param start the lower bound of the range of message-boards messages to return
2236            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2237            * @param orderByComparator the comparator to order the results by
2238            * @return the ordered range of matching message-boards messages
2239            * @throws SystemException if a system exception occurred
2240            */
2241            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S(
2242                    long threadId, int status, int start, int end,
2243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2244                    throws com.liferay.portal.kernel.exception.SystemException {
2245                    return getPersistence()
2246                                       .findByTR_S(threadId, status, start, end, orderByComparator);
2247            }
2248    
2249            /**
2250            * Finds the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2251            *
2252            * <p>
2253            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2254            * </p>
2255            *
2256            * @param threadId the thread ID to search with
2257            * @param status the status to search with
2258            * @param orderByComparator the comparator to order the set by
2259            * @return the first matching message-boards message
2260            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2261            * @throws SystemException if a system exception occurred
2262            */
2263            public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_First(
2264                    long threadId, int status,
2265                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2266                    throws com.liferay.portal.kernel.exception.SystemException,
2267                            com.liferay.portlet.messageboards.NoSuchMessageException {
2268                    return getPersistence()
2269                                       .findByTR_S_First(threadId, status, orderByComparator);
2270            }
2271    
2272            /**
2273            * Finds the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2274            *
2275            * <p>
2276            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2277            * </p>
2278            *
2279            * @param threadId the thread ID to search with
2280            * @param status the status to search with
2281            * @param orderByComparator the comparator to order the set by
2282            * @return the last matching message-boards message
2283            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2284            * @throws SystemException if a system exception occurred
2285            */
2286            public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_Last(
2287                    long threadId, int status,
2288                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2289                    throws com.liferay.portal.kernel.exception.SystemException,
2290                            com.liferay.portlet.messageboards.NoSuchMessageException {
2291                    return getPersistence()
2292                                       .findByTR_S_Last(threadId, status, orderByComparator);
2293            }
2294    
2295            /**
2296            * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2297            *
2298            * <p>
2299            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2300            * </p>
2301            *
2302            * @param messageId the primary key of the current message-boards message
2303            * @param threadId the thread ID to search with
2304            * @param status the status to search with
2305            * @param orderByComparator the comparator to order the set by
2306            * @return the previous, current, and next message-boards message
2307            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2308            * @throws SystemException if a system exception occurred
2309            */
2310            public static com.liferay.portlet.messageboards.model.MBMessage[] findByTR_S_PrevAndNext(
2311                    long messageId, long threadId, int status,
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                                       .findByTR_S_PrevAndNext(messageId, threadId, status,
2317                            orderByComparator);
2318            }
2319    
2320            /**
2321            * Finds all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2322            *
2323            * @param groupId the group ID to search with
2324            * @param userId the user ID to search with
2325            * @param status the status to search with
2326            * @return the matching message-boards messages
2327            * @throws SystemException if a system exception occurred
2328            */
2329            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
2330                    long groupId, long userId, int status)
2331                    throws com.liferay.portal.kernel.exception.SystemException {
2332                    return getPersistence().findByG_U_S(groupId, userId, status);
2333            }
2334    
2335            /**
2336            * Finds a range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2337            *
2338            * <p>
2339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2340            * </p>
2341            *
2342            * @param groupId the group ID to search with
2343            * @param userId the user ID to search with
2344            * @param status the status to search with
2345            * @param start the lower bound of the range of message-boards messages to return
2346            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2347            * @return the range of matching message-boards messages
2348            * @throws SystemException if a system exception occurred
2349            */
2350            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
2351                    long groupId, long userId, int status, int start, int end)
2352                    throws com.liferay.portal.kernel.exception.SystemException {
2353                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
2354            }
2355    
2356            /**
2357            * Finds an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2358            *
2359            * <p>
2360            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2361            * </p>
2362            *
2363            * @param groupId the group ID to search with
2364            * @param userId the user ID to search with
2365            * @param status the status to search with
2366            * @param start the lower bound of the range of message-boards messages to return
2367            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2368            * @param orderByComparator the comparator to order the results by
2369            * @return the ordered range of matching message-boards messages
2370            * @throws SystemException if a system exception occurred
2371            */
2372            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S(
2373                    long groupId, long userId, int status, int start, int end,
2374                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2375                    throws com.liferay.portal.kernel.exception.SystemException {
2376                    return getPersistence()
2377                                       .findByG_U_S(groupId, userId, status, start, end,
2378                            orderByComparator);
2379            }
2380    
2381            /**
2382            * Finds the first message-boards message in the ordered set where groupId = &#63; and userId = &#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 groupId the group ID to search with
2389            * @param userId the user ID to search with
2390            * @param status the status to search with
2391            * @param orderByComparator the comparator to order the set by
2392            * @return the first matching message-boards message
2393            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2394            * @throws SystemException if a system exception occurred
2395            */
2396            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_First(
2397                    long groupId, long userId, int status,
2398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2399                    throws com.liferay.portal.kernel.exception.SystemException,
2400                            com.liferay.portlet.messageboards.NoSuchMessageException {
2401                    return getPersistence()
2402                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
2403            }
2404    
2405            /**
2406            * Finds the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2407            *
2408            * <p>
2409            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2410            * </p>
2411            *
2412            * @param groupId the group ID to search with
2413            * @param userId the user ID to search with
2414            * @param status the status to search with
2415            * @param orderByComparator the comparator to order the set by
2416            * @return the last matching message-boards message
2417            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2418            * @throws SystemException if a system exception occurred
2419            */
2420            public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_Last(
2421                    long groupId, long userId, int status,
2422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2423                    throws com.liferay.portal.kernel.exception.SystemException,
2424                            com.liferay.portlet.messageboards.NoSuchMessageException {
2425                    return getPersistence()
2426                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
2427            }
2428    
2429            /**
2430            * Finds 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;.
2431            *
2432            * <p>
2433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2434            * </p>
2435            *
2436            * @param messageId the primary key of the current message-boards message
2437            * @param groupId the group ID to search with
2438            * @param userId the user ID to search with
2439            * @param status the status to search with
2440            * @param orderByComparator the comparator to order the set by
2441            * @return the previous, current, and next message-boards message
2442            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2443            * @throws SystemException if a system exception occurred
2444            */
2445            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_S_PrevAndNext(
2446                    long messageId, long groupId, long userId, int status,
2447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2448                    throws com.liferay.portal.kernel.exception.SystemException,
2449                            com.liferay.portlet.messageboards.NoSuchMessageException {
2450                    return getPersistence()
2451                                       .findByG_U_S_PrevAndNext(messageId, groupId, userId, status,
2452                            orderByComparator);
2453            }
2454    
2455            /**
2456            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2457            *
2458            * @param groupId the group ID to search with
2459            * @param userId the user ID to search with
2460            * @param status the status to search with
2461            * @return the matching message-boards messages that the user has permission to view
2462            * @throws SystemException if a system exception occurred
2463            */
2464            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
2465                    long groupId, long userId, int status)
2466                    throws com.liferay.portal.kernel.exception.SystemException {
2467                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
2468            }
2469    
2470            /**
2471            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and userId = &#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 groupId the group ID to search with
2478            * @param userId the user ID to search with
2479            * @param status the status to search with
2480            * @param start the lower bound of the range of message-boards messages to return
2481            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2482            * @return the range of matching message-boards messages that the user has permission to view
2483            * @throws SystemException if a system exception occurred
2484            */
2485            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
2486                    long groupId, long userId, int status, int start, int end)
2487                    throws com.liferay.portal.kernel.exception.SystemException {
2488                    return getPersistence()
2489                                       .filterFindByG_U_S(groupId, userId, status, start, end);
2490            }
2491    
2492            /**
2493            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2494            *
2495            * <p>
2496            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2497            * </p>
2498            *
2499            * @param groupId the group ID to search with
2500            * @param userId the user ID to search with
2501            * @param status the status to search with
2502            * @param start the lower bound of the range of message-boards messages to return
2503            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2504            * @param orderByComparator the comparator to order the results by
2505            * @return the ordered range of matching message-boards messages that the user has permission to view
2506            * @throws SystemException if a system exception occurred
2507            */
2508            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S(
2509                    long groupId, long userId, int status, int start, int end,
2510                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2511                    throws com.liferay.portal.kernel.exception.SystemException {
2512                    return getPersistence()
2513                                       .filterFindByG_U_S(groupId, userId, status, start, end,
2514                            orderByComparator);
2515            }
2516    
2517            /**
2518            * Filters 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;.
2519            *
2520            * <p>
2521            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2522            * </p>
2523            *
2524            * @param messageId the primary key of the current message-boards message
2525            * @param groupId the group ID to search with
2526            * @param userId the user ID to search with
2527            * @param status the status to search with
2528            * @param orderByComparator the comparator to order the set by
2529            * @return the previous, current, and next message-boards message
2530            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2531            * @throws SystemException if a system exception occurred
2532            */
2533            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_U_S_PrevAndNext(
2534                    long messageId, long groupId, long userId, int status,
2535                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2536                    throws com.liferay.portal.kernel.exception.SystemException,
2537                            com.liferay.portlet.messageboards.NoSuchMessageException {
2538                    return getPersistence()
2539                                       .filterFindByG_U_S_PrevAndNext(messageId, groupId, userId,
2540                            status, orderByComparator);
2541            }
2542    
2543            /**
2544            * Finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2545            *
2546            * @param groupId the group ID to search with
2547            * @param categoryId the category ID to search with
2548            * @param threadId the thread ID to search with
2549            * @return the matching message-boards messages
2550            * @throws SystemException if a system exception occurred
2551            */
2552            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
2553                    long groupId, long categoryId, long threadId)
2554                    throws com.liferay.portal.kernel.exception.SystemException {
2555                    return getPersistence().findByG_C_T(groupId, categoryId, threadId);
2556            }
2557    
2558            /**
2559            * Finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2560            *
2561            * <p>
2562            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2563            * </p>
2564            *
2565            * @param groupId the group ID to search with
2566            * @param categoryId the category ID to search with
2567            * @param threadId the thread ID to search with
2568            * @param start the lower bound of the range of message-boards messages to return
2569            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2570            * @return the range of matching message-boards messages
2571            * @throws SystemException if a system exception occurred
2572            */
2573            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
2574                    long groupId, long categoryId, long threadId, int start, int end)
2575                    throws com.liferay.portal.kernel.exception.SystemException {
2576                    return getPersistence()
2577                                       .findByG_C_T(groupId, categoryId, threadId, start, end);
2578            }
2579    
2580            /**
2581            * Finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2582            *
2583            * <p>
2584            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2585            * </p>
2586            *
2587            * @param groupId the group ID to search with
2588            * @param categoryId the category ID to search with
2589            * @param threadId the thread ID to search with
2590            * @param start the lower bound of the range of message-boards messages to return
2591            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2592            * @param orderByComparator the comparator to order the results by
2593            * @return the ordered range of matching message-boards messages
2594            * @throws SystemException if a system exception occurred
2595            */
2596            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T(
2597                    long groupId, long categoryId, long threadId, int start, int end,
2598                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2599                    throws com.liferay.portal.kernel.exception.SystemException {
2600                    return getPersistence()
2601                                       .findByG_C_T(groupId, categoryId, threadId, start, end,
2602                            orderByComparator);
2603            }
2604    
2605            /**
2606            * Finds the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2607            *
2608            * <p>
2609            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2610            * </p>
2611            *
2612            * @param groupId the group ID to search with
2613            * @param categoryId the category ID to search with
2614            * @param threadId the thread ID to search with
2615            * @param orderByComparator the comparator to order the set by
2616            * @return the first matching message-boards message
2617            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2618            * @throws SystemException if a system exception occurred
2619            */
2620            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_First(
2621                    long groupId, long categoryId, long threadId,
2622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2623                    throws com.liferay.portal.kernel.exception.SystemException,
2624                            com.liferay.portlet.messageboards.NoSuchMessageException {
2625                    return getPersistence()
2626                                       .findByG_C_T_First(groupId, categoryId, threadId,
2627                            orderByComparator);
2628            }
2629    
2630            /**
2631            * Finds the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2632            *
2633            * <p>
2634            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2635            * </p>
2636            *
2637            * @param groupId the group ID to search with
2638            * @param categoryId the category ID to search with
2639            * @param threadId the thread ID to search with
2640            * @param orderByComparator the comparator to order the set by
2641            * @return the last matching message-boards message
2642            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2643            * @throws SystemException if a system exception occurred
2644            */
2645            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_Last(
2646                    long groupId, long categoryId, long threadId,
2647                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2648                    throws com.liferay.portal.kernel.exception.SystemException,
2649                            com.liferay.portlet.messageboards.NoSuchMessageException {
2650                    return getPersistence()
2651                                       .findByG_C_T_Last(groupId, categoryId, threadId,
2652                            orderByComparator);
2653            }
2654    
2655            /**
2656            * Finds 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;.
2657            *
2658            * <p>
2659            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2660            * </p>
2661            *
2662            * @param messageId the primary key of the current message-boards message
2663            * @param groupId the group ID to search with
2664            * @param categoryId the category ID to search with
2665            * @param threadId the thread ID to search with
2666            * @param orderByComparator the comparator to order the set by
2667            * @return the previous, current, and next message-boards message
2668            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2669            * @throws SystemException if a system exception occurred
2670            */
2671            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_PrevAndNext(
2672                    long messageId, long groupId, long categoryId, long threadId,
2673                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2674                    throws com.liferay.portal.kernel.exception.SystemException,
2675                            com.liferay.portlet.messageboards.NoSuchMessageException {
2676                    return getPersistence()
2677                                       .findByG_C_T_PrevAndNext(messageId, groupId, categoryId,
2678                            threadId, orderByComparator);
2679            }
2680    
2681            /**
2682            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2683            *
2684            * @param groupId the group ID to search with
2685            * @param categoryId the category ID to search with
2686            * @param threadId the thread ID to search with
2687            * @return the matching message-boards messages that the user has permission to view
2688            * @throws SystemException if a system exception occurred
2689            */
2690            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
2691                    long groupId, long categoryId, long threadId)
2692                    throws com.liferay.portal.kernel.exception.SystemException {
2693                    return getPersistence().filterFindByG_C_T(groupId, categoryId, threadId);
2694            }
2695    
2696            /**
2697            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2698            *
2699            * <p>
2700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2701            * </p>
2702            *
2703            * @param groupId the group ID to search with
2704            * @param categoryId the category ID to search with
2705            * @param threadId the thread ID to search with
2706            * @param start the lower bound of the range of message-boards messages to return
2707            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2708            * @return the range of matching message-boards messages that the user has permission to view
2709            * @throws SystemException if a system exception occurred
2710            */
2711            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
2712                    long groupId, long categoryId, long threadId, int start, int end)
2713                    throws com.liferay.portal.kernel.exception.SystemException {
2714                    return getPersistence()
2715                                       .filterFindByG_C_T(groupId, categoryId, threadId, start, end);
2716            }
2717    
2718            /**
2719            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
2720            *
2721            * <p>
2722            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2723            * </p>
2724            *
2725            * @param groupId the group ID to search with
2726            * @param categoryId the category ID to search with
2727            * @param threadId the thread ID to search with
2728            * @param start the lower bound of the range of message-boards messages to return
2729            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2730            * @param orderByComparator the comparator to order the results by
2731            * @return the ordered range of matching message-boards messages that the user has permission to view
2732            * @throws SystemException if a system exception occurred
2733            */
2734            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T(
2735                    long groupId, long categoryId, long threadId, int start, int end,
2736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2737                    throws com.liferay.portal.kernel.exception.SystemException {
2738                    return getPersistence()
2739                                       .filterFindByG_C_T(groupId, categoryId, threadId, start,
2740                            end, orderByComparator);
2741            }
2742    
2743            /**
2744            * Filters 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;.
2745            *
2746            * <p>
2747            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2748            * </p>
2749            *
2750            * @param messageId the primary key of the current message-boards message
2751            * @param groupId the group ID to search with
2752            * @param categoryId the category ID to search with
2753            * @param threadId the thread ID to search with
2754            * @param orderByComparator the comparator to order the set by
2755            * @return the previous, current, and next message-boards message
2756            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2757            * @throws SystemException if a system exception occurred
2758            */
2759            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_T_PrevAndNext(
2760                    long messageId, long groupId, long categoryId, long threadId,
2761                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2762                    throws com.liferay.portal.kernel.exception.SystemException,
2763                            com.liferay.portlet.messageboards.NoSuchMessageException {
2764                    return getPersistence()
2765                                       .filterFindByG_C_T_PrevAndNext(messageId, groupId,
2766                            categoryId, threadId, orderByComparator);
2767            }
2768    
2769            /**
2770            * Finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2771            *
2772            * @param groupId the group ID to search with
2773            * @param categoryId the category ID to search with
2774            * @param status the status to search with
2775            * @return the matching message-boards messages
2776            * @throws SystemException if a system exception occurred
2777            */
2778            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
2779                    long groupId, long categoryId, int status)
2780                    throws com.liferay.portal.kernel.exception.SystemException {
2781                    return getPersistence().findByG_C_S(groupId, categoryId, status);
2782            }
2783    
2784            /**
2785            * Finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2786            *
2787            * <p>
2788            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2789            * </p>
2790            *
2791            * @param groupId the group ID to search with
2792            * @param categoryId the category ID to search with
2793            * @param status the status to search with
2794            * @param start the lower bound of the range of message-boards messages to return
2795            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2796            * @return the range of matching message-boards messages
2797            * @throws SystemException if a system exception occurred
2798            */
2799            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
2800                    long groupId, long categoryId, int status, int start, int end)
2801                    throws com.liferay.portal.kernel.exception.SystemException {
2802                    return getPersistence()
2803                                       .findByG_C_S(groupId, categoryId, status, start, end);
2804            }
2805    
2806            /**
2807            * Finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2808            *
2809            * <p>
2810            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2811            * </p>
2812            *
2813            * @param groupId the group ID to search with
2814            * @param categoryId the category ID to search with
2815            * @param status the status to search with
2816            * @param start the lower bound of the range of message-boards messages to return
2817            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2818            * @param orderByComparator the comparator to order the results by
2819            * @return the ordered range of matching message-boards messages
2820            * @throws SystemException if a system exception occurred
2821            */
2822            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S(
2823                    long groupId, long categoryId, int status, int start, int end,
2824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2825                    throws com.liferay.portal.kernel.exception.SystemException {
2826                    return getPersistence()
2827                                       .findByG_C_S(groupId, categoryId, status, start, end,
2828                            orderByComparator);
2829            }
2830    
2831            /**
2832            * Finds the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2833            *
2834            * <p>
2835            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2836            * </p>
2837            *
2838            * @param groupId the group ID to search with
2839            * @param categoryId the category ID to search with
2840            * @param status the status to search with
2841            * @param orderByComparator the comparator to order the set by
2842            * @return the first matching message-boards message
2843            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2844            * @throws SystemException if a system exception occurred
2845            */
2846            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_First(
2847                    long groupId, long categoryId, int status,
2848                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2849                    throws com.liferay.portal.kernel.exception.SystemException,
2850                            com.liferay.portlet.messageboards.NoSuchMessageException {
2851                    return getPersistence()
2852                                       .findByG_C_S_First(groupId, categoryId, status,
2853                            orderByComparator);
2854            }
2855    
2856            /**
2857            * Finds the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2858            *
2859            * <p>
2860            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2861            * </p>
2862            *
2863            * @param groupId the group ID to search with
2864            * @param categoryId the category ID to search with
2865            * @param status the status to search with
2866            * @param orderByComparator the comparator to order the set by
2867            * @return the last matching message-boards message
2868            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
2869            * @throws SystemException if a system exception occurred
2870            */
2871            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_Last(
2872                    long groupId, long categoryId, int status,
2873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2874                    throws com.liferay.portal.kernel.exception.SystemException,
2875                            com.liferay.portlet.messageboards.NoSuchMessageException {
2876                    return getPersistence()
2877                                       .findByG_C_S_Last(groupId, categoryId, status,
2878                            orderByComparator);
2879            }
2880    
2881            /**
2882            * Finds 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;.
2883            *
2884            * <p>
2885            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2886            * </p>
2887            *
2888            * @param messageId the primary key of the current message-boards message
2889            * @param groupId the group ID to search with
2890            * @param categoryId the category ID to search with
2891            * @param status the status to search with
2892            * @param orderByComparator the comparator to order the set by
2893            * @return the previous, current, and next message-boards message
2894            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2895            * @throws SystemException if a system exception occurred
2896            */
2897            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_S_PrevAndNext(
2898                    long messageId, long groupId, long categoryId, int status,
2899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2900                    throws com.liferay.portal.kernel.exception.SystemException,
2901                            com.liferay.portlet.messageboards.NoSuchMessageException {
2902                    return getPersistence()
2903                                       .findByG_C_S_PrevAndNext(messageId, groupId, categoryId,
2904                            status, orderByComparator);
2905            }
2906    
2907            /**
2908            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2909            *
2910            * @param groupId the group ID to search with
2911            * @param categoryId the category ID to search with
2912            * @param status the status to search with
2913            * @return the matching message-boards messages that the user has permission to view
2914            * @throws SystemException if a system exception occurred
2915            */
2916            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
2917                    long groupId, long categoryId, int status)
2918                    throws com.liferay.portal.kernel.exception.SystemException {
2919                    return getPersistence().filterFindByG_C_S(groupId, categoryId, status);
2920            }
2921    
2922            /**
2923            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2924            *
2925            * <p>
2926            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2927            * </p>
2928            *
2929            * @param groupId the group ID to search with
2930            * @param categoryId the category ID to search with
2931            * @param status the status to search with
2932            * @param start the lower bound of the range of message-boards messages to return
2933            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2934            * @return the range of matching message-boards messages that the user has permission to view
2935            * @throws SystemException if a system exception occurred
2936            */
2937            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
2938                    long groupId, long categoryId, int status, int start, int end)
2939                    throws com.liferay.portal.kernel.exception.SystemException {
2940                    return getPersistence()
2941                                       .filterFindByG_C_S(groupId, categoryId, status, start, end);
2942            }
2943    
2944            /**
2945            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
2946            *
2947            * <p>
2948            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2949            * </p>
2950            *
2951            * @param groupId the group ID to search with
2952            * @param categoryId the category ID to search with
2953            * @param status the status to search with
2954            * @param start the lower bound of the range of message-boards messages to return
2955            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
2956            * @param orderByComparator the comparator to order the results by
2957            * @return the ordered range of matching message-boards messages that the user has permission to view
2958            * @throws SystemException if a system exception occurred
2959            */
2960            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S(
2961                    long groupId, long categoryId, int status, int start, int end,
2962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2963                    throws com.liferay.portal.kernel.exception.SystemException {
2964                    return getPersistence()
2965                                       .filterFindByG_C_S(groupId, categoryId, status, start, end,
2966                            orderByComparator);
2967            }
2968    
2969            /**
2970            * Filters 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;.
2971            *
2972            * <p>
2973            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2974            * </p>
2975            *
2976            * @param messageId the primary key of the current message-boards message
2977            * @param groupId the group ID to search with
2978            * @param categoryId the category ID to search with
2979            * @param status the status to search with
2980            * @param orderByComparator the comparator to order the set by
2981            * @return the previous, current, and next message-boards message
2982            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
2983            * @throws SystemException if a system exception occurred
2984            */
2985            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_S_PrevAndNext(
2986                    long messageId, long groupId, long categoryId, int status,
2987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2988                    throws com.liferay.portal.kernel.exception.SystemException,
2989                            com.liferay.portlet.messageboards.NoSuchMessageException {
2990                    return getPersistence()
2991                                       .filterFindByG_C_S_PrevAndNext(messageId, groupId,
2992                            categoryId, status, orderByComparator);
2993            }
2994    
2995            /**
2996            * Finds all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
2997            *
2998            * @param classNameId the class name ID to search with
2999            * @param classPK the class p k to search with
3000            * @param status the status to search with
3001            * @return the matching message-boards messages
3002            * @throws SystemException if a system exception occurred
3003            */
3004            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
3005                    long classNameId, long classPK, int status)
3006                    throws com.liferay.portal.kernel.exception.SystemException {
3007                    return getPersistence().findByC_C_S(classNameId, classPK, status);
3008            }
3009    
3010            /**
3011            * Finds a range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3012            *
3013            * <p>
3014            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3015            * </p>
3016            *
3017            * @param classNameId the class name ID to search with
3018            * @param classPK the class p k to search with
3019            * @param status the status to search with
3020            * @param start the lower bound of the range of message-boards messages to return
3021            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3022            * @return the range of matching message-boards messages
3023            * @throws SystemException if a system exception occurred
3024            */
3025            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
3026                    long classNameId, long classPK, int status, int start, int end)
3027                    throws com.liferay.portal.kernel.exception.SystemException {
3028                    return getPersistence()
3029                                       .findByC_C_S(classNameId, classPK, status, start, end);
3030            }
3031    
3032            /**
3033            * Finds an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3034            *
3035            * <p>
3036            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3037            * </p>
3038            *
3039            * @param classNameId the class name ID to search with
3040            * @param classPK the class p k to search with
3041            * @param status the status to search with
3042            * @param start the lower bound of the range of message-boards messages to return
3043            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3044            * @param orderByComparator the comparator to order the results by
3045            * @return the ordered range of matching message-boards messages
3046            * @throws SystemException if a system exception occurred
3047            */
3048            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S(
3049                    long classNameId, long classPK, int status, int start, int end,
3050                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3051                    throws com.liferay.portal.kernel.exception.SystemException {
3052                    return getPersistence()
3053                                       .findByC_C_S(classNameId, classPK, status, start, end,
3054                            orderByComparator);
3055            }
3056    
3057            /**
3058            * Finds the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
3059            *
3060            * <p>
3061            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3062            * </p>
3063            *
3064            * @param classNameId the class name ID to search with
3065            * @param classPK the class p k to search with
3066            * @param status the status to search with
3067            * @param orderByComparator the comparator to order the set by
3068            * @return the first matching message-boards message
3069            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3070            * @throws SystemException if a system exception occurred
3071            */
3072            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_First(
3073                    long classNameId, long classPK, int status,
3074                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3075                    throws com.liferay.portal.kernel.exception.SystemException,
3076                            com.liferay.portlet.messageboards.NoSuchMessageException {
3077                    return getPersistence()
3078                                       .findByC_C_S_First(classNameId, classPK, status,
3079                            orderByComparator);
3080            }
3081    
3082            /**
3083            * Finds the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
3084            *
3085            * <p>
3086            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3087            * </p>
3088            *
3089            * @param classNameId the class name ID to search with
3090            * @param classPK the class p k to search with
3091            * @param status the status to search with
3092            * @param orderByComparator the comparator to order the set by
3093            * @return the last matching message-boards message
3094            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3095            * @throws SystemException if a system exception occurred
3096            */
3097            public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_Last(
3098                    long classNameId, long classPK, int status,
3099                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3100                    throws com.liferay.portal.kernel.exception.SystemException,
3101                            com.liferay.portlet.messageboards.NoSuchMessageException {
3102                    return getPersistence()
3103                                       .findByC_C_S_Last(classNameId, classPK, status,
3104                            orderByComparator);
3105            }
3106    
3107            /**
3108            * Finds 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;.
3109            *
3110            * <p>
3111            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3112            * </p>
3113            *
3114            * @param messageId the primary key of the current message-boards message
3115            * @param classNameId the class name ID to search with
3116            * @param classPK the class p k to search with
3117            * @param status the status to search with
3118            * @param orderByComparator the comparator to order the set by
3119            * @return the previous, current, and next message-boards message
3120            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3121            * @throws SystemException if a system exception occurred
3122            */
3123            public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_S_PrevAndNext(
3124                    long messageId, long classNameId, long classPK, int status,
3125                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3126                    throws com.liferay.portal.kernel.exception.SystemException,
3127                            com.liferay.portlet.messageboards.NoSuchMessageException {
3128                    return getPersistence()
3129                                       .findByC_C_S_PrevAndNext(messageId, classNameId, classPK,
3130                            status, orderByComparator);
3131            }
3132    
3133            /**
3134            * Finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3135            *
3136            * @param groupId the group ID to search with
3137            * @param categoryId the category ID to search with
3138            * @param threadId the thread ID to search with
3139            * @param status the status to search with
3140            * @return the matching message-boards messages
3141            * @throws SystemException if a system exception occurred
3142            */
3143            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
3144                    long groupId, long categoryId, long threadId, int status)
3145                    throws com.liferay.portal.kernel.exception.SystemException {
3146                    return getPersistence()
3147                                       .findByG_C_T_S(groupId, categoryId, threadId, status);
3148            }
3149    
3150            /**
3151            * Finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3152            *
3153            * <p>
3154            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3155            * </p>
3156            *
3157            * @param groupId the group ID to search with
3158            * @param categoryId the category ID to search with
3159            * @param threadId the thread ID to search with
3160            * @param status the status to search with
3161            * @param start the lower bound of the range of message-boards messages to return
3162            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3163            * @return the range of matching message-boards messages
3164            * @throws SystemException if a system exception occurred
3165            */
3166            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
3167                    long groupId, long categoryId, long threadId, int status, int start,
3168                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3169                    return getPersistence()
3170                                       .findByG_C_T_S(groupId, categoryId, threadId, status, start,
3171                            end);
3172            }
3173    
3174            /**
3175            * Finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3176            *
3177            * <p>
3178            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3179            * </p>
3180            *
3181            * @param groupId the group ID to search with
3182            * @param categoryId the category ID to search with
3183            * @param threadId the thread ID to search with
3184            * @param status the status to search with
3185            * @param start the lower bound of the range of message-boards messages to return
3186            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3187            * @param orderByComparator the comparator to order the results by
3188            * @return the ordered range of matching message-boards messages
3189            * @throws SystemException if a system exception occurred
3190            */
3191            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S(
3192                    long groupId, long categoryId, long threadId, int status, int start,
3193                    int end,
3194                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3195                    throws com.liferay.portal.kernel.exception.SystemException {
3196                    return getPersistence()
3197                                       .findByG_C_T_S(groupId, categoryId, threadId, status, start,
3198                            end, orderByComparator);
3199            }
3200    
3201            /**
3202            * Finds the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3203            *
3204            * <p>
3205            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3206            * </p>
3207            *
3208            * @param groupId the group ID to search with
3209            * @param categoryId the category ID to search with
3210            * @param threadId the thread ID to search with
3211            * @param status the status to search with
3212            * @param orderByComparator the comparator to order the set by
3213            * @return the first matching message-boards message
3214            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3215            * @throws SystemException if a system exception occurred
3216            */
3217            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_First(
3218                    long groupId, long categoryId, long threadId, int status,
3219                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3220                    throws com.liferay.portal.kernel.exception.SystemException,
3221                            com.liferay.portlet.messageboards.NoSuchMessageException {
3222                    return getPersistence()
3223                                       .findByG_C_T_S_First(groupId, categoryId, threadId, status,
3224                            orderByComparator);
3225            }
3226    
3227            /**
3228            * Finds the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3229            *
3230            * <p>
3231            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3232            * </p>
3233            *
3234            * @param groupId the group ID to search with
3235            * @param categoryId the category ID to search with
3236            * @param threadId the thread ID to search with
3237            * @param status the status to search with
3238            * @param orderByComparator the comparator to order the set by
3239            * @return the last matching message-boards message
3240            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found
3241            * @throws SystemException if a system exception occurred
3242            */
3243            public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_Last(
3244                    long groupId, long categoryId, long threadId, int status,
3245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3246                    throws com.liferay.portal.kernel.exception.SystemException,
3247                            com.liferay.portlet.messageboards.NoSuchMessageException {
3248                    return getPersistence()
3249                                       .findByG_C_T_S_Last(groupId, categoryId, threadId, status,
3250                            orderByComparator);
3251            }
3252    
3253            /**
3254            * Finds 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;.
3255            *
3256            * <p>
3257            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3258            * </p>
3259            *
3260            * @param messageId the primary key of the current message-boards message
3261            * @param groupId the group ID to search with
3262            * @param categoryId the category ID to search with
3263            * @param threadId the thread ID to search with
3264            * @param status the status to search with
3265            * @param orderByComparator the comparator to order the set by
3266            * @return the previous, current, and next message-boards message
3267            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3268            * @throws SystemException if a system exception occurred
3269            */
3270            public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_S_PrevAndNext(
3271                    long messageId, long groupId, long categoryId, long threadId,
3272                    int status,
3273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3274                    throws com.liferay.portal.kernel.exception.SystemException,
3275                            com.liferay.portlet.messageboards.NoSuchMessageException {
3276                    return getPersistence()
3277                                       .findByG_C_T_S_PrevAndNext(messageId, groupId, categoryId,
3278                            threadId, status, orderByComparator);
3279            }
3280    
3281            /**
3282            * Filters by the user's permissions and finds all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3283            *
3284            * @param groupId the group ID to search with
3285            * @param categoryId the category ID to search with
3286            * @param threadId the thread ID to search with
3287            * @param status the status to search with
3288            * @return the matching message-boards messages that the user has permission to view
3289            * @throws SystemException if a system exception occurred
3290            */
3291            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
3292                    long groupId, long categoryId, long threadId, int status)
3293                    throws com.liferay.portal.kernel.exception.SystemException {
3294                    return getPersistence()
3295                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status);
3296            }
3297    
3298            /**
3299            * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3300            *
3301            * <p>
3302            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3303            * </p>
3304            *
3305            * @param groupId the group ID to search with
3306            * @param categoryId the category ID to search with
3307            * @param threadId the thread ID to search with
3308            * @param status the status to search with
3309            * @param start the lower bound of the range of message-boards messages to return
3310            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3311            * @return the range of matching message-boards messages that the user has permission to view
3312            * @throws SystemException if a system exception occurred
3313            */
3314            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
3315                    long groupId, long categoryId, long threadId, int status, int start,
3316                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3317                    return getPersistence()
3318                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status,
3319                            start, end);
3320            }
3321    
3322            /**
3323            * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
3324            *
3325            * <p>
3326            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3327            * </p>
3328            *
3329            * @param groupId the group ID to search with
3330            * @param categoryId the category ID to search with
3331            * @param threadId the thread ID to search with
3332            * @param status the status to search with
3333            * @param start the lower bound of the range of message-boards messages to return
3334            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3335            * @param orderByComparator the comparator to order the results by
3336            * @return the ordered range of matching message-boards messages that the user has permission to view
3337            * @throws SystemException if a system exception occurred
3338            */
3339            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S(
3340                    long groupId, long categoryId, long threadId, int status, int start,
3341                    int end,
3342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3343                    throws com.liferay.portal.kernel.exception.SystemException {
3344                    return getPersistence()
3345                                       .filterFindByG_C_T_S(groupId, categoryId, threadId, status,
3346                            start, end, orderByComparator);
3347            }
3348    
3349            /**
3350            * Filters 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;.
3351            *
3352            * <p>
3353            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3354            * </p>
3355            *
3356            * @param messageId the primary key of the current message-boards message
3357            * @param groupId the group ID to search with
3358            * @param categoryId the category ID to search with
3359            * @param threadId the thread ID to search with
3360            * @param status the status to search with
3361            * @param orderByComparator the comparator to order the set by
3362            * @return the previous, current, and next message-boards message
3363            * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found
3364            * @throws SystemException if a system exception occurred
3365            */
3366            public static com.liferay.portlet.messageboards.model.MBMessage[] filterFindByG_C_T_S_PrevAndNext(
3367                    long messageId, long groupId, long categoryId, long threadId,
3368                    int status,
3369                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3370                    throws com.liferay.portal.kernel.exception.SystemException,
3371                            com.liferay.portlet.messageboards.NoSuchMessageException {
3372                    return getPersistence()
3373                                       .filterFindByG_C_T_S_PrevAndNext(messageId, groupId,
3374                            categoryId, threadId, status, orderByComparator);
3375            }
3376    
3377            /**
3378            * Finds all the message-boards messages.
3379            *
3380            * @return the message-boards messages
3381            * @throws SystemException if a system exception occurred
3382            */
3383            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll()
3384                    throws com.liferay.portal.kernel.exception.SystemException {
3385                    return getPersistence().findAll();
3386            }
3387    
3388            /**
3389            * Finds a range of all the message-boards messages.
3390            *
3391            * <p>
3392            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3393            * </p>
3394            *
3395            * @param start the lower bound of the range of message-boards messages to return
3396            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3397            * @return the range of message-boards messages
3398            * @throws SystemException if a system exception occurred
3399            */
3400            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll(
3401                    int start, int end)
3402                    throws com.liferay.portal.kernel.exception.SystemException {
3403                    return getPersistence().findAll(start, end);
3404            }
3405    
3406            /**
3407            * Finds an ordered range of all the message-boards messages.
3408            *
3409            * <p>
3410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3411            * </p>
3412            *
3413            * @param start the lower bound of the range of message-boards messages to return
3414            * @param end the upper bound of the range of message-boards messages to return (not inclusive)
3415            * @param orderByComparator the comparator to order the results by
3416            * @return the ordered range of message-boards messages
3417            * @throws SystemException if a system exception occurred
3418            */
3419            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll(
3420                    int start, int end,
3421                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3422                    throws com.liferay.portal.kernel.exception.SystemException {
3423                    return getPersistence().findAll(start, end, orderByComparator);
3424            }
3425    
3426            /**
3427            * Removes all the message-boards messages where uuid = &#63; from the database.
3428            *
3429            * @param uuid the uuid to search with
3430            * @throws SystemException if a system exception occurred
3431            */
3432            public static void removeByUuid(java.lang.String uuid)
3433                    throws com.liferay.portal.kernel.exception.SystemException {
3434                    getPersistence().removeByUuid(uuid);
3435            }
3436    
3437            /**
3438            * Removes the message-boards message where uuid = &#63; and groupId = &#63; from the database.
3439            *
3440            * @param uuid the uuid to search with
3441            * @param groupId the group ID to search with
3442            * @throws SystemException if a system exception occurred
3443            */
3444            public static void removeByUUID_G(java.lang.String uuid, long groupId)
3445                    throws com.liferay.portal.kernel.exception.SystemException,
3446                            com.liferay.portlet.messageboards.NoSuchMessageException {
3447                    getPersistence().removeByUUID_G(uuid, groupId);
3448            }
3449    
3450            /**
3451            * Removes all the message-boards messages where groupId = &#63; from the database.
3452            *
3453            * @param groupId the group ID to search with
3454            * @throws SystemException if a system exception occurred
3455            */
3456            public static void removeByGroupId(long groupId)
3457                    throws com.liferay.portal.kernel.exception.SystemException {
3458                    getPersistence().removeByGroupId(groupId);
3459            }
3460    
3461            /**
3462            * Removes all the message-boards messages where companyId = &#63; from the database.
3463            *
3464            * @param companyId the company ID to search with
3465            * @throws SystemException if a system exception occurred
3466            */
3467            public static void removeByCompanyId(long companyId)
3468                    throws com.liferay.portal.kernel.exception.SystemException {
3469                    getPersistence().removeByCompanyId(companyId);
3470            }
3471    
3472            /**
3473            * Removes all the message-boards messages where threadId = &#63; from the database.
3474            *
3475            * @param threadId the thread ID to search with
3476            * @throws SystemException if a system exception occurred
3477            */
3478            public static void removeByThreadId(long threadId)
3479                    throws com.liferay.portal.kernel.exception.SystemException {
3480                    getPersistence().removeByThreadId(threadId);
3481            }
3482    
3483            /**
3484            * Removes all the message-boards messages where threadId = &#63; from the database.
3485            *
3486            * @param threadId the thread ID to search with
3487            * @throws SystemException if a system exception occurred
3488            */
3489            public static void removeByThreadReplies(long threadId)
3490                    throws com.liferay.portal.kernel.exception.SystemException {
3491                    getPersistence().removeByThreadReplies(threadId);
3492            }
3493    
3494            /**
3495            * Removes all the message-boards messages where userId = &#63; from the database.
3496            *
3497            * @param userId the user ID to search with
3498            * @throws SystemException if a system exception occurred
3499            */
3500            public static void removeByUserId(long userId)
3501                    throws com.liferay.portal.kernel.exception.SystemException {
3502                    getPersistence().removeByUserId(userId);
3503            }
3504    
3505            /**
3506            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; from the database.
3507            *
3508            * @param groupId the group ID to search with
3509            * @param userId the user ID to search with
3510            * @throws SystemException if a system exception occurred
3511            */
3512            public static void removeByG_U(long groupId, long userId)
3513                    throws com.liferay.portal.kernel.exception.SystemException {
3514                    getPersistence().removeByG_U(groupId, userId);
3515            }
3516    
3517            /**
3518            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; from the database.
3519            *
3520            * @param groupId the group ID to search with
3521            * @param categoryId the category ID to search with
3522            * @throws SystemException if a system exception occurred
3523            */
3524            public static void removeByG_C(long groupId, long categoryId)
3525                    throws com.liferay.portal.kernel.exception.SystemException {
3526                    getPersistence().removeByG_C(groupId, categoryId);
3527            }
3528    
3529            /**
3530            * Removes all the message-boards messages where groupId = &#63; and status = &#63; from the database.
3531            *
3532            * @param groupId the group ID to search with
3533            * @param status the status to search with
3534            * @throws SystemException if a system exception occurred
3535            */
3536            public static void removeByG_S(long groupId, int status)
3537                    throws com.liferay.portal.kernel.exception.SystemException {
3538                    getPersistence().removeByG_S(groupId, status);
3539            }
3540    
3541            /**
3542            * Removes all the message-boards messages where companyId = &#63; and status = &#63; from the database.
3543            *
3544            * @param companyId the company ID to search with
3545            * @param status the status to search with
3546            * @throws SystemException if a system exception occurred
3547            */
3548            public static void removeByC_S(long companyId, int status)
3549                    throws com.liferay.portal.kernel.exception.SystemException {
3550                    getPersistence().removeByC_S(companyId, status);
3551            }
3552    
3553            /**
3554            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; from the database.
3555            *
3556            * @param classNameId the class name ID to search with
3557            * @param classPK the class p k to search with
3558            * @throws SystemException if a system exception occurred
3559            */
3560            public static void removeByC_C(long classNameId, long classPK)
3561                    throws com.liferay.portal.kernel.exception.SystemException {
3562                    getPersistence().removeByC_C(classNameId, classPK);
3563            }
3564    
3565            /**
3566            * Removes all the message-boards messages where threadId = &#63; and parentMessageId = &#63; from the database.
3567            *
3568            * @param threadId the thread ID to search with
3569            * @param parentMessageId the parent message ID to search with
3570            * @throws SystemException if a system exception occurred
3571            */
3572            public static void removeByT_P(long threadId, long parentMessageId)
3573                    throws com.liferay.portal.kernel.exception.SystemException {
3574                    getPersistence().removeByT_P(threadId, parentMessageId);
3575            }
3576    
3577            /**
3578            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
3579            *
3580            * @param threadId the thread ID to search with
3581            * @param status the status to search with
3582            * @throws SystemException if a system exception occurred
3583            */
3584            public static void removeByT_S(long threadId, int status)
3585                    throws com.liferay.portal.kernel.exception.SystemException {
3586                    getPersistence().removeByT_S(threadId, status);
3587            }
3588    
3589            /**
3590            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
3591            *
3592            * @param threadId the thread ID to search with
3593            * @param status the status to search with
3594            * @throws SystemException if a system exception occurred
3595            */
3596            public static void removeByTR_S(long threadId, int status)
3597                    throws com.liferay.portal.kernel.exception.SystemException {
3598                    getPersistence().removeByTR_S(threadId, status);
3599            }
3600    
3601            /**
3602            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63; from the database.
3603            *
3604            * @param groupId the group ID to search with
3605            * @param userId the user ID to search with
3606            * @param status the status to search with
3607            * @throws SystemException if a system exception occurred
3608            */
3609            public static void removeByG_U_S(long groupId, long userId, int status)
3610                    throws com.liferay.portal.kernel.exception.SystemException {
3611                    getPersistence().removeByG_U_S(groupId, userId, status);
3612            }
3613    
3614            /**
3615            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; from the database.
3616            *
3617            * @param groupId the group ID to search with
3618            * @param categoryId the category ID to search with
3619            * @param threadId the thread ID to search with
3620            * @throws SystemException if a system exception occurred
3621            */
3622            public static void removeByG_C_T(long groupId, long categoryId,
3623                    long threadId)
3624                    throws com.liferay.portal.kernel.exception.SystemException {
3625                    getPersistence().removeByG_C_T(groupId, categoryId, threadId);
3626            }
3627    
3628            /**
3629            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
3630            *
3631            * @param groupId the group ID to search with
3632            * @param categoryId the category ID to search with
3633            * @param status the status to search with
3634            * @throws SystemException if a system exception occurred
3635            */
3636            public static void removeByG_C_S(long groupId, long categoryId, int status)
3637                    throws com.liferay.portal.kernel.exception.SystemException {
3638                    getPersistence().removeByG_C_S(groupId, categoryId, status);
3639            }
3640    
3641            /**
3642            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63; from the database.
3643            *
3644            * @param classNameId the class name ID to search with
3645            * @param classPK the class p k to search with
3646            * @param status the status to search with
3647            * @throws SystemException if a system exception occurred
3648            */
3649            public static void removeByC_C_S(long classNameId, long classPK, int status)
3650                    throws com.liferay.portal.kernel.exception.SystemException {
3651                    getPersistence().removeByC_C_S(classNameId, classPK, status);
3652            }
3653    
3654            /**
3655            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63; from the database.
3656            *
3657            * @param groupId the group ID to search with
3658            * @param categoryId the category ID to search with
3659            * @param threadId the thread ID to search with
3660            * @param status the status to search with
3661            * @throws SystemException if a system exception occurred
3662            */
3663            public static void removeByG_C_T_S(long groupId, long categoryId,
3664                    long threadId, int status)
3665                    throws com.liferay.portal.kernel.exception.SystemException {
3666                    getPersistence().removeByG_C_T_S(groupId, categoryId, threadId, status);
3667            }
3668    
3669            /**
3670            * Removes all the message-boards messages from the database.
3671            *
3672            * @throws SystemException if a system exception occurred
3673            */
3674            public static void removeAll()
3675                    throws com.liferay.portal.kernel.exception.SystemException {
3676                    getPersistence().removeAll();
3677            }
3678    
3679            /**
3680            * Counts all the message-boards messages where uuid = &#63;.
3681            *
3682            * @param uuid the uuid to search with
3683            * @return the number of matching message-boards messages
3684            * @throws SystemException if a system exception occurred
3685            */
3686            public static int countByUuid(java.lang.String uuid)
3687                    throws com.liferay.portal.kernel.exception.SystemException {
3688                    return getPersistence().countByUuid(uuid);
3689            }
3690    
3691            /**
3692            * Counts all the message-boards messages where uuid = &#63; and groupId = &#63;.
3693            *
3694            * @param uuid the uuid to search with
3695            * @param groupId the group ID to search with
3696            * @return the number of matching message-boards messages
3697            * @throws SystemException if a system exception occurred
3698            */
3699            public static int countByUUID_G(java.lang.String uuid, long groupId)
3700                    throws com.liferay.portal.kernel.exception.SystemException {
3701                    return getPersistence().countByUUID_G(uuid, groupId);
3702            }
3703    
3704            /**
3705            * Counts all the message-boards messages where groupId = &#63;.
3706            *
3707            * @param groupId the group ID to search with
3708            * @return the number of matching message-boards messages
3709            * @throws SystemException if a system exception occurred
3710            */
3711            public static int countByGroupId(long groupId)
3712                    throws com.liferay.portal.kernel.exception.SystemException {
3713                    return getPersistence().countByGroupId(groupId);
3714            }
3715    
3716            /**
3717            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63;.
3718            *
3719            * @param groupId the group ID to search with
3720            * @return the number of matching message-boards messages that the user has permission to view
3721            * @throws SystemException if a system exception occurred
3722            */
3723            public static int filterCountByGroupId(long groupId)
3724                    throws com.liferay.portal.kernel.exception.SystemException {
3725                    return getPersistence().filterCountByGroupId(groupId);
3726            }
3727    
3728            /**
3729            * Counts all the message-boards messages where companyId = &#63;.
3730            *
3731            * @param companyId the company ID to search with
3732            * @return the number of matching message-boards messages
3733            * @throws SystemException if a system exception occurred
3734            */
3735            public static int countByCompanyId(long companyId)
3736                    throws com.liferay.portal.kernel.exception.SystemException {
3737                    return getPersistence().countByCompanyId(companyId);
3738            }
3739    
3740            /**
3741            * Counts all the message-boards messages where threadId = &#63;.
3742            *
3743            * @param threadId the thread ID to search with
3744            * @return the number of matching message-boards messages
3745            * @throws SystemException if a system exception occurred
3746            */
3747            public static int countByThreadId(long threadId)
3748                    throws com.liferay.portal.kernel.exception.SystemException {
3749                    return getPersistence().countByThreadId(threadId);
3750            }
3751    
3752            /**
3753            * Counts all the message-boards messages where threadId = &#63;.
3754            *
3755            * @param threadId the thread ID to search with
3756            * @return the number of matching message-boards messages
3757            * @throws SystemException if a system exception occurred
3758            */
3759            public static int countByThreadReplies(long threadId)
3760                    throws com.liferay.portal.kernel.exception.SystemException {
3761                    return getPersistence().countByThreadReplies(threadId);
3762            }
3763    
3764            /**
3765            * Counts all the message-boards messages where userId = &#63;.
3766            *
3767            * @param userId the user ID to search with
3768            * @return the number of matching message-boards messages
3769            * @throws SystemException if a system exception occurred
3770            */
3771            public static int countByUserId(long userId)
3772                    throws com.liferay.portal.kernel.exception.SystemException {
3773                    return getPersistence().countByUserId(userId);
3774            }
3775    
3776            /**
3777            * Counts all the message-boards messages where groupId = &#63; and userId = &#63;.
3778            *
3779            * @param groupId the group ID to search with
3780            * @param userId the user ID to search with
3781            * @return the number of matching message-boards messages
3782            * @throws SystemException if a system exception occurred
3783            */
3784            public static int countByG_U(long groupId, long userId)
3785                    throws com.liferay.portal.kernel.exception.SystemException {
3786                    return getPersistence().countByG_U(groupId, userId);
3787            }
3788    
3789            /**
3790            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and userId = &#63;.
3791            *
3792            * @param groupId the group ID to search with
3793            * @param userId the user ID to search with
3794            * @return the number of matching message-boards messages that the user has permission to view
3795            * @throws SystemException if a system exception occurred
3796            */
3797            public static int filterCountByG_U(long groupId, long userId)
3798                    throws com.liferay.portal.kernel.exception.SystemException {
3799                    return getPersistence().filterCountByG_U(groupId, userId);
3800            }
3801    
3802            /**
3803            * Counts all the message-boards messages where groupId = &#63; and categoryId = &#63;.
3804            *
3805            * @param groupId the group ID to search with
3806            * @param categoryId the category ID to search with
3807            * @return the number of matching message-boards messages
3808            * @throws SystemException if a system exception occurred
3809            */
3810            public static int countByG_C(long groupId, long categoryId)
3811                    throws com.liferay.portal.kernel.exception.SystemException {
3812                    return getPersistence().countByG_C(groupId, categoryId);
3813            }
3814    
3815            /**
3816            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and categoryId = &#63;.
3817            *
3818            * @param groupId the group ID to search with
3819            * @param categoryId the category ID to search with
3820            * @return the number of matching message-boards messages that the user has permission to view
3821            * @throws SystemException if a system exception occurred
3822            */
3823            public static int filterCountByG_C(long groupId, long categoryId)
3824                    throws com.liferay.portal.kernel.exception.SystemException {
3825                    return getPersistence().filterCountByG_C(groupId, categoryId);
3826            }
3827    
3828            /**
3829            * Counts all the message-boards messages where groupId = &#63; and status = &#63;.
3830            *
3831            * @param groupId the group ID to search with
3832            * @param status the status to search with
3833            * @return the number of matching message-boards messages
3834            * @throws SystemException if a system exception occurred
3835            */
3836            public static int countByG_S(long groupId, int status)
3837                    throws com.liferay.portal.kernel.exception.SystemException {
3838                    return getPersistence().countByG_S(groupId, status);
3839            }
3840    
3841            /**
3842            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and status = &#63;.
3843            *
3844            * @param groupId the group ID to search with
3845            * @param status the status to search with
3846            * @return the number of matching message-boards messages that the user has permission to view
3847            * @throws SystemException if a system exception occurred
3848            */
3849            public static int filterCountByG_S(long groupId, int status)
3850                    throws com.liferay.portal.kernel.exception.SystemException {
3851                    return getPersistence().filterCountByG_S(groupId, status);
3852            }
3853    
3854            /**
3855            * Counts all the message-boards messages where companyId = &#63; and status = &#63;.
3856            *
3857            * @param companyId the company ID to search with
3858            * @param status the status to search with
3859            * @return the number of matching message-boards messages
3860            * @throws SystemException if a system exception occurred
3861            */
3862            public static int countByC_S(long companyId, int status)
3863                    throws com.liferay.portal.kernel.exception.SystemException {
3864                    return getPersistence().countByC_S(companyId, status);
3865            }
3866    
3867            /**
3868            * Counts all the message-boards messages where classNameId = &#63; and classPK = &#63;.
3869            *
3870            * @param classNameId the class name ID to search with
3871            * @param classPK the class p k to search with
3872            * @return the number of matching message-boards messages
3873            * @throws SystemException if a system exception occurred
3874            */
3875            public static int countByC_C(long classNameId, long classPK)
3876                    throws com.liferay.portal.kernel.exception.SystemException {
3877                    return getPersistence().countByC_C(classNameId, classPK);
3878            }
3879    
3880            /**
3881            * Counts all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
3882            *
3883            * @param threadId the thread ID to search with
3884            * @param parentMessageId the parent message ID to search with
3885            * @return the number of matching message-boards messages
3886            * @throws SystemException if a system exception occurred
3887            */
3888            public static int countByT_P(long threadId, long parentMessageId)
3889                    throws com.liferay.portal.kernel.exception.SystemException {
3890                    return getPersistence().countByT_P(threadId, parentMessageId);
3891            }
3892    
3893            /**
3894            * Counts all the message-boards messages where threadId = &#63; and status = &#63;.
3895            *
3896            * @param threadId the thread ID to search with
3897            * @param status the status to search with
3898            * @return the number of matching message-boards messages
3899            * @throws SystemException if a system exception occurred
3900            */
3901            public static int countByT_S(long threadId, int status)
3902                    throws com.liferay.portal.kernel.exception.SystemException {
3903                    return getPersistence().countByT_S(threadId, status);
3904            }
3905    
3906            /**
3907            * Counts all the message-boards messages where threadId = &#63; and status = &#63;.
3908            *
3909            * @param threadId the thread ID to search with
3910            * @param status the status to search with
3911            * @return the number of matching message-boards messages
3912            * @throws SystemException if a system exception occurred
3913            */
3914            public static int countByTR_S(long threadId, int status)
3915                    throws com.liferay.portal.kernel.exception.SystemException {
3916                    return getPersistence().countByTR_S(threadId, status);
3917            }
3918    
3919            /**
3920            * Counts all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3921            *
3922            * @param groupId the group ID to search with
3923            * @param userId the user ID to search with
3924            * @param status the status to search with
3925            * @return the number of matching message-boards messages
3926            * @throws SystemException if a system exception occurred
3927            */
3928            public static int countByG_U_S(long groupId, long userId, int status)
3929                    throws com.liferay.portal.kernel.exception.SystemException {
3930                    return getPersistence().countByG_U_S(groupId, userId, status);
3931            }
3932    
3933            /**
3934            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3935            *
3936            * @param groupId the group ID to search with
3937            * @param userId the user ID to search with
3938            * @param status the status to search with
3939            * @return the number of matching message-boards messages that the user has permission to view
3940            * @throws SystemException if a system exception occurred
3941            */
3942            public static int filterCountByG_U_S(long groupId, long userId, int status)
3943                    throws com.liferay.portal.kernel.exception.SystemException {
3944                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
3945            }
3946    
3947            /**
3948            * Counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3949            *
3950            * @param groupId the group ID to search with
3951            * @param categoryId the category ID to search with
3952            * @param threadId the thread ID to search with
3953            * @return the number of matching message-boards messages
3954            * @throws SystemException if a system exception occurred
3955            */
3956            public static int countByG_C_T(long groupId, long categoryId, long threadId)
3957                    throws com.liferay.portal.kernel.exception.SystemException {
3958                    return getPersistence().countByG_C_T(groupId, categoryId, threadId);
3959            }
3960    
3961            /**
3962            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3963            *
3964            * @param groupId the group ID to search with
3965            * @param categoryId the category ID to search with
3966            * @param threadId the thread ID to search with
3967            * @return the number of matching message-boards messages that the user has permission to view
3968            * @throws SystemException if a system exception occurred
3969            */
3970            public static int filterCountByG_C_T(long groupId, long categoryId,
3971                    long threadId)
3972                    throws com.liferay.portal.kernel.exception.SystemException {
3973                    return getPersistence().filterCountByG_C_T(groupId, categoryId, threadId);
3974            }
3975    
3976            /**
3977            * Counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3978            *
3979            * @param groupId the group ID to search with
3980            * @param categoryId the category ID to search with
3981            * @param status the status to search with
3982            * @return the number of matching message-boards messages
3983            * @throws SystemException if a system exception occurred
3984            */
3985            public static int countByG_C_S(long groupId, long categoryId, int status)
3986                    throws com.liferay.portal.kernel.exception.SystemException {
3987                    return getPersistence().countByG_C_S(groupId, categoryId, status);
3988            }
3989    
3990            /**
3991            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3992            *
3993            * @param groupId the group ID to search with
3994            * @param categoryId the category ID to search with
3995            * @param status the status to search with
3996            * @return the number of matching message-boards messages that the user has permission to view
3997            * @throws SystemException if a system exception occurred
3998            */
3999            public static int filterCountByG_C_S(long groupId, long categoryId,
4000                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4001                    return getPersistence().filterCountByG_C_S(groupId, categoryId, status);
4002            }
4003    
4004            /**
4005            * Counts all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
4006            *
4007            * @param classNameId the class name ID to search with
4008            * @param classPK the class p k to search with
4009            * @param status the status to search with
4010            * @return the number of matching message-boards messages
4011            * @throws SystemException if a system exception occurred
4012            */
4013            public static int countByC_C_S(long classNameId, long classPK, int status)
4014                    throws com.liferay.portal.kernel.exception.SystemException {
4015                    return getPersistence().countByC_C_S(classNameId, classPK, status);
4016            }
4017    
4018            /**
4019            * Counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4020            *
4021            * @param groupId the group ID to search with
4022            * @param categoryId the category ID to search with
4023            * @param threadId the thread ID to search with
4024            * @param status the status to search with
4025            * @return the number of matching message-boards messages
4026            * @throws SystemException if a system exception occurred
4027            */
4028            public static int countByG_C_T_S(long groupId, long categoryId,
4029                    long threadId, int status)
4030                    throws com.liferay.portal.kernel.exception.SystemException {
4031                    return getPersistence()
4032                                       .countByG_C_T_S(groupId, categoryId, threadId, status);
4033            }
4034    
4035            /**
4036            * Filters by the user's permissions and counts all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4037            *
4038            * @param groupId the group ID to search with
4039            * @param categoryId the category ID to search with
4040            * @param threadId the thread ID to search with
4041            * @param status the status to search with
4042            * @return the number of matching message-boards messages that the user has permission to view
4043            * @throws SystemException if a system exception occurred
4044            */
4045            public static int filterCountByG_C_T_S(long groupId, long categoryId,
4046                    long threadId, int status)
4047                    throws com.liferay.portal.kernel.exception.SystemException {
4048                    return getPersistence()
4049                                       .filterCountByG_C_T_S(groupId, categoryId, threadId, status);
4050            }
4051    
4052            /**
4053            * Counts all the message-boards messages.
4054            *
4055            * @return the number of message-boards messages
4056            * @throws SystemException if a system exception occurred
4057            */
4058            public static int countAll()
4059                    throws com.liferay.portal.kernel.exception.SystemException {
4060                    return getPersistence().countAll();
4061            }
4062    
4063            public static MBMessagePersistence getPersistence() {
4064                    if (_persistence == null) {
4065                            _persistence = (MBMessagePersistence)PortalBeanLocatorUtil.locate(MBMessagePersistence.class.getName());
4066    
4067                            ReferenceRegistry.registerReference(MBMessageUtil.class,
4068                                    "_persistence");
4069                    }
4070    
4071                    return _persistence;
4072            }
4073    
4074            public void setPersistence(MBMessagePersistence persistence) {
4075                    _persistence = persistence;
4076    
4077                    ReferenceRegistry.registerReference(MBMessageUtil.class, "_persistence");
4078            }
4079    
4080            private static MBMessagePersistence _persistence;
4081    }