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