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