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