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