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.MBMailingList;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the message boards mailing list service. This utility wraps {@link com.liferay.portlet.messageboards.service.persistence.impl.MBMailingListPersistenceImpl} 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 MBMailingListPersistence
038     * @see com.liferay.portlet.messageboards.service.persistence.impl.MBMailingListPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class MBMailingListUtil {
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(MBMailingList mbMailingList) {
060                    getPersistence().clearCache(mbMailingList);
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<MBMailingList> 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<MBMailingList> 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<MBMailingList> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<MBMailingList> 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 MBMailingList update(MBMailingList mbMailingList) {
101                    return getPersistence().update(mbMailingList);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static MBMailingList update(MBMailingList mbMailingList,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(mbMailingList, serviceContext);
110            }
111    
112            /**
113            * Returns all the message boards mailing lists where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching message boards mailing lists
117            */
118            public static List<MBMailingList> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the message boards mailing lists 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 mailing lists
131            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
132            * @return the range of matching message boards mailing lists
133            */
134            public static List<MBMailingList> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the message boards mailing lists 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 mailing lists
148            * @param end the upper bound of the range of message boards mailing lists (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 mailing lists
151            */
152            public static List<MBMailingList> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<MBMailingList> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the message boards mailing lists 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 mailing lists
166            * @param end the upper bound of the range of message boards mailing lists (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 mailing lists
170            */
171            public static List<MBMailingList> findByUuid(java.lang.String uuid,
172                    int start, int end, OrderByComparator<MBMailingList> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first message boards mailing list 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 mailing list
185            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
186            */
187            public static MBMailingList findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<MBMailingList> orderByComparator)
189                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first message boards mailing list 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 mailing list, or <code>null</code> if a matching message boards mailing list could not be found
199            */
200            public static MBMailingList fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<MBMailingList> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last message boards mailing list 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 mailing list
211            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
212            */
213            public static MBMailingList findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<MBMailingList> orderByComparator)
215                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last message boards mailing list 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 mailing list, or <code>null</code> if a matching message boards mailing list could not be found
225            */
226            public static MBMailingList fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<MBMailingList> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the message boards mailing lists before and after the current message boards mailing list in the ordered set where uuid = &#63;.
233            *
234            * @param mailingListId the primary key of the current message boards mailing list
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 mailing list
238            * @throws NoSuchMailingListException if a message boards mailing list with the primary key could not be found
239            */
240            public static MBMailingList[] findByUuid_PrevAndNext(long mailingListId,
241                    java.lang.String uuid,
242                    OrderByComparator<MBMailingList> orderByComparator)
243                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(mailingListId, uuid,
246                            orderByComparator);
247            }
248    
249            /**
250            * Removes all the message boards mailing lists where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            */
254            public static void removeByUuid(java.lang.String uuid) {
255                    getPersistence().removeByUuid(uuid);
256            }
257    
258            /**
259            * Returns the number of message boards mailing lists where uuid = &#63;.
260            *
261            * @param uuid the uuid
262            * @return the number of matching message boards mailing lists
263            */
264            public static int countByUuid(java.lang.String uuid) {
265                    return getPersistence().countByUuid(uuid);
266            }
267    
268            /**
269            * Returns the message boards mailing list where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchMailingListException} if it could not be found.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @return the matching message boards mailing list
274            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
275            */
276            public static MBMailingList findByUUID_G(java.lang.String uuid, long groupId)
277                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
278                    return getPersistence().findByUUID_G(uuid, groupId);
279            }
280    
281            /**
282            * Returns the message boards mailing list where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
287            */
288            public static MBMailingList fetchByUUID_G(java.lang.String uuid,
289                    long groupId) {
290                    return getPersistence().fetchByUUID_G(uuid, groupId);
291            }
292    
293            /**
294            * Returns the message boards mailing list where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
295            *
296            * @param uuid the uuid
297            * @param groupId the group ID
298            * @param retrieveFromCache whether to retrieve from the finder cache
299            * @return the matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
300            */
301            public static MBMailingList fetchByUUID_G(java.lang.String uuid,
302                    long groupId, boolean retrieveFromCache) {
303                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
304            }
305    
306            /**
307            * Removes the message boards mailing list where uuid = &#63; and groupId = &#63; from the database.
308            *
309            * @param uuid the uuid
310            * @param groupId the group ID
311            * @return the message boards mailing list that was removed
312            */
313            public static MBMailingList removeByUUID_G(java.lang.String uuid,
314                    long groupId)
315                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
316                    return getPersistence().removeByUUID_G(uuid, groupId);
317            }
318    
319            /**
320            * Returns the number of message boards mailing lists where uuid = &#63; and groupId = &#63;.
321            *
322            * @param uuid the uuid
323            * @param groupId the group ID
324            * @return the number of matching message boards mailing lists
325            */
326            public static int countByUUID_G(java.lang.String uuid, long groupId) {
327                    return getPersistence().countByUUID_G(uuid, groupId);
328            }
329    
330            /**
331            * Returns all the message boards mailing lists where uuid = &#63; and companyId = &#63;.
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @return the matching message boards mailing lists
336            */
337            public static List<MBMailingList> findByUuid_C(java.lang.String uuid,
338                    long companyId) {
339                    return getPersistence().findByUuid_C(uuid, companyId);
340            }
341    
342            /**
343            * Returns a range of all the message boards mailing lists where uuid = &#63; and companyId = &#63;.
344            *
345            * <p>
346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
347            * </p>
348            *
349            * @param uuid the uuid
350            * @param companyId the company ID
351            * @param start the lower bound of the range of message boards mailing lists
352            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
353            * @return the range of matching message boards mailing lists
354            */
355            public static List<MBMailingList> findByUuid_C(java.lang.String uuid,
356                    long companyId, int start, int end) {
357                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
358            }
359    
360            /**
361            * Returns an ordered range of all the message boards mailing lists where uuid = &#63; and companyId = &#63;.
362            *
363            * <p>
364            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
365            * </p>
366            *
367            * @param uuid the uuid
368            * @param companyId the company ID
369            * @param start the lower bound of the range of message boards mailing lists
370            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
372            * @return the ordered range of matching message boards mailing lists
373            */
374            public static List<MBMailingList> findByUuid_C(java.lang.String uuid,
375                    long companyId, int start, int end,
376                    OrderByComparator<MBMailingList> orderByComparator) {
377                    return getPersistence()
378                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
379            }
380    
381            /**
382            * Returns an ordered range of all the message boards mailing lists where uuid = &#63; and companyId = &#63;.
383            *
384            * <p>
385            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
386            * </p>
387            *
388            * @param uuid the uuid
389            * @param companyId the company ID
390            * @param start the lower bound of the range of message boards mailing lists
391            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
392            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
393            * @param retrieveFromCache whether to retrieve from the finder cache
394            * @return the ordered range of matching message boards mailing lists
395            */
396            public static List<MBMailingList> findByUuid_C(java.lang.String uuid,
397                    long companyId, int start, int end,
398                    OrderByComparator<MBMailingList> orderByComparator,
399                    boolean retrieveFromCache) {
400                    return getPersistence()
401                                       .findByUuid_C(uuid, companyId, start, end,
402                            orderByComparator, retrieveFromCache);
403            }
404    
405            /**
406            * Returns the first message boards mailing list in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the first matching message boards mailing list
412            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
413            */
414            public static MBMailingList findByUuid_C_First(java.lang.String uuid,
415                    long companyId, OrderByComparator<MBMailingList> orderByComparator)
416                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first message boards mailing list in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
428            */
429            public static MBMailingList fetchByUuid_C_First(java.lang.String uuid,
430                    long companyId, OrderByComparator<MBMailingList> orderByComparator) {
431                    return getPersistence()
432                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
433            }
434    
435            /**
436            * Returns the last message boards mailing list in the ordered set where uuid = &#63; and companyId = &#63;.
437            *
438            * @param uuid the uuid
439            * @param companyId the company ID
440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
441            * @return the last matching message boards mailing list
442            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
443            */
444            public static MBMailingList findByUuid_C_Last(java.lang.String uuid,
445                    long companyId, OrderByComparator<MBMailingList> orderByComparator)
446                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
447                    return getPersistence()
448                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
449            }
450    
451            /**
452            * Returns the last message boards mailing list in the ordered set where uuid = &#63; and companyId = &#63;.
453            *
454            * @param uuid the uuid
455            * @param companyId the company ID
456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
457            * @return the last matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
458            */
459            public static MBMailingList fetchByUuid_C_Last(java.lang.String uuid,
460                    long companyId, OrderByComparator<MBMailingList> orderByComparator) {
461                    return getPersistence()
462                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
463            }
464    
465            /**
466            * Returns the message boards mailing lists before and after the current message boards mailing list in the ordered set where uuid = &#63; and companyId = &#63;.
467            *
468            * @param mailingListId the primary key of the current message boards mailing list
469            * @param uuid the uuid
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the previous, current, and next message boards mailing list
473            * @throws NoSuchMailingListException if a message boards mailing list with the primary key could not be found
474            */
475            public static MBMailingList[] findByUuid_C_PrevAndNext(long mailingListId,
476                    java.lang.String uuid, long companyId,
477                    OrderByComparator<MBMailingList> orderByComparator)
478                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
479                    return getPersistence()
480                                       .findByUuid_C_PrevAndNext(mailingListId, uuid, companyId,
481                            orderByComparator);
482            }
483    
484            /**
485            * Removes all the message boards mailing lists where uuid = &#63; and companyId = &#63; from the database.
486            *
487            * @param uuid the uuid
488            * @param companyId the company ID
489            */
490            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
491                    getPersistence().removeByUuid_C(uuid, companyId);
492            }
493    
494            /**
495            * Returns the number of message boards mailing lists where uuid = &#63; and companyId = &#63;.
496            *
497            * @param uuid the uuid
498            * @param companyId the company ID
499            * @return the number of matching message boards mailing lists
500            */
501            public static int countByUuid_C(java.lang.String uuid, long companyId) {
502                    return getPersistence().countByUuid_C(uuid, companyId);
503            }
504    
505            /**
506            * Returns all the message boards mailing lists where active = &#63;.
507            *
508            * @param active the active
509            * @return the matching message boards mailing lists
510            */
511            public static List<MBMailingList> findByActive(boolean active) {
512                    return getPersistence().findByActive(active);
513            }
514    
515            /**
516            * Returns a range of all the message boards mailing lists where active = &#63;.
517            *
518            * <p>
519            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
520            * </p>
521            *
522            * @param active the active
523            * @param start the lower bound of the range of message boards mailing lists
524            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
525            * @return the range of matching message boards mailing lists
526            */
527            public static List<MBMailingList> findByActive(boolean active, int start,
528                    int end) {
529                    return getPersistence().findByActive(active, start, end);
530            }
531    
532            /**
533            * Returns an ordered range of all the message boards mailing lists where active = &#63;.
534            *
535            * <p>
536            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
537            * </p>
538            *
539            * @param active the active
540            * @param start the lower bound of the range of message boards mailing lists
541            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
543            * @return the ordered range of matching message boards mailing lists
544            */
545            public static List<MBMailingList> findByActive(boolean active, int start,
546                    int end, OrderByComparator<MBMailingList> orderByComparator) {
547                    return getPersistence()
548                                       .findByActive(active, start, end, orderByComparator);
549            }
550    
551            /**
552            * Returns an ordered range of all the message boards mailing lists where active = &#63;.
553            *
554            * <p>
555            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
556            * </p>
557            *
558            * @param active the active
559            * @param start the lower bound of the range of message boards mailing lists
560            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @param retrieveFromCache whether to retrieve from the finder cache
563            * @return the ordered range of matching message boards mailing lists
564            */
565            public static List<MBMailingList> findByActive(boolean active, int start,
566                    int end, OrderByComparator<MBMailingList> orderByComparator,
567                    boolean retrieveFromCache) {
568                    return getPersistence()
569                                       .findByActive(active, start, end, orderByComparator,
570                            retrieveFromCache);
571            }
572    
573            /**
574            * Returns the first message boards mailing list in the ordered set where active = &#63;.
575            *
576            * @param active the active
577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
578            * @return the first matching message boards mailing list
579            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
580            */
581            public static MBMailingList findByActive_First(boolean active,
582                    OrderByComparator<MBMailingList> orderByComparator)
583                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
584                    return getPersistence().findByActive_First(active, orderByComparator);
585            }
586    
587            /**
588            * Returns the first message boards mailing list in the ordered set where active = &#63;.
589            *
590            * @param active the active
591            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
592            * @return the first matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
593            */
594            public static MBMailingList fetchByActive_First(boolean active,
595                    OrderByComparator<MBMailingList> orderByComparator) {
596                    return getPersistence().fetchByActive_First(active, orderByComparator);
597            }
598    
599            /**
600            * Returns the last message boards mailing list in the ordered set where active = &#63;.
601            *
602            * @param active the active
603            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
604            * @return the last matching message boards mailing list
605            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
606            */
607            public static MBMailingList findByActive_Last(boolean active,
608                    OrderByComparator<MBMailingList> orderByComparator)
609                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
610                    return getPersistence().findByActive_Last(active, orderByComparator);
611            }
612    
613            /**
614            * Returns the last message boards mailing list in the ordered set where active = &#63;.
615            *
616            * @param active the active
617            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
618            * @return the last matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
619            */
620            public static MBMailingList fetchByActive_Last(boolean active,
621                    OrderByComparator<MBMailingList> orderByComparator) {
622                    return getPersistence().fetchByActive_Last(active, orderByComparator);
623            }
624    
625            /**
626            * Returns the message boards mailing lists before and after the current message boards mailing list in the ordered set where active = &#63;.
627            *
628            * @param mailingListId the primary key of the current message boards mailing list
629            * @param active the active
630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
631            * @return the previous, current, and next message boards mailing list
632            * @throws NoSuchMailingListException if a message boards mailing list with the primary key could not be found
633            */
634            public static MBMailingList[] findByActive_PrevAndNext(long mailingListId,
635                    boolean active, OrderByComparator<MBMailingList> orderByComparator)
636                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
637                    return getPersistence()
638                                       .findByActive_PrevAndNext(mailingListId, active,
639                            orderByComparator);
640            }
641    
642            /**
643            * Removes all the message boards mailing lists where active = &#63; from the database.
644            *
645            * @param active the active
646            */
647            public static void removeByActive(boolean active) {
648                    getPersistence().removeByActive(active);
649            }
650    
651            /**
652            * Returns the number of message boards mailing lists where active = &#63;.
653            *
654            * @param active the active
655            * @return the number of matching message boards mailing lists
656            */
657            public static int countByActive(boolean active) {
658                    return getPersistence().countByActive(active);
659            }
660    
661            /**
662            * Returns the message boards mailing list where groupId = &#63; and categoryId = &#63; or throws a {@link NoSuchMailingListException} if it could not be found.
663            *
664            * @param groupId the group ID
665            * @param categoryId the category ID
666            * @return the matching message boards mailing list
667            * @throws NoSuchMailingListException if a matching message boards mailing list could not be found
668            */
669            public static MBMailingList findByG_C(long groupId, long categoryId)
670                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
671                    return getPersistence().findByG_C(groupId, categoryId);
672            }
673    
674            /**
675            * Returns the message boards mailing list where groupId = &#63; and categoryId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
676            *
677            * @param groupId the group ID
678            * @param categoryId the category ID
679            * @return the matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
680            */
681            public static MBMailingList fetchByG_C(long groupId, long categoryId) {
682                    return getPersistence().fetchByG_C(groupId, categoryId);
683            }
684    
685            /**
686            * Returns the message boards mailing list where groupId = &#63; and categoryId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
687            *
688            * @param groupId the group ID
689            * @param categoryId the category ID
690            * @param retrieveFromCache whether to retrieve from the finder cache
691            * @return the matching message boards mailing list, or <code>null</code> if a matching message boards mailing list could not be found
692            */
693            public static MBMailingList fetchByG_C(long groupId, long categoryId,
694                    boolean retrieveFromCache) {
695                    return getPersistence()
696                                       .fetchByG_C(groupId, categoryId, retrieveFromCache);
697            }
698    
699            /**
700            * Removes the message boards mailing list where groupId = &#63; and categoryId = &#63; from the database.
701            *
702            * @param groupId the group ID
703            * @param categoryId the category ID
704            * @return the message boards mailing list that was removed
705            */
706            public static MBMailingList removeByG_C(long groupId, long categoryId)
707                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
708                    return getPersistence().removeByG_C(groupId, categoryId);
709            }
710    
711            /**
712            * Returns the number of message boards mailing lists where groupId = &#63; and categoryId = &#63;.
713            *
714            * @param groupId the group ID
715            * @param categoryId the category ID
716            * @return the number of matching message boards mailing lists
717            */
718            public static int countByG_C(long groupId, long categoryId) {
719                    return getPersistence().countByG_C(groupId, categoryId);
720            }
721    
722            /**
723            * Caches the message boards mailing list in the entity cache if it is enabled.
724            *
725            * @param mbMailingList the message boards mailing list
726            */
727            public static void cacheResult(MBMailingList mbMailingList) {
728                    getPersistence().cacheResult(mbMailingList);
729            }
730    
731            /**
732            * Caches the message boards mailing lists in the entity cache if it is enabled.
733            *
734            * @param mbMailingLists the message boards mailing lists
735            */
736            public static void cacheResult(List<MBMailingList> mbMailingLists) {
737                    getPersistence().cacheResult(mbMailingLists);
738            }
739    
740            /**
741            * Creates a new message boards mailing list with the primary key. Does not add the message boards mailing list to the database.
742            *
743            * @param mailingListId the primary key for the new message boards mailing list
744            * @return the new message boards mailing list
745            */
746            public static MBMailingList create(long mailingListId) {
747                    return getPersistence().create(mailingListId);
748            }
749    
750            /**
751            * Removes the message boards mailing list with the primary key from the database. Also notifies the appropriate model listeners.
752            *
753            * @param mailingListId the primary key of the message boards mailing list
754            * @return the message boards mailing list that was removed
755            * @throws NoSuchMailingListException if a message boards mailing list with the primary key could not be found
756            */
757            public static MBMailingList remove(long mailingListId)
758                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
759                    return getPersistence().remove(mailingListId);
760            }
761    
762            public static MBMailingList updateImpl(MBMailingList mbMailingList) {
763                    return getPersistence().updateImpl(mbMailingList);
764            }
765    
766            /**
767            * Returns the message boards mailing list with the primary key or throws a {@link NoSuchMailingListException} if it could not be found.
768            *
769            * @param mailingListId the primary key of the message boards mailing list
770            * @return the message boards mailing list
771            * @throws NoSuchMailingListException if a message boards mailing list with the primary key could not be found
772            */
773            public static MBMailingList findByPrimaryKey(long mailingListId)
774                    throws com.liferay.portlet.messageboards.exception.NoSuchMailingListException {
775                    return getPersistence().findByPrimaryKey(mailingListId);
776            }
777    
778            /**
779            * Returns the message boards mailing list with the primary key or returns <code>null</code> if it could not be found.
780            *
781            * @param mailingListId the primary key of the message boards mailing list
782            * @return the message boards mailing list, or <code>null</code> if a message boards mailing list with the primary key could not be found
783            */
784            public static MBMailingList fetchByPrimaryKey(long mailingListId) {
785                    return getPersistence().fetchByPrimaryKey(mailingListId);
786            }
787    
788            public static java.util.Map<java.io.Serializable, MBMailingList> fetchByPrimaryKeys(
789                    java.util.Set<java.io.Serializable> primaryKeys) {
790                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
791            }
792    
793            /**
794            * Returns all the message boards mailing lists.
795            *
796            * @return the message boards mailing lists
797            */
798            public static List<MBMailingList> findAll() {
799                    return getPersistence().findAll();
800            }
801    
802            /**
803            * Returns a range of all the message boards mailing lists.
804            *
805            * <p>
806            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
807            * </p>
808            *
809            * @param start the lower bound of the range of message boards mailing lists
810            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
811            * @return the range of message boards mailing lists
812            */
813            public static List<MBMailingList> findAll(int start, int end) {
814                    return getPersistence().findAll(start, end);
815            }
816    
817            /**
818            * Returns an ordered range of all the message boards mailing lists.
819            *
820            * <p>
821            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
822            * </p>
823            *
824            * @param start the lower bound of the range of message boards mailing lists
825            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
826            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
827            * @return the ordered range of message boards mailing lists
828            */
829            public static List<MBMailingList> findAll(int start, int end,
830                    OrderByComparator<MBMailingList> orderByComparator) {
831                    return getPersistence().findAll(start, end, orderByComparator);
832            }
833    
834            /**
835            * Returns an ordered range of all the message boards mailing lists.
836            *
837            * <p>
838            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 MBMailingListModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
839            * </p>
840            *
841            * @param start the lower bound of the range of message boards mailing lists
842            * @param end the upper bound of the range of message boards mailing lists (not inclusive)
843            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
844            * @param retrieveFromCache whether to retrieve from the finder cache
845            * @return the ordered range of message boards mailing lists
846            */
847            public static List<MBMailingList> findAll(int start, int end,
848                    OrderByComparator<MBMailingList> orderByComparator,
849                    boolean retrieveFromCache) {
850                    return getPersistence()
851                                       .findAll(start, end, orderByComparator, retrieveFromCache);
852            }
853    
854            /**
855            * Removes all the message boards mailing lists from the database.
856            */
857            public static void removeAll() {
858                    getPersistence().removeAll();
859            }
860    
861            /**
862            * Returns the number of message boards mailing lists.
863            *
864            * @return the number of message boards mailing lists
865            */
866            public static int countAll() {
867                    return getPersistence().countAll();
868            }
869    
870            public static java.util.Set<java.lang.String> getBadColumnNames() {
871                    return getPersistence().getBadColumnNames();
872            }
873    
874            public static MBMailingListPersistence getPersistence() {
875                    if (_persistence == null) {
876                            _persistence = (MBMailingListPersistence)PortalBeanLocatorUtil.locate(MBMailingListPersistence.class.getName());
877    
878                            ReferenceRegistry.registerReference(MBMailingListUtil.class,
879                                    "_persistence");
880                    }
881    
882                    return _persistence;
883            }
884    
885            private static MBMailingListPersistence _persistence;
886    }