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