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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ? 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 = ? and companyId = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and categoryId = ? 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 = ? and categoryId = ? 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 = ? and categoryId = ? 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 = ? and categoryId = ? 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 = ? and categoryId = ?. 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 }