001 /** 002 * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.messageboards.model.MBThread; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the message boards thread service. This utility wraps {@link MBThreadPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see MBThreadPersistence 037 * @see MBThreadPersistenceImpl 038 * @generated 039 */ 040 public class MBThreadUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(MBThread mbThread) { 058 getPersistence().clearCache(mbThread); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery) 073 throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<MBThread> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<MBThread> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static MBThread update(MBThread mbThread) throws SystemException { 101 return getPersistence().update(mbThread); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static MBThread update(MBThread mbThread, 108 ServiceContext serviceContext) throws SystemException { 109 return getPersistence().update(mbThread, serviceContext); 110 } 111 112 /** 113 * Caches the message boards thread in the entity cache if it is enabled. 114 * 115 * @param mbThread the message boards thread 116 */ 117 public static void cacheResult( 118 com.liferay.portlet.messageboards.model.MBThread mbThread) { 119 getPersistence().cacheResult(mbThread); 120 } 121 122 /** 123 * Caches the message boards threads in the entity cache if it is enabled. 124 * 125 * @param mbThreads the message boards threads 126 */ 127 public static void cacheResult( 128 java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) { 129 getPersistence().cacheResult(mbThreads); 130 } 131 132 /** 133 * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database. 134 * 135 * @param threadId the primary key for the new message boards thread 136 * @return the new message boards thread 137 */ 138 public static com.liferay.portlet.messageboards.model.MBThread create( 139 long threadId) { 140 return getPersistence().create(threadId); 141 } 142 143 /** 144 * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners. 145 * 146 * @param threadId the primary key of the message boards thread 147 * @return the message boards thread that was removed 148 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 149 * @throws SystemException if a system exception occurred 150 */ 151 public static com.liferay.portlet.messageboards.model.MBThread remove( 152 long threadId) 153 throws com.liferay.portal.kernel.exception.SystemException, 154 com.liferay.portlet.messageboards.NoSuchThreadException { 155 return getPersistence().remove(threadId); 156 } 157 158 public static com.liferay.portlet.messageboards.model.MBThread updateImpl( 159 com.liferay.portlet.messageboards.model.MBThread mbThread) 160 throws com.liferay.portal.kernel.exception.SystemException { 161 return getPersistence().updateImpl(mbThread); 162 } 163 164 /** 165 * Returns the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 166 * 167 * @param threadId the primary key of the message boards thread 168 * @return the message boards thread 169 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 170 * @throws SystemException if a system exception occurred 171 */ 172 public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey( 173 long threadId) 174 throws com.liferay.portal.kernel.exception.SystemException, 175 com.liferay.portlet.messageboards.NoSuchThreadException { 176 return getPersistence().findByPrimaryKey(threadId); 177 } 178 179 /** 180 * Returns the message boards thread with the primary key or returns <code>null</code> if it could not be found. 181 * 182 * @param threadId the primary key of the message boards thread 183 * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found 184 * @throws SystemException if a system exception occurred 185 */ 186 public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey( 187 long threadId) 188 throws com.liferay.portal.kernel.exception.SystemException { 189 return getPersistence().fetchByPrimaryKey(threadId); 190 } 191 192 /** 193 * Returns all the message boards threads where groupId = ?. 194 * 195 * @param groupId the group ID 196 * @return the matching message boards threads 197 * @throws SystemException if a system exception occurred 198 */ 199 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 200 long groupId) 201 throws com.liferay.portal.kernel.exception.SystemException { 202 return getPersistence().findByGroupId(groupId); 203 } 204 205 /** 206 * Returns a range of all the message boards threads where groupId = ?. 207 * 208 * <p> 209 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 210 * </p> 211 * 212 * @param groupId the group ID 213 * @param start the lower bound of the range of message boards threads 214 * @param end the upper bound of the range of message boards threads (not inclusive) 215 * @return the range of matching message boards threads 216 * @throws SystemException if a system exception occurred 217 */ 218 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 219 long groupId, int start, int end) 220 throws com.liferay.portal.kernel.exception.SystemException { 221 return getPersistence().findByGroupId(groupId, start, end); 222 } 223 224 /** 225 * Returns an ordered range of all the message boards threads where groupId = ?. 226 * 227 * <p> 228 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 229 * </p> 230 * 231 * @param groupId the group ID 232 * @param start the lower bound of the range of message boards threads 233 * @param end the upper bound of the range of message boards threads (not inclusive) 234 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 235 * @return the ordered range of matching message boards threads 236 * @throws SystemException if a system exception occurred 237 */ 238 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 239 long groupId, int start, int end, 240 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 241 throws com.liferay.portal.kernel.exception.SystemException { 242 return getPersistence() 243 .findByGroupId(groupId, start, end, orderByComparator); 244 } 245 246 /** 247 * Returns the first message boards thread in the ordered set where groupId = ?. 248 * 249 * @param groupId the group ID 250 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 251 * @return the first matching message boards thread 252 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 253 * @throws SystemException if a system exception occurred 254 */ 255 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First( 256 long groupId, 257 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 258 throws com.liferay.portal.kernel.exception.SystemException, 259 com.liferay.portlet.messageboards.NoSuchThreadException { 260 return getPersistence().findByGroupId_First(groupId, orderByComparator); 261 } 262 263 /** 264 * Returns the first message boards thread in the ordered set where groupId = ?. 265 * 266 * @param groupId the group ID 267 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 268 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 269 * @throws SystemException if a system exception occurred 270 */ 271 public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_First( 272 long groupId, 273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 274 throws com.liferay.portal.kernel.exception.SystemException { 275 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 276 } 277 278 /** 279 * Returns the last message boards thread in the ordered set where groupId = ?. 280 * 281 * @param groupId the group ID 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the last matching message boards thread 284 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 285 * @throws SystemException if a system exception occurred 286 */ 287 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last( 288 long groupId, 289 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 290 throws com.liferay.portal.kernel.exception.SystemException, 291 com.liferay.portlet.messageboards.NoSuchThreadException { 292 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 293 } 294 295 /** 296 * Returns the last message boards thread in the ordered set where groupId = ?. 297 * 298 * @param groupId the group ID 299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 300 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 301 * @throws SystemException if a system exception occurred 302 */ 303 public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_Last( 304 long groupId, 305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 306 throws com.liferay.portal.kernel.exception.SystemException { 307 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 308 } 309 310 /** 311 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ?. 312 * 313 * @param threadId the primary key of the current message boards thread 314 * @param groupId the group ID 315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 316 * @return the previous, current, and next message boards thread 317 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 318 * @throws SystemException if a system exception occurred 319 */ 320 public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext( 321 long threadId, long groupId, 322 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 323 throws com.liferay.portal.kernel.exception.SystemException, 324 com.liferay.portlet.messageboards.NoSuchThreadException { 325 return getPersistence() 326 .findByGroupId_PrevAndNext(threadId, groupId, 327 orderByComparator); 328 } 329 330 /** 331 * Returns all the message boards threads that the user has permission to view where groupId = ?. 332 * 333 * @param groupId the group ID 334 * @return the matching message boards threads that the user has permission to view 335 * @throws SystemException if a system exception occurred 336 */ 337 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 338 long groupId) 339 throws com.liferay.portal.kernel.exception.SystemException { 340 return getPersistence().filterFindByGroupId(groupId); 341 } 342 343 /** 344 * Returns a range of all the message boards threads that the user has permission to view where groupId = ?. 345 * 346 * <p> 347 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 348 * </p> 349 * 350 * @param groupId the group ID 351 * @param start the lower bound of the range of message boards threads 352 * @param end the upper bound of the range of message boards threads (not inclusive) 353 * @return the range of matching message boards threads that the user has permission to view 354 * @throws SystemException if a system exception occurred 355 */ 356 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 357 long groupId, int start, int end) 358 throws com.liferay.portal.kernel.exception.SystemException { 359 return getPersistence().filterFindByGroupId(groupId, start, end); 360 } 361 362 /** 363 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ?. 364 * 365 * <p> 366 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 367 * </p> 368 * 369 * @param groupId the group ID 370 * @param start the lower bound of the range of message boards threads 371 * @param end the upper bound of the range of message boards threads (not inclusive) 372 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 373 * @return the ordered range of matching message boards threads that the user has permission to view 374 * @throws SystemException if a system exception occurred 375 */ 376 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 377 long groupId, int start, int end, 378 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 379 throws com.liferay.portal.kernel.exception.SystemException { 380 return getPersistence() 381 .filterFindByGroupId(groupId, start, end, orderByComparator); 382 } 383 384 /** 385 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ?. 386 * 387 * @param threadId the primary key of the current message boards thread 388 * @param groupId the group ID 389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 390 * @return the previous, current, and next message boards thread 391 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 392 * @throws SystemException if a system exception occurred 393 */ 394 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByGroupId_PrevAndNext( 395 long threadId, long groupId, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException, 398 com.liferay.portlet.messageboards.NoSuchThreadException { 399 return getPersistence() 400 .filterFindByGroupId_PrevAndNext(threadId, groupId, 401 orderByComparator); 402 } 403 404 /** 405 * Returns the message boards thread where rootMessageId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 406 * 407 * @param rootMessageId the root message ID 408 * @return the matching message boards thread 409 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.messageboards.model.MBThread findByRootMessageId( 413 long rootMessageId) 414 throws com.liferay.portal.kernel.exception.SystemException, 415 com.liferay.portlet.messageboards.NoSuchThreadException { 416 return getPersistence().findByRootMessageId(rootMessageId); 417 } 418 419 /** 420 * Returns the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 421 * 422 * @param rootMessageId the root message ID 423 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 424 * @throws SystemException if a system exception occurred 425 */ 426 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 427 long rootMessageId) 428 throws com.liferay.portal.kernel.exception.SystemException { 429 return getPersistence().fetchByRootMessageId(rootMessageId); 430 } 431 432 /** 433 * Returns the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 434 * 435 * @param rootMessageId the root message ID 436 * @param retrieveFromCache whether to use the finder cache 437 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 438 * @throws SystemException if a system exception occurred 439 */ 440 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 441 long rootMessageId, boolean retrieveFromCache) 442 throws com.liferay.portal.kernel.exception.SystemException { 443 return getPersistence() 444 .fetchByRootMessageId(rootMessageId, retrieveFromCache); 445 } 446 447 /** 448 * Returns all the message boards threads where groupId = ? and categoryId = ?. 449 * 450 * @param groupId the group ID 451 * @param categoryId the category ID 452 * @return the matching message boards threads 453 * @throws SystemException if a system exception occurred 454 */ 455 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 456 long groupId, long categoryId) 457 throws com.liferay.portal.kernel.exception.SystemException { 458 return getPersistence().findByG_C(groupId, categoryId); 459 } 460 461 /** 462 * Returns a range of all the message boards threads where groupId = ? and categoryId = ?. 463 * 464 * <p> 465 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 466 * </p> 467 * 468 * @param groupId the group ID 469 * @param categoryId the category ID 470 * @param start the lower bound of the range of message boards threads 471 * @param end the upper bound of the range of message boards threads (not inclusive) 472 * @return the range of matching message boards threads 473 * @throws SystemException if a system exception occurred 474 */ 475 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 476 long groupId, long categoryId, int start, int end) 477 throws com.liferay.portal.kernel.exception.SystemException { 478 return getPersistence().findByG_C(groupId, categoryId, start, end); 479 } 480 481 /** 482 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ?. 483 * 484 * <p> 485 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 486 * </p> 487 * 488 * @param groupId the group ID 489 * @param categoryId the category ID 490 * @param start the lower bound of the range of message boards threads 491 * @param end the upper bound of the range of message boards threads (not inclusive) 492 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 493 * @return the ordered range of matching message boards threads 494 * @throws SystemException if a system exception occurred 495 */ 496 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 497 long groupId, long categoryId, int start, int end, 498 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 499 throws com.liferay.portal.kernel.exception.SystemException { 500 return getPersistence() 501 .findByG_C(groupId, categoryId, start, end, orderByComparator); 502 } 503 504 /** 505 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 506 * 507 * @param groupId the group ID 508 * @param categoryId the category ID 509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 510 * @return the first matching message boards thread 511 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 512 * @throws SystemException if a system exception occurred 513 */ 514 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First( 515 long groupId, long categoryId, 516 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 517 throws com.liferay.portal.kernel.exception.SystemException, 518 com.liferay.portlet.messageboards.NoSuchThreadException { 519 return getPersistence() 520 .findByG_C_First(groupId, categoryId, orderByComparator); 521 } 522 523 /** 524 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 525 * 526 * @param groupId the group ID 527 * @param categoryId the category ID 528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 529 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 530 * @throws SystemException if a system exception occurred 531 */ 532 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_First( 533 long groupId, long categoryId, 534 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 535 throws com.liferay.portal.kernel.exception.SystemException { 536 return getPersistence() 537 .fetchByG_C_First(groupId, categoryId, orderByComparator); 538 } 539 540 /** 541 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 542 * 543 * @param groupId the group ID 544 * @param categoryId the category ID 545 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 546 * @return the last matching message boards thread 547 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 548 * @throws SystemException if a system exception occurred 549 */ 550 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last( 551 long groupId, long categoryId, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException, 554 com.liferay.portlet.messageboards.NoSuchThreadException { 555 return getPersistence() 556 .findByG_C_Last(groupId, categoryId, orderByComparator); 557 } 558 559 /** 560 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 561 * 562 * @param groupId the group ID 563 * @param categoryId the category ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 566 * @throws SystemException if a system exception occurred 567 */ 568 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_Last( 569 long groupId, long categoryId, 570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 571 throws com.liferay.portal.kernel.exception.SystemException { 572 return getPersistence() 573 .fetchByG_C_Last(groupId, categoryId, orderByComparator); 574 } 575 576 /** 577 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ?. 578 * 579 * @param threadId the primary key of the current message boards thread 580 * @param groupId the group ID 581 * @param categoryId the category ID 582 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 583 * @return the previous, current, and next message boards thread 584 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 585 * @throws SystemException if a system exception occurred 586 */ 587 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext( 588 long threadId, long groupId, long categoryId, 589 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 590 throws com.liferay.portal.kernel.exception.SystemException, 591 com.liferay.portlet.messageboards.NoSuchThreadException { 592 return getPersistence() 593 .findByG_C_PrevAndNext(threadId, groupId, categoryId, 594 orderByComparator); 595 } 596 597 /** 598 * Returns all the message boards threads where groupId = ? and categoryId = any ?. 599 * 600 * <p> 601 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 602 * </p> 603 * 604 * @param groupId the group ID 605 * @param categoryIds the category IDs 606 * @return the matching message boards threads 607 * @throws SystemException if a system exception occurred 608 */ 609 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 610 long groupId, long[] categoryIds) 611 throws com.liferay.portal.kernel.exception.SystemException { 612 return getPersistence().findByG_C(groupId, categoryIds); 613 } 614 615 /** 616 * Returns a range of all the message boards threads where groupId = ? and categoryId = any ?. 617 * 618 * <p> 619 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 620 * </p> 621 * 622 * @param groupId the group ID 623 * @param categoryIds the category IDs 624 * @param start the lower bound of the range of message boards threads 625 * @param end the upper bound of the range of message boards threads (not inclusive) 626 * @return the range of matching message boards threads 627 * @throws SystemException if a system exception occurred 628 */ 629 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 630 long groupId, long[] categoryIds, int start, int end) 631 throws com.liferay.portal.kernel.exception.SystemException { 632 return getPersistence().findByG_C(groupId, categoryIds, start, end); 633 } 634 635 /** 636 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = any ?. 637 * 638 * <p> 639 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 640 * </p> 641 * 642 * @param groupId the group ID 643 * @param categoryIds the category IDs 644 * @param start the lower bound of the range of message boards threads 645 * @param end the upper bound of the range of message boards threads (not inclusive) 646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 647 * @return the ordered range of matching message boards threads 648 * @throws SystemException if a system exception occurred 649 */ 650 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 651 long groupId, long[] categoryIds, int start, int end, 652 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 653 throws com.liferay.portal.kernel.exception.SystemException { 654 return getPersistence() 655 .findByG_C(groupId, categoryIds, start, end, 656 orderByComparator); 657 } 658 659 /** 660 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 661 * 662 * @param groupId the group ID 663 * @param categoryId the category ID 664 * @return the matching message boards threads that the user has permission to view 665 * @throws SystemException if a system exception occurred 666 */ 667 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 668 long groupId, long categoryId) 669 throws com.liferay.portal.kernel.exception.SystemException { 670 return getPersistence().filterFindByG_C(groupId, categoryId); 671 } 672 673 /** 674 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 675 * 676 * <p> 677 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 678 * </p> 679 * 680 * @param groupId the group ID 681 * @param categoryId the category ID 682 * @param start the lower bound of the range of message boards threads 683 * @param end the upper bound of the range of message boards threads (not inclusive) 684 * @return the range of matching message boards threads that the user has permission to view 685 * @throws SystemException if a system exception occurred 686 */ 687 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 688 long groupId, long categoryId, int start, int end) 689 throws com.liferay.portal.kernel.exception.SystemException { 690 return getPersistence().filterFindByG_C(groupId, categoryId, start, end); 691 } 692 693 /** 694 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ?. 695 * 696 * <p> 697 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 698 * </p> 699 * 700 * @param groupId the group ID 701 * @param categoryId the category ID 702 * @param start the lower bound of the range of message boards threads 703 * @param end the upper bound of the range of message boards threads (not inclusive) 704 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 705 * @return the ordered range of matching message boards threads that the user has permission to view 706 * @throws SystemException if a system exception occurred 707 */ 708 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 709 long groupId, long categoryId, int start, int end, 710 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 711 throws com.liferay.portal.kernel.exception.SystemException { 712 return getPersistence() 713 .filterFindByG_C(groupId, categoryId, start, end, 714 orderByComparator); 715 } 716 717 /** 718 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 719 * 720 * @param threadId the primary key of the current message boards thread 721 * @param groupId the group ID 722 * @param categoryId the category ID 723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 724 * @return the previous, current, and next message boards thread 725 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 726 * @throws SystemException if a system exception occurred 727 */ 728 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_PrevAndNext( 729 long threadId, long groupId, long categoryId, 730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 731 throws com.liferay.portal.kernel.exception.SystemException, 732 com.liferay.portlet.messageboards.NoSuchThreadException { 733 return getPersistence() 734 .filterFindByG_C_PrevAndNext(threadId, groupId, categoryId, 735 orderByComparator); 736 } 737 738 /** 739 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 740 * 741 * @param groupId the group ID 742 * @param categoryIds the category IDs 743 * @return the matching message boards threads that the user has permission to view 744 * @throws SystemException if a system exception occurred 745 */ 746 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 747 long groupId, long[] categoryIds) 748 throws com.liferay.portal.kernel.exception.SystemException { 749 return getPersistence().filterFindByG_C(groupId, categoryIds); 750 } 751 752 /** 753 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 754 * 755 * <p> 756 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 757 * </p> 758 * 759 * @param groupId the group ID 760 * @param categoryIds the category IDs 761 * @param start the lower bound of the range of message boards threads 762 * @param end the upper bound of the range of message boards threads (not inclusive) 763 * @return the range of matching message boards threads that the user has permission to view 764 * @throws SystemException if a system exception occurred 765 */ 766 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 767 long groupId, long[] categoryIds, int start, int end) 768 throws com.liferay.portal.kernel.exception.SystemException { 769 return getPersistence().filterFindByG_C(groupId, categoryIds, start, end); 770 } 771 772 /** 773 * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 774 * 775 * <p> 776 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 777 * </p> 778 * 779 * @param groupId the group ID 780 * @param categoryIds the category IDs 781 * @param start the lower bound of the range of message boards threads 782 * @param end the upper bound of the range of message boards threads (not inclusive) 783 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 784 * @return the ordered range of matching message boards threads that the user has permission to view 785 * @throws SystemException if a system exception occurred 786 */ 787 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 788 long groupId, long[] categoryIds, int start, int end, 789 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 790 throws com.liferay.portal.kernel.exception.SystemException { 791 return getPersistence() 792 .filterFindByG_C(groupId, categoryIds, start, end, 793 orderByComparator); 794 } 795 796 /** 797 * Returns all the message boards threads where groupId = ? and categoryId ≠ ?. 798 * 799 * @param groupId the group ID 800 * @param categoryId the category ID 801 * @return the matching message boards threads 802 * @throws SystemException if a system exception occurred 803 */ 804 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 805 long groupId, long categoryId) 806 throws com.liferay.portal.kernel.exception.SystemException { 807 return getPersistence().findByG_NotC(groupId, categoryId); 808 } 809 810 /** 811 * Returns a range of all the message boards threads where groupId = ? and categoryId ≠ ?. 812 * 813 * <p> 814 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 815 * </p> 816 * 817 * @param groupId the group ID 818 * @param categoryId the category ID 819 * @param start the lower bound of the range of message boards threads 820 * @param end the upper bound of the range of message boards threads (not inclusive) 821 * @return the range of matching message boards threads 822 * @throws SystemException if a system exception occurred 823 */ 824 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 825 long groupId, long categoryId, int start, int end) 826 throws com.liferay.portal.kernel.exception.SystemException { 827 return getPersistence().findByG_NotC(groupId, categoryId, start, end); 828 } 829 830 /** 831 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ?. 832 * 833 * <p> 834 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 835 * </p> 836 * 837 * @param groupId the group ID 838 * @param categoryId the category ID 839 * @param start the lower bound of the range of message boards threads 840 * @param end the upper bound of the range of message boards threads (not inclusive) 841 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 842 * @return the ordered range of matching message boards threads 843 * @throws SystemException if a system exception occurred 844 */ 845 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 846 long groupId, long categoryId, int start, int end, 847 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 848 throws com.liferay.portal.kernel.exception.SystemException { 849 return getPersistence() 850 .findByG_NotC(groupId, categoryId, start, end, 851 orderByComparator); 852 } 853 854 /** 855 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 856 * 857 * @param groupId the group ID 858 * @param categoryId the category ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the first matching message boards thread 861 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 862 * @throws SystemException if a system exception occurred 863 */ 864 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First( 865 long groupId, long categoryId, 866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 867 throws com.liferay.portal.kernel.exception.SystemException, 868 com.liferay.portlet.messageboards.NoSuchThreadException { 869 return getPersistence() 870 .findByG_NotC_First(groupId, categoryId, orderByComparator); 871 } 872 873 /** 874 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 875 * 876 * @param groupId the group ID 877 * @param categoryId the category ID 878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 879 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 880 * @throws SystemException if a system exception occurred 881 */ 882 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_First( 883 long groupId, long categoryId, 884 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 885 throws com.liferay.portal.kernel.exception.SystemException { 886 return getPersistence() 887 .fetchByG_NotC_First(groupId, categoryId, orderByComparator); 888 } 889 890 /** 891 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 892 * 893 * @param groupId the group ID 894 * @param categoryId the category ID 895 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 896 * @return the last matching message boards thread 897 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 898 * @throws SystemException if a system exception occurred 899 */ 900 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last( 901 long groupId, long categoryId, 902 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 903 throws com.liferay.portal.kernel.exception.SystemException, 904 com.liferay.portlet.messageboards.NoSuchThreadException { 905 return getPersistence() 906 .findByG_NotC_Last(groupId, categoryId, orderByComparator); 907 } 908 909 /** 910 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 911 * 912 * @param groupId the group ID 913 * @param categoryId the category ID 914 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 915 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 916 * @throws SystemException if a system exception occurred 917 */ 918 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_Last( 919 long groupId, long categoryId, 920 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 921 throws com.liferay.portal.kernel.exception.SystemException { 922 return getPersistence() 923 .fetchByG_NotC_Last(groupId, categoryId, orderByComparator); 924 } 925 926 /** 927 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 928 * 929 * @param threadId the primary key of the current message boards thread 930 * @param groupId the group ID 931 * @param categoryId the category ID 932 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 933 * @return the previous, current, and next message boards thread 934 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 935 * @throws SystemException if a system exception occurred 936 */ 937 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext( 938 long threadId, long groupId, long categoryId, 939 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 940 throws com.liferay.portal.kernel.exception.SystemException, 941 com.liferay.portlet.messageboards.NoSuchThreadException { 942 return getPersistence() 943 .findByG_NotC_PrevAndNext(threadId, groupId, categoryId, 944 orderByComparator); 945 } 946 947 /** 948 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 949 * 950 * @param groupId the group ID 951 * @param categoryId the category ID 952 * @return the matching message boards threads that the user has permission to view 953 * @throws SystemException if a system exception occurred 954 */ 955 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 956 long groupId, long categoryId) 957 throws com.liferay.portal.kernel.exception.SystemException { 958 return getPersistence().filterFindByG_NotC(groupId, categoryId); 959 } 960 961 /** 962 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 963 * 964 * <p> 965 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 966 * </p> 967 * 968 * @param groupId the group ID 969 * @param categoryId the category ID 970 * @param start the lower bound of the range of message boards threads 971 * @param end the upper bound of the range of message boards threads (not inclusive) 972 * @return the range of matching message boards threads that the user has permission to view 973 * @throws SystemException if a system exception occurred 974 */ 975 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 976 long groupId, long categoryId, int start, int end) 977 throws com.liferay.portal.kernel.exception.SystemException { 978 return getPersistence() 979 .filterFindByG_NotC(groupId, categoryId, start, end); 980 } 981 982 /** 983 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId ≠ ?. 984 * 985 * <p> 986 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 987 * </p> 988 * 989 * @param groupId the group ID 990 * @param categoryId the category ID 991 * @param start the lower bound of the range of message boards threads 992 * @param end the upper bound of the range of message boards threads (not inclusive) 993 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 994 * @return the ordered range of matching message boards threads that the user has permission to view 995 * @throws SystemException if a system exception occurred 996 */ 997 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 998 long groupId, long categoryId, int start, int end, 999 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1000 throws com.liferay.portal.kernel.exception.SystemException { 1001 return getPersistence() 1002 .filterFindByG_NotC(groupId, categoryId, start, end, 1003 orderByComparator); 1004 } 1005 1006 /** 1007 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 1008 * 1009 * @param threadId the primary key of the current message boards thread 1010 * @param groupId the group ID 1011 * @param categoryId the category ID 1012 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1013 * @return the previous, current, and next message boards thread 1014 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_PrevAndNext( 1018 long threadId, long groupId, long categoryId, 1019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1020 throws com.liferay.portal.kernel.exception.SystemException, 1021 com.liferay.portlet.messageboards.NoSuchThreadException { 1022 return getPersistence() 1023 .filterFindByG_NotC_PrevAndNext(threadId, groupId, 1024 categoryId, orderByComparator); 1025 } 1026 1027 /** 1028 * Returns all the message boards threads where groupId = ? and status = ?. 1029 * 1030 * @param groupId the group ID 1031 * @param status the status 1032 * @return the matching message boards threads 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1036 long groupId, int status) 1037 throws com.liferay.portal.kernel.exception.SystemException { 1038 return getPersistence().findByG_S(groupId, status); 1039 } 1040 1041 /** 1042 * Returns a range of all the message boards threads where groupId = ? and status = ?. 1043 * 1044 * <p> 1045 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1046 * </p> 1047 * 1048 * @param groupId the group ID 1049 * @param status the status 1050 * @param start the lower bound of the range of message boards threads 1051 * @param end the upper bound of the range of message boards threads (not inclusive) 1052 * @return the range of matching message boards threads 1053 * @throws SystemException if a system exception occurred 1054 */ 1055 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1056 long groupId, int status, int start, int end) 1057 throws com.liferay.portal.kernel.exception.SystemException { 1058 return getPersistence().findByG_S(groupId, status, start, end); 1059 } 1060 1061 /** 1062 * Returns an ordered range of all the message boards threads where groupId = ? and status = ?. 1063 * 1064 * <p> 1065 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1066 * </p> 1067 * 1068 * @param groupId the group ID 1069 * @param status the status 1070 * @param start the lower bound of the range of message boards threads 1071 * @param end the upper bound of the range of message boards threads (not inclusive) 1072 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1073 * @return the ordered range of matching message boards threads 1074 * @throws SystemException if a system exception occurred 1075 */ 1076 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1077 long groupId, int status, int start, int end, 1078 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1079 throws com.liferay.portal.kernel.exception.SystemException { 1080 return getPersistence() 1081 .findByG_S(groupId, status, start, end, orderByComparator); 1082 } 1083 1084 /** 1085 * Returns the first message boards thread in the ordered set where groupId = ? and status = ?. 1086 * 1087 * @param groupId the group ID 1088 * @param status the status 1089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1090 * @return the first matching message boards thread 1091 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1092 * @throws SystemException if a system exception occurred 1093 */ 1094 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First( 1095 long groupId, int status, 1096 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1097 throws com.liferay.portal.kernel.exception.SystemException, 1098 com.liferay.portlet.messageboards.NoSuchThreadException { 1099 return getPersistence() 1100 .findByG_S_First(groupId, status, orderByComparator); 1101 } 1102 1103 /** 1104 * Returns the first message boards thread in the ordered set where groupId = ? and status = ?. 1105 * 1106 * @param groupId the group ID 1107 * @param status the status 1108 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1109 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1110 * @throws SystemException if a system exception occurred 1111 */ 1112 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_First( 1113 long groupId, int status, 1114 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1115 throws com.liferay.portal.kernel.exception.SystemException { 1116 return getPersistence() 1117 .fetchByG_S_First(groupId, status, orderByComparator); 1118 } 1119 1120 /** 1121 * Returns the last message boards thread in the ordered set where groupId = ? and status = ?. 1122 * 1123 * @param groupId the group ID 1124 * @param status the status 1125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1126 * @return the last matching message boards thread 1127 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1128 * @throws SystemException if a system exception occurred 1129 */ 1130 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last( 1131 long groupId, int status, 1132 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1133 throws com.liferay.portal.kernel.exception.SystemException, 1134 com.liferay.portlet.messageboards.NoSuchThreadException { 1135 return getPersistence() 1136 .findByG_S_Last(groupId, status, orderByComparator); 1137 } 1138 1139 /** 1140 * Returns the last message boards thread in the ordered set where groupId = ? and status = ?. 1141 * 1142 * @param groupId the group ID 1143 * @param status the status 1144 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1145 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1146 * @throws SystemException if a system exception occurred 1147 */ 1148 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_Last( 1149 long groupId, int status, 1150 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1151 throws com.liferay.portal.kernel.exception.SystemException { 1152 return getPersistence() 1153 .fetchByG_S_Last(groupId, status, orderByComparator); 1154 } 1155 1156 /** 1157 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and status = ?. 1158 * 1159 * @param threadId the primary key of the current message boards thread 1160 * @param groupId the group ID 1161 * @param status the status 1162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1163 * @return the previous, current, and next message boards thread 1164 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1165 * @throws SystemException if a system exception occurred 1166 */ 1167 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext( 1168 long threadId, long groupId, int status, 1169 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1170 throws com.liferay.portal.kernel.exception.SystemException, 1171 com.liferay.portlet.messageboards.NoSuchThreadException { 1172 return getPersistence() 1173 .findByG_S_PrevAndNext(threadId, groupId, status, 1174 orderByComparator); 1175 } 1176 1177 /** 1178 * Returns all the message boards threads that the user has permission to view where groupId = ? and status = ?. 1179 * 1180 * @param groupId the group ID 1181 * @param status the status 1182 * @return the matching message boards threads that the user has permission to view 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1186 long groupId, int status) 1187 throws com.liferay.portal.kernel.exception.SystemException { 1188 return getPersistence().filterFindByG_S(groupId, status); 1189 } 1190 1191 /** 1192 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and status = ?. 1193 * 1194 * <p> 1195 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1196 * </p> 1197 * 1198 * @param groupId the group ID 1199 * @param status the status 1200 * @param start the lower bound of the range of message boards threads 1201 * @param end the upper bound of the range of message boards threads (not inclusive) 1202 * @return the range of matching message boards threads that the user has permission to view 1203 * @throws SystemException if a system exception occurred 1204 */ 1205 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1206 long groupId, int status, int start, int end) 1207 throws com.liferay.portal.kernel.exception.SystemException { 1208 return getPersistence().filterFindByG_S(groupId, status, start, end); 1209 } 1210 1211 /** 1212 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and status = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1216 * </p> 1217 * 1218 * @param groupId the group ID 1219 * @param status the status 1220 * @param start the lower bound of the range of message boards threads 1221 * @param end the upper bound of the range of message boards threads (not inclusive) 1222 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1223 * @return the ordered range of matching message boards threads that the user has permission to view 1224 * @throws SystemException if a system exception occurred 1225 */ 1226 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1227 long groupId, int status, int start, int end, 1228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1229 throws com.liferay.portal.kernel.exception.SystemException { 1230 return getPersistence() 1231 .filterFindByG_S(groupId, status, start, end, 1232 orderByComparator); 1233 } 1234 1235 /** 1236 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and status = ?. 1237 * 1238 * @param threadId the primary key of the current message boards thread 1239 * @param groupId the group ID 1240 * @param status the status 1241 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1242 * @return the previous, current, and next message boards thread 1243 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1244 * @throws SystemException if a system exception occurred 1245 */ 1246 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_S_PrevAndNext( 1247 long threadId, long groupId, int status, 1248 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1249 throws com.liferay.portal.kernel.exception.SystemException, 1250 com.liferay.portlet.messageboards.NoSuchThreadException { 1251 return getPersistence() 1252 .filterFindByG_S_PrevAndNext(threadId, groupId, status, 1253 orderByComparator); 1254 } 1255 1256 /** 1257 * Returns all the message boards threads where categoryId = ? and priority = ?. 1258 * 1259 * @param categoryId the category ID 1260 * @param priority the priority 1261 * @return the matching message boards threads 1262 * @throws SystemException if a system exception occurred 1263 */ 1264 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1265 long categoryId, double priority) 1266 throws com.liferay.portal.kernel.exception.SystemException { 1267 return getPersistence().findByC_P(categoryId, priority); 1268 } 1269 1270 /** 1271 * Returns a range of all the message boards threads where categoryId = ? and priority = ?. 1272 * 1273 * <p> 1274 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1275 * </p> 1276 * 1277 * @param categoryId the category ID 1278 * @param priority the priority 1279 * @param start the lower bound of the range of message boards threads 1280 * @param end the upper bound of the range of message boards threads (not inclusive) 1281 * @return the range of matching message boards threads 1282 * @throws SystemException if a system exception occurred 1283 */ 1284 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1285 long categoryId, double priority, int start, int end) 1286 throws com.liferay.portal.kernel.exception.SystemException { 1287 return getPersistence().findByC_P(categoryId, priority, start, end); 1288 } 1289 1290 /** 1291 * Returns an ordered range of all the message boards threads where categoryId = ? and priority = ?. 1292 * 1293 * <p> 1294 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1295 * </p> 1296 * 1297 * @param categoryId the category ID 1298 * @param priority the priority 1299 * @param start the lower bound of the range of message boards threads 1300 * @param end the upper bound of the range of message boards threads (not inclusive) 1301 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1302 * @return the ordered range of matching message boards threads 1303 * @throws SystemException if a system exception occurred 1304 */ 1305 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1306 long categoryId, double priority, int start, int end, 1307 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1308 throws com.liferay.portal.kernel.exception.SystemException { 1309 return getPersistence() 1310 .findByC_P(categoryId, priority, start, end, 1311 orderByComparator); 1312 } 1313 1314 /** 1315 * Returns the first message boards thread in the ordered set where categoryId = ? and priority = ?. 1316 * 1317 * @param categoryId the category ID 1318 * @param priority the priority 1319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1320 * @return the first matching message boards thread 1321 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1322 * @throws SystemException if a system exception occurred 1323 */ 1324 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First( 1325 long categoryId, double priority, 1326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1327 throws com.liferay.portal.kernel.exception.SystemException, 1328 com.liferay.portlet.messageboards.NoSuchThreadException { 1329 return getPersistence() 1330 .findByC_P_First(categoryId, priority, orderByComparator); 1331 } 1332 1333 /** 1334 * Returns the first message boards thread in the ordered set where categoryId = ? and priority = ?. 1335 * 1336 * @param categoryId the category ID 1337 * @param priority the priority 1338 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1339 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1340 * @throws SystemException if a system exception occurred 1341 */ 1342 public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_First( 1343 long categoryId, double priority, 1344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1345 throws com.liferay.portal.kernel.exception.SystemException { 1346 return getPersistence() 1347 .fetchByC_P_First(categoryId, priority, orderByComparator); 1348 } 1349 1350 /** 1351 * Returns the last message boards thread in the ordered set where categoryId = ? and priority = ?. 1352 * 1353 * @param categoryId the category ID 1354 * @param priority the priority 1355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1356 * @return the last matching message boards thread 1357 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1358 * @throws SystemException if a system exception occurred 1359 */ 1360 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last( 1361 long categoryId, double priority, 1362 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1363 throws com.liferay.portal.kernel.exception.SystemException, 1364 com.liferay.portlet.messageboards.NoSuchThreadException { 1365 return getPersistence() 1366 .findByC_P_Last(categoryId, priority, orderByComparator); 1367 } 1368 1369 /** 1370 * Returns the last message boards thread in the ordered set where categoryId = ? and priority = ?. 1371 * 1372 * @param categoryId the category ID 1373 * @param priority the priority 1374 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1375 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1376 * @throws SystemException if a system exception occurred 1377 */ 1378 public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_Last( 1379 long categoryId, double priority, 1380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1381 throws com.liferay.portal.kernel.exception.SystemException { 1382 return getPersistence() 1383 .fetchByC_P_Last(categoryId, priority, orderByComparator); 1384 } 1385 1386 /** 1387 * Returns the message boards threads before and after the current message boards thread in the ordered set where categoryId = ? and priority = ?. 1388 * 1389 * @param threadId the primary key of the current message boards thread 1390 * @param categoryId the category ID 1391 * @param priority the priority 1392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1393 * @return the previous, current, and next message boards thread 1394 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1395 * @throws SystemException if a system exception occurred 1396 */ 1397 public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext( 1398 long threadId, long categoryId, double priority, 1399 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1400 throws com.liferay.portal.kernel.exception.SystemException, 1401 com.liferay.portlet.messageboards.NoSuchThreadException { 1402 return getPersistence() 1403 .findByC_P_PrevAndNext(threadId, categoryId, priority, 1404 orderByComparator); 1405 } 1406 1407 /** 1408 * Returns all the message boards threads where lastPostDate = ? and priority = ?. 1409 * 1410 * @param lastPostDate the last post date 1411 * @param priority the priority 1412 * @return the matching message boards threads 1413 * @throws SystemException if a system exception occurred 1414 */ 1415 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 1416 java.util.Date lastPostDate, double priority) 1417 throws com.liferay.portal.kernel.exception.SystemException { 1418 return getPersistence().findByL_P(lastPostDate, priority); 1419 } 1420 1421 /** 1422 * Returns a range of all the message boards threads where lastPostDate = ? and priority = ?. 1423 * 1424 * <p> 1425 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1426 * </p> 1427 * 1428 * @param lastPostDate the last post date 1429 * @param priority the priority 1430 * @param start the lower bound of the range of message boards threads 1431 * @param end the upper bound of the range of message boards threads (not inclusive) 1432 * @return the range of matching message boards threads 1433 * @throws SystemException if a system exception occurred 1434 */ 1435 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 1436 java.util.Date lastPostDate, double priority, int start, int end) 1437 throws com.liferay.portal.kernel.exception.SystemException { 1438 return getPersistence().findByL_P(lastPostDate, priority, start, end); 1439 } 1440 1441 /** 1442 * Returns an ordered range of all the message boards threads where lastPostDate = ? and priority = ?. 1443 * 1444 * <p> 1445 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1446 * </p> 1447 * 1448 * @param lastPostDate the last post date 1449 * @param priority the priority 1450 * @param start the lower bound of the range of message boards threads 1451 * @param end the upper bound of the range of message boards threads (not inclusive) 1452 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1453 * @return the ordered range of matching message boards threads 1454 * @throws SystemException if a system exception occurred 1455 */ 1456 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 1457 java.util.Date lastPostDate, double priority, int start, int end, 1458 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1459 throws com.liferay.portal.kernel.exception.SystemException { 1460 return getPersistence() 1461 .findByL_P(lastPostDate, priority, start, end, 1462 orderByComparator); 1463 } 1464 1465 /** 1466 * Returns the first message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1467 * 1468 * @param lastPostDate the last post date 1469 * @param priority the priority 1470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1471 * @return the first matching message boards thread 1472 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_First( 1476 java.util.Date lastPostDate, double priority, 1477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1478 throws com.liferay.portal.kernel.exception.SystemException, 1479 com.liferay.portlet.messageboards.NoSuchThreadException { 1480 return getPersistence() 1481 .findByL_P_First(lastPostDate, priority, orderByComparator); 1482 } 1483 1484 /** 1485 * Returns the first message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1486 * 1487 * @param lastPostDate the last post date 1488 * @param priority the priority 1489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1490 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1491 * @throws SystemException if a system exception occurred 1492 */ 1493 public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_First( 1494 java.util.Date lastPostDate, double priority, 1495 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1496 throws com.liferay.portal.kernel.exception.SystemException { 1497 return getPersistence() 1498 .fetchByL_P_First(lastPostDate, priority, orderByComparator); 1499 } 1500 1501 /** 1502 * Returns the last message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1503 * 1504 * @param lastPostDate the last post date 1505 * @param priority the priority 1506 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1507 * @return the last matching message boards thread 1508 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1509 * @throws SystemException if a system exception occurred 1510 */ 1511 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_Last( 1512 java.util.Date lastPostDate, double priority, 1513 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1514 throws com.liferay.portal.kernel.exception.SystemException, 1515 com.liferay.portlet.messageboards.NoSuchThreadException { 1516 return getPersistence() 1517 .findByL_P_Last(lastPostDate, priority, orderByComparator); 1518 } 1519 1520 /** 1521 * Returns the last message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1522 * 1523 * @param lastPostDate the last post date 1524 * @param priority the priority 1525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1526 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1527 * @throws SystemException if a system exception occurred 1528 */ 1529 public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_Last( 1530 java.util.Date lastPostDate, double priority, 1531 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1532 throws com.liferay.portal.kernel.exception.SystemException { 1533 return getPersistence() 1534 .fetchByL_P_Last(lastPostDate, priority, orderByComparator); 1535 } 1536 1537 /** 1538 * Returns the message boards threads before and after the current message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1539 * 1540 * @param threadId the primary key of the current message boards thread 1541 * @param lastPostDate the last post date 1542 * @param priority the priority 1543 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1544 * @return the previous, current, and next message boards thread 1545 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1546 * @throws SystemException if a system exception occurred 1547 */ 1548 public static com.liferay.portlet.messageboards.model.MBThread[] findByL_P_PrevAndNext( 1549 long threadId, java.util.Date lastPostDate, double priority, 1550 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1551 throws com.liferay.portal.kernel.exception.SystemException, 1552 com.liferay.portlet.messageboards.NoSuchThreadException { 1553 return getPersistence() 1554 .findByL_P_PrevAndNext(threadId, lastPostDate, priority, 1555 orderByComparator); 1556 } 1557 1558 /** 1559 * Returns all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1560 * 1561 * @param groupId the group ID 1562 * @param categoryId the category ID 1563 * @param lastPostDate the last post date 1564 * @return the matching message boards threads 1565 * @throws SystemException if a system exception occurred 1566 */ 1567 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1568 long groupId, long categoryId, java.util.Date lastPostDate) 1569 throws com.liferay.portal.kernel.exception.SystemException { 1570 return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate); 1571 } 1572 1573 /** 1574 * Returns a range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1575 * 1576 * <p> 1577 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1578 * </p> 1579 * 1580 * @param groupId the group ID 1581 * @param categoryId the category ID 1582 * @param lastPostDate the last post date 1583 * @param start the lower bound of the range of message boards threads 1584 * @param end the upper bound of the range of message boards threads (not inclusive) 1585 * @return the range of matching message boards threads 1586 * @throws SystemException if a system exception occurred 1587 */ 1588 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1589 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1590 int end) throws com.liferay.portal.kernel.exception.SystemException { 1591 return getPersistence() 1592 .findByG_C_L(groupId, categoryId, lastPostDate, start, end); 1593 } 1594 1595 /** 1596 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1597 * 1598 * <p> 1599 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1600 * </p> 1601 * 1602 * @param groupId the group ID 1603 * @param categoryId the category ID 1604 * @param lastPostDate the last post date 1605 * @param start the lower bound of the range of message boards threads 1606 * @param end the upper bound of the range of message boards threads (not inclusive) 1607 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1608 * @return the ordered range of matching message boards threads 1609 * @throws SystemException if a system exception occurred 1610 */ 1611 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1612 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1613 int end, 1614 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1615 throws com.liferay.portal.kernel.exception.SystemException { 1616 return getPersistence() 1617 .findByG_C_L(groupId, categoryId, lastPostDate, start, end, 1618 orderByComparator); 1619 } 1620 1621 /** 1622 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1623 * 1624 * @param groupId the group ID 1625 * @param categoryId the category ID 1626 * @param lastPostDate the last post date 1627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1628 * @return the first matching message boards thread 1629 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1630 * @throws SystemException if a system exception occurred 1631 */ 1632 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First( 1633 long groupId, long categoryId, java.util.Date lastPostDate, 1634 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1635 throws com.liferay.portal.kernel.exception.SystemException, 1636 com.liferay.portlet.messageboards.NoSuchThreadException { 1637 return getPersistence() 1638 .findByG_C_L_First(groupId, categoryId, lastPostDate, 1639 orderByComparator); 1640 } 1641 1642 /** 1643 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1644 * 1645 * @param groupId the group ID 1646 * @param categoryId the category ID 1647 * @param lastPostDate the last post date 1648 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1649 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1650 * @throws SystemException if a system exception occurred 1651 */ 1652 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_First( 1653 long groupId, long categoryId, java.util.Date lastPostDate, 1654 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1655 throws com.liferay.portal.kernel.exception.SystemException { 1656 return getPersistence() 1657 .fetchByG_C_L_First(groupId, categoryId, lastPostDate, 1658 orderByComparator); 1659 } 1660 1661 /** 1662 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1663 * 1664 * @param groupId the group ID 1665 * @param categoryId the category ID 1666 * @param lastPostDate the last post date 1667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1668 * @return the last matching message boards thread 1669 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1670 * @throws SystemException if a system exception occurred 1671 */ 1672 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last( 1673 long groupId, long categoryId, java.util.Date lastPostDate, 1674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1675 throws com.liferay.portal.kernel.exception.SystemException, 1676 com.liferay.portlet.messageboards.NoSuchThreadException { 1677 return getPersistence() 1678 .findByG_C_L_Last(groupId, categoryId, lastPostDate, 1679 orderByComparator); 1680 } 1681 1682 /** 1683 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1684 * 1685 * @param groupId the group ID 1686 * @param categoryId the category ID 1687 * @param lastPostDate the last post date 1688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1689 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1690 * @throws SystemException if a system exception occurred 1691 */ 1692 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_Last( 1693 long groupId, long categoryId, java.util.Date lastPostDate, 1694 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1695 throws com.liferay.portal.kernel.exception.SystemException { 1696 return getPersistence() 1697 .fetchByG_C_L_Last(groupId, categoryId, lastPostDate, 1698 orderByComparator); 1699 } 1700 1701 /** 1702 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1703 * 1704 * @param threadId the primary key of the current message boards thread 1705 * @param groupId the group ID 1706 * @param categoryId the category ID 1707 * @param lastPostDate the last post date 1708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1709 * @return the previous, current, and next message boards thread 1710 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1711 * @throws SystemException if a system exception occurred 1712 */ 1713 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext( 1714 long threadId, long groupId, long categoryId, 1715 java.util.Date lastPostDate, 1716 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1717 throws com.liferay.portal.kernel.exception.SystemException, 1718 com.liferay.portlet.messageboards.NoSuchThreadException { 1719 return getPersistence() 1720 .findByG_C_L_PrevAndNext(threadId, groupId, categoryId, 1721 lastPostDate, orderByComparator); 1722 } 1723 1724 /** 1725 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 1726 * 1727 * @param groupId the group ID 1728 * @param categoryId the category ID 1729 * @param lastPostDate the last post date 1730 * @return the matching message boards threads that the user has permission to view 1731 * @throws SystemException if a system exception occurred 1732 */ 1733 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 1734 long groupId, long categoryId, java.util.Date lastPostDate) 1735 throws com.liferay.portal.kernel.exception.SystemException { 1736 return getPersistence() 1737 .filterFindByG_C_L(groupId, categoryId, lastPostDate); 1738 } 1739 1740 /** 1741 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 1742 * 1743 * <p> 1744 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1745 * </p> 1746 * 1747 * @param groupId the group ID 1748 * @param categoryId the category ID 1749 * @param lastPostDate the last post date 1750 * @param start the lower bound of the range of message boards threads 1751 * @param end the upper bound of the range of message boards threads (not inclusive) 1752 * @return the range of matching message boards threads that the user has permission to view 1753 * @throws SystemException if a system exception occurred 1754 */ 1755 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 1756 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1757 int end) throws com.liferay.portal.kernel.exception.SystemException { 1758 return getPersistence() 1759 .filterFindByG_C_L(groupId, categoryId, lastPostDate, start, 1760 end); 1761 } 1762 1763 /** 1764 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ? and lastPostDate = ?. 1765 * 1766 * <p> 1767 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1768 * </p> 1769 * 1770 * @param groupId the group ID 1771 * @param categoryId the category ID 1772 * @param lastPostDate the last post date 1773 * @param start the lower bound of the range of message boards threads 1774 * @param end the upper bound of the range of message boards threads (not inclusive) 1775 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1776 * @return the ordered range of matching message boards threads that the user has permission to view 1777 * @throws SystemException if a system exception occurred 1778 */ 1779 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 1780 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1781 int end, 1782 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1783 throws com.liferay.portal.kernel.exception.SystemException { 1784 return getPersistence() 1785 .filterFindByG_C_L(groupId, categoryId, lastPostDate, start, 1786 end, orderByComparator); 1787 } 1788 1789 /** 1790 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 1791 * 1792 * @param threadId the primary key of the current message boards thread 1793 * @param groupId the group ID 1794 * @param categoryId the category ID 1795 * @param lastPostDate the last post date 1796 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1797 * @return the previous, current, and next message boards thread 1798 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1799 * @throws SystemException if a system exception occurred 1800 */ 1801 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_L_PrevAndNext( 1802 long threadId, long groupId, long categoryId, 1803 java.util.Date lastPostDate, 1804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1805 throws com.liferay.portal.kernel.exception.SystemException, 1806 com.liferay.portlet.messageboards.NoSuchThreadException { 1807 return getPersistence() 1808 .filterFindByG_C_L_PrevAndNext(threadId, groupId, 1809 categoryId, lastPostDate, orderByComparator); 1810 } 1811 1812 /** 1813 * Returns all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1814 * 1815 * @param groupId the group ID 1816 * @param categoryId the category ID 1817 * @param status the status 1818 * @return the matching message boards threads 1819 * @throws SystemException if a system exception occurred 1820 */ 1821 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1822 long groupId, long categoryId, int status) 1823 throws com.liferay.portal.kernel.exception.SystemException { 1824 return getPersistence().findByG_C_S(groupId, categoryId, status); 1825 } 1826 1827 /** 1828 * Returns a range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1829 * 1830 * <p> 1831 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1832 * </p> 1833 * 1834 * @param groupId the group ID 1835 * @param categoryId the category ID 1836 * @param status the status 1837 * @param start the lower bound of the range of message boards threads 1838 * @param end the upper bound of the range of message boards threads (not inclusive) 1839 * @return the range of matching message boards threads 1840 * @throws SystemException if a system exception occurred 1841 */ 1842 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1843 long groupId, long categoryId, int status, int start, int end) 1844 throws com.liferay.portal.kernel.exception.SystemException { 1845 return getPersistence() 1846 .findByG_C_S(groupId, categoryId, status, start, end); 1847 } 1848 1849 /** 1850 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1851 * 1852 * <p> 1853 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1854 * </p> 1855 * 1856 * @param groupId the group ID 1857 * @param categoryId the category ID 1858 * @param status the status 1859 * @param start the lower bound of the range of message boards threads 1860 * @param end the upper bound of the range of message boards threads (not inclusive) 1861 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1862 * @return the ordered range of matching message boards threads 1863 * @throws SystemException if a system exception occurred 1864 */ 1865 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1866 long groupId, long categoryId, int status, int start, int end, 1867 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1868 throws com.liferay.portal.kernel.exception.SystemException { 1869 return getPersistence() 1870 .findByG_C_S(groupId, categoryId, status, start, end, 1871 orderByComparator); 1872 } 1873 1874 /** 1875 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1876 * 1877 * @param groupId the group ID 1878 * @param categoryId the category ID 1879 * @param status the status 1880 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1881 * @return the first matching message boards thread 1882 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1883 * @throws SystemException if a system exception occurred 1884 */ 1885 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First( 1886 long groupId, long categoryId, int status, 1887 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1888 throws com.liferay.portal.kernel.exception.SystemException, 1889 com.liferay.portlet.messageboards.NoSuchThreadException { 1890 return getPersistence() 1891 .findByG_C_S_First(groupId, categoryId, status, 1892 orderByComparator); 1893 } 1894 1895 /** 1896 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1897 * 1898 * @param groupId the group ID 1899 * @param categoryId the category ID 1900 * @param status the status 1901 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1902 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1903 * @throws SystemException if a system exception occurred 1904 */ 1905 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_First( 1906 long groupId, long categoryId, int status, 1907 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1908 throws com.liferay.portal.kernel.exception.SystemException { 1909 return getPersistence() 1910 .fetchByG_C_S_First(groupId, categoryId, status, 1911 orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1916 * 1917 * @param groupId the group ID 1918 * @param categoryId the category ID 1919 * @param status the status 1920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1921 * @return the last matching message boards thread 1922 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1923 * @throws SystemException if a system exception occurred 1924 */ 1925 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last( 1926 long groupId, long categoryId, int status, 1927 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1928 throws com.liferay.portal.kernel.exception.SystemException, 1929 com.liferay.portlet.messageboards.NoSuchThreadException { 1930 return getPersistence() 1931 .findByG_C_S_Last(groupId, categoryId, status, 1932 orderByComparator); 1933 } 1934 1935 /** 1936 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1937 * 1938 * @param groupId the group ID 1939 * @param categoryId the category ID 1940 * @param status the status 1941 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1942 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1943 * @throws SystemException if a system exception occurred 1944 */ 1945 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_Last( 1946 long groupId, long categoryId, int status, 1947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1948 throws com.liferay.portal.kernel.exception.SystemException { 1949 return getPersistence() 1950 .fetchByG_C_S_Last(groupId, categoryId, status, 1951 orderByComparator); 1952 } 1953 1954 /** 1955 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1956 * 1957 * @param threadId the primary key of the current message boards thread 1958 * @param groupId the group ID 1959 * @param categoryId the category ID 1960 * @param status the status 1961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1962 * @return the previous, current, and next message boards thread 1963 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1964 * @throws SystemException if a system exception occurred 1965 */ 1966 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext( 1967 long threadId, long groupId, long categoryId, int status, 1968 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1969 throws com.liferay.portal.kernel.exception.SystemException, 1970 com.liferay.portlet.messageboards.NoSuchThreadException { 1971 return getPersistence() 1972 .findByG_C_S_PrevAndNext(threadId, groupId, categoryId, 1973 status, orderByComparator); 1974 } 1975 1976 /** 1977 * Returns all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1978 * 1979 * <p> 1980 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1981 * </p> 1982 * 1983 * @param groupId the group ID 1984 * @param categoryIds the category IDs 1985 * @param status the status 1986 * @return the matching message boards threads 1987 * @throws SystemException if a system exception occurred 1988 */ 1989 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1990 long groupId, long[] categoryIds, int status) 1991 throws com.liferay.portal.kernel.exception.SystemException { 1992 return getPersistence().findByG_C_S(groupId, categoryIds, status); 1993 } 1994 1995 /** 1996 * Returns a range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1997 * 1998 * <p> 1999 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2000 * </p> 2001 * 2002 * @param groupId the group ID 2003 * @param categoryIds the category IDs 2004 * @param status the status 2005 * @param start the lower bound of the range of message boards threads 2006 * @param end the upper bound of the range of message boards threads (not inclusive) 2007 * @return the range of matching message boards threads 2008 * @throws SystemException if a system exception occurred 2009 */ 2010 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2011 long groupId, long[] categoryIds, int status, int start, int end) 2012 throws com.liferay.portal.kernel.exception.SystemException { 2013 return getPersistence() 2014 .findByG_C_S(groupId, categoryIds, status, start, end); 2015 } 2016 2017 /** 2018 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 2019 * 2020 * <p> 2021 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2022 * </p> 2023 * 2024 * @param groupId the group ID 2025 * @param categoryIds the category IDs 2026 * @param status the status 2027 * @param start the lower bound of the range of message boards threads 2028 * @param end the upper bound of the range of message boards threads (not inclusive) 2029 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2030 * @return the ordered range of matching message boards threads 2031 * @throws SystemException if a system exception occurred 2032 */ 2033 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2034 long groupId, long[] categoryIds, int status, int start, int end, 2035 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2036 throws com.liferay.portal.kernel.exception.SystemException { 2037 return getPersistence() 2038 .findByG_C_S(groupId, categoryIds, status, start, end, 2039 orderByComparator); 2040 } 2041 2042 /** 2043 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2044 * 2045 * @param groupId the group ID 2046 * @param categoryId the category ID 2047 * @param status the status 2048 * @return the matching message boards threads that the user has permission to view 2049 * @throws SystemException if a system exception occurred 2050 */ 2051 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2052 long groupId, long categoryId, int status) 2053 throws com.liferay.portal.kernel.exception.SystemException { 2054 return getPersistence().filterFindByG_C_S(groupId, categoryId, status); 2055 } 2056 2057 /** 2058 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2059 * 2060 * <p> 2061 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2062 * </p> 2063 * 2064 * @param groupId the group ID 2065 * @param categoryId the category ID 2066 * @param status the status 2067 * @param start the lower bound of the range of message boards threads 2068 * @param end the upper bound of the range of message boards threads (not inclusive) 2069 * @return the range of matching message boards threads that the user has permission to view 2070 * @throws SystemException if a system exception occurred 2071 */ 2072 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2073 long groupId, long categoryId, int status, int start, int end) 2074 throws com.liferay.portal.kernel.exception.SystemException { 2075 return getPersistence() 2076 .filterFindByG_C_S(groupId, categoryId, status, start, end); 2077 } 2078 2079 /** 2080 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ? and status = ?. 2081 * 2082 * <p> 2083 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2084 * </p> 2085 * 2086 * @param groupId the group ID 2087 * @param categoryId the category ID 2088 * @param status the status 2089 * @param start the lower bound of the range of message boards threads 2090 * @param end the upper bound of the range of message boards threads (not inclusive) 2091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2092 * @return the ordered range of matching message boards threads that the user has permission to view 2093 * @throws SystemException if a system exception occurred 2094 */ 2095 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2096 long groupId, long categoryId, int status, int start, int end, 2097 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2098 throws com.liferay.portal.kernel.exception.SystemException { 2099 return getPersistence() 2100 .filterFindByG_C_S(groupId, categoryId, status, start, end, 2101 orderByComparator); 2102 } 2103 2104 /** 2105 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2106 * 2107 * @param threadId the primary key of the current message boards thread 2108 * @param groupId the group ID 2109 * @param categoryId the category ID 2110 * @param status the status 2111 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2112 * @return the previous, current, and next message boards thread 2113 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2114 * @throws SystemException if a system exception occurred 2115 */ 2116 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_S_PrevAndNext( 2117 long threadId, long groupId, long categoryId, int status, 2118 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2119 throws com.liferay.portal.kernel.exception.SystemException, 2120 com.liferay.portlet.messageboards.NoSuchThreadException { 2121 return getPersistence() 2122 .filterFindByG_C_S_PrevAndNext(threadId, groupId, 2123 categoryId, status, orderByComparator); 2124 } 2125 2126 /** 2127 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2128 * 2129 * @param groupId the group ID 2130 * @param categoryIds the category IDs 2131 * @param status the status 2132 * @return the matching message boards threads that the user has permission to view 2133 * @throws SystemException if a system exception occurred 2134 */ 2135 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2136 long groupId, long[] categoryIds, int status) 2137 throws com.liferay.portal.kernel.exception.SystemException { 2138 return getPersistence().filterFindByG_C_S(groupId, categoryIds, status); 2139 } 2140 2141 /** 2142 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2143 * 2144 * <p> 2145 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2146 * </p> 2147 * 2148 * @param groupId the group ID 2149 * @param categoryIds the category IDs 2150 * @param status the status 2151 * @param start the lower bound of the range of message boards threads 2152 * @param end the upper bound of the range of message boards threads (not inclusive) 2153 * @return the range of matching message boards threads that the user has permission to view 2154 * @throws SystemException if a system exception occurred 2155 */ 2156 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2157 long groupId, long[] categoryIds, int status, int start, int end) 2158 throws com.liferay.portal.kernel.exception.SystemException { 2159 return getPersistence() 2160 .filterFindByG_C_S(groupId, categoryIds, status, start, end); 2161 } 2162 2163 /** 2164 * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2165 * 2166 * <p> 2167 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2168 * </p> 2169 * 2170 * @param groupId the group ID 2171 * @param categoryIds the category IDs 2172 * @param status the status 2173 * @param start the lower bound of the range of message boards threads 2174 * @param end the upper bound of the range of message boards threads (not inclusive) 2175 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2176 * @return the ordered range of matching message boards threads that the user has permission to view 2177 * @throws SystemException if a system exception occurred 2178 */ 2179 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2180 long groupId, long[] categoryIds, int status, int start, int end, 2181 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2182 throws com.liferay.portal.kernel.exception.SystemException { 2183 return getPersistence() 2184 .filterFindByG_C_S(groupId, categoryIds, status, start, end, 2185 orderByComparator); 2186 } 2187 2188 /** 2189 * Returns all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 2190 * 2191 * @param groupId the group ID 2192 * @param categoryId the category ID 2193 * @param status the status 2194 * @return the matching message boards threads 2195 * @throws SystemException if a system exception occurred 2196 */ 2197 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 2198 long groupId, long categoryId, int status) 2199 throws com.liferay.portal.kernel.exception.SystemException { 2200 return getPersistence().findByG_NotC_S(groupId, categoryId, status); 2201 } 2202 2203 /** 2204 * Returns a range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 2205 * 2206 * <p> 2207 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2208 * </p> 2209 * 2210 * @param groupId the group ID 2211 * @param categoryId the category ID 2212 * @param status the status 2213 * @param start the lower bound of the range of message boards threads 2214 * @param end the upper bound of the range of message boards threads (not inclusive) 2215 * @return the range of matching message boards threads 2216 * @throws SystemException if a system exception occurred 2217 */ 2218 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 2219 long groupId, long categoryId, int status, int start, int end) 2220 throws com.liferay.portal.kernel.exception.SystemException { 2221 return getPersistence() 2222 .findByG_NotC_S(groupId, categoryId, status, start, end); 2223 } 2224 2225 /** 2226 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 2227 * 2228 * <p> 2229 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2230 * </p> 2231 * 2232 * @param groupId the group ID 2233 * @param categoryId the category ID 2234 * @param status the status 2235 * @param start the lower bound of the range of message boards threads 2236 * @param end the upper bound of the range of message boards threads (not inclusive) 2237 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2238 * @return the ordered range of matching message boards threads 2239 * @throws SystemException if a system exception occurred 2240 */ 2241 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 2242 long groupId, long categoryId, int status, int start, int end, 2243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2244 throws com.liferay.portal.kernel.exception.SystemException { 2245 return getPersistence() 2246 .findByG_NotC_S(groupId, categoryId, status, start, end, 2247 orderByComparator); 2248 } 2249 2250 /** 2251 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 2252 * 2253 * @param groupId the group ID 2254 * @param categoryId the category ID 2255 * @param status the status 2256 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2257 * @return the first matching message boards thread 2258 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2259 * @throws SystemException if a system exception occurred 2260 */ 2261 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First( 2262 long groupId, long categoryId, int status, 2263 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2264 throws com.liferay.portal.kernel.exception.SystemException, 2265 com.liferay.portlet.messageboards.NoSuchThreadException { 2266 return getPersistence() 2267 .findByG_NotC_S_First(groupId, categoryId, status, 2268 orderByComparator); 2269 } 2270 2271 /** 2272 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 2273 * 2274 * @param groupId the group ID 2275 * @param categoryId the category ID 2276 * @param status the status 2277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2278 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2279 * @throws SystemException if a system exception occurred 2280 */ 2281 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_First( 2282 long groupId, long categoryId, int status, 2283 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2284 throws com.liferay.portal.kernel.exception.SystemException { 2285 return getPersistence() 2286 .fetchByG_NotC_S_First(groupId, categoryId, status, 2287 orderByComparator); 2288 } 2289 2290 /** 2291 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 2292 * 2293 * @param groupId the group ID 2294 * @param categoryId the category ID 2295 * @param status the status 2296 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2297 * @return the last matching message boards thread 2298 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2299 * @throws SystemException if a system exception occurred 2300 */ 2301 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last( 2302 long groupId, long categoryId, int status, 2303 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2304 throws com.liferay.portal.kernel.exception.SystemException, 2305 com.liferay.portlet.messageboards.NoSuchThreadException { 2306 return getPersistence() 2307 .findByG_NotC_S_Last(groupId, categoryId, status, 2308 orderByComparator); 2309 } 2310 2311 /** 2312 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 2313 * 2314 * @param groupId the group ID 2315 * @param categoryId the category ID 2316 * @param status the status 2317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2318 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2319 * @throws SystemException if a system exception occurred 2320 */ 2321 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_Last( 2322 long groupId, long categoryId, int status, 2323 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2324 throws com.liferay.portal.kernel.exception.SystemException { 2325 return getPersistence() 2326 .fetchByG_NotC_S_Last(groupId, categoryId, status, 2327 orderByComparator); 2328 } 2329 2330 /** 2331 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 2332 * 2333 * @param threadId the primary key of the current message boards thread 2334 * @param groupId the group ID 2335 * @param categoryId the category ID 2336 * @param status the status 2337 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2338 * @return the previous, current, and next message boards thread 2339 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2340 * @throws SystemException if a system exception occurred 2341 */ 2342 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext( 2343 long threadId, long groupId, long categoryId, int status, 2344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2345 throws com.liferay.portal.kernel.exception.SystemException, 2346 com.liferay.portlet.messageboards.NoSuchThreadException { 2347 return getPersistence() 2348 .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId, 2349 status, orderByComparator); 2350 } 2351 2352 /** 2353 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 2354 * 2355 * @param groupId the group ID 2356 * @param categoryId the category ID 2357 * @param status the status 2358 * @return the matching message boards threads that the user has permission to view 2359 * @throws SystemException if a system exception occurred 2360 */ 2361 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 2362 long groupId, long categoryId, int status) 2363 throws com.liferay.portal.kernel.exception.SystemException { 2364 return getPersistence().filterFindByG_NotC_S(groupId, categoryId, status); 2365 } 2366 2367 /** 2368 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 2369 * 2370 * <p> 2371 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2372 * </p> 2373 * 2374 * @param groupId the group ID 2375 * @param categoryId the category ID 2376 * @param status the status 2377 * @param start the lower bound of the range of message boards threads 2378 * @param end the upper bound of the range of message boards threads (not inclusive) 2379 * @return the range of matching message boards threads that the user has permission to view 2380 * @throws SystemException if a system exception occurred 2381 */ 2382 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 2383 long groupId, long categoryId, int status, int start, int end) 2384 throws com.liferay.portal.kernel.exception.SystemException { 2385 return getPersistence() 2386 .filterFindByG_NotC_S(groupId, categoryId, status, start, end); 2387 } 2388 2389 /** 2390 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId ≠ ? and status = ?. 2391 * 2392 * <p> 2393 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2394 * </p> 2395 * 2396 * @param groupId the group ID 2397 * @param categoryId the category ID 2398 * @param status the status 2399 * @param start the lower bound of the range of message boards threads 2400 * @param end the upper bound of the range of message boards threads (not inclusive) 2401 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2402 * @return the ordered range of matching message boards threads that the user has permission to view 2403 * @throws SystemException if a system exception occurred 2404 */ 2405 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 2406 long groupId, long categoryId, int status, int start, int end, 2407 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2408 throws com.liferay.portal.kernel.exception.SystemException { 2409 return getPersistence() 2410 .filterFindByG_NotC_S(groupId, categoryId, status, start, 2411 end, orderByComparator); 2412 } 2413 2414 /** 2415 * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 2416 * 2417 * @param threadId the primary key of the current message boards thread 2418 * @param groupId the group ID 2419 * @param categoryId the category ID 2420 * @param status the status 2421 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2422 * @return the previous, current, and next message boards thread 2423 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2424 * @throws SystemException if a system exception occurred 2425 */ 2426 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_S_PrevAndNext( 2427 long threadId, long groupId, long categoryId, int status, 2428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2429 throws com.liferay.portal.kernel.exception.SystemException, 2430 com.liferay.portlet.messageboards.NoSuchThreadException { 2431 return getPersistence() 2432 .filterFindByG_NotC_S_PrevAndNext(threadId, groupId, 2433 categoryId, status, orderByComparator); 2434 } 2435 2436 /** 2437 * Returns all the message boards threads. 2438 * 2439 * @return the message boards threads 2440 * @throws SystemException if a system exception occurred 2441 */ 2442 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll() 2443 throws com.liferay.portal.kernel.exception.SystemException { 2444 return getPersistence().findAll(); 2445 } 2446 2447 /** 2448 * Returns a range of all the message boards threads. 2449 * 2450 * <p> 2451 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2452 * </p> 2453 * 2454 * @param start the lower bound of the range of message boards threads 2455 * @param end the upper bound of the range of message boards threads (not inclusive) 2456 * @return the range of message boards threads 2457 * @throws SystemException if a system exception occurred 2458 */ 2459 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 2460 int start, int end) 2461 throws com.liferay.portal.kernel.exception.SystemException { 2462 return getPersistence().findAll(start, end); 2463 } 2464 2465 /** 2466 * Returns an ordered range of all the message boards threads. 2467 * 2468 * <p> 2469 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2470 * </p> 2471 * 2472 * @param start the lower bound of the range of message boards threads 2473 * @param end the upper bound of the range of message boards threads (not inclusive) 2474 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2475 * @return the ordered range of message boards threads 2476 * @throws SystemException if a system exception occurred 2477 */ 2478 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 2479 int start, int end, 2480 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2481 throws com.liferay.portal.kernel.exception.SystemException { 2482 return getPersistence().findAll(start, end, orderByComparator); 2483 } 2484 2485 /** 2486 * Removes all the message boards threads where groupId = ? from the database. 2487 * 2488 * @param groupId the group ID 2489 * @throws SystemException if a system exception occurred 2490 */ 2491 public static void removeByGroupId(long groupId) 2492 throws com.liferay.portal.kernel.exception.SystemException { 2493 getPersistence().removeByGroupId(groupId); 2494 } 2495 2496 /** 2497 * Removes the message boards thread where rootMessageId = ? from the database. 2498 * 2499 * @param rootMessageId the root message ID 2500 * @return the message boards thread that was removed 2501 * @throws SystemException if a system exception occurred 2502 */ 2503 public static com.liferay.portlet.messageboards.model.MBThread removeByRootMessageId( 2504 long rootMessageId) 2505 throws com.liferay.portal.kernel.exception.SystemException, 2506 com.liferay.portlet.messageboards.NoSuchThreadException { 2507 return getPersistence().removeByRootMessageId(rootMessageId); 2508 } 2509 2510 /** 2511 * Removes all the message boards threads where groupId = ? and categoryId = ? from the database. 2512 * 2513 * @param groupId the group ID 2514 * @param categoryId the category ID 2515 * @throws SystemException if a system exception occurred 2516 */ 2517 public static void removeByG_C(long groupId, long categoryId) 2518 throws com.liferay.portal.kernel.exception.SystemException { 2519 getPersistence().removeByG_C(groupId, categoryId); 2520 } 2521 2522 /** 2523 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? from the database. 2524 * 2525 * @param groupId the group ID 2526 * @param categoryId the category ID 2527 * @throws SystemException if a system exception occurred 2528 */ 2529 public static void removeByG_NotC(long groupId, long categoryId) 2530 throws com.liferay.portal.kernel.exception.SystemException { 2531 getPersistence().removeByG_NotC(groupId, categoryId); 2532 } 2533 2534 /** 2535 * Removes all the message boards threads where groupId = ? and status = ? from the database. 2536 * 2537 * @param groupId the group ID 2538 * @param status the status 2539 * @throws SystemException if a system exception occurred 2540 */ 2541 public static void removeByG_S(long groupId, int status) 2542 throws com.liferay.portal.kernel.exception.SystemException { 2543 getPersistence().removeByG_S(groupId, status); 2544 } 2545 2546 /** 2547 * Removes all the message boards threads where categoryId = ? and priority = ? from the database. 2548 * 2549 * @param categoryId the category ID 2550 * @param priority the priority 2551 * @throws SystemException if a system exception occurred 2552 */ 2553 public static void removeByC_P(long categoryId, double priority) 2554 throws com.liferay.portal.kernel.exception.SystemException { 2555 getPersistence().removeByC_P(categoryId, priority); 2556 } 2557 2558 /** 2559 * Removes all the message boards threads where lastPostDate = ? and priority = ? from the database. 2560 * 2561 * @param lastPostDate the last post date 2562 * @param priority the priority 2563 * @throws SystemException if a system exception occurred 2564 */ 2565 public static void removeByL_P(java.util.Date lastPostDate, double priority) 2566 throws com.liferay.portal.kernel.exception.SystemException { 2567 getPersistence().removeByL_P(lastPostDate, priority); 2568 } 2569 2570 /** 2571 * Removes all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ? from the database. 2572 * 2573 * @param groupId the group ID 2574 * @param categoryId the category ID 2575 * @param lastPostDate the last post date 2576 * @throws SystemException if a system exception occurred 2577 */ 2578 public static void removeByG_C_L(long groupId, long categoryId, 2579 java.util.Date lastPostDate) 2580 throws com.liferay.portal.kernel.exception.SystemException { 2581 getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate); 2582 } 2583 2584 /** 2585 * Removes all the message boards threads where groupId = ? and categoryId = ? and status = ? from the database. 2586 * 2587 * @param groupId the group ID 2588 * @param categoryId the category ID 2589 * @param status the status 2590 * @throws SystemException if a system exception occurred 2591 */ 2592 public static void removeByG_C_S(long groupId, long categoryId, int status) 2593 throws com.liferay.portal.kernel.exception.SystemException { 2594 getPersistence().removeByG_C_S(groupId, categoryId, status); 2595 } 2596 2597 /** 2598 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? and status = ? from the database. 2599 * 2600 * @param groupId the group ID 2601 * @param categoryId the category ID 2602 * @param status the status 2603 * @throws SystemException if a system exception occurred 2604 */ 2605 public static void removeByG_NotC_S(long groupId, long categoryId, 2606 int status) throws com.liferay.portal.kernel.exception.SystemException { 2607 getPersistence().removeByG_NotC_S(groupId, categoryId, status); 2608 } 2609 2610 /** 2611 * Removes all the message boards threads from the database. 2612 * 2613 * @throws SystemException if a system exception occurred 2614 */ 2615 public static void removeAll() 2616 throws com.liferay.portal.kernel.exception.SystemException { 2617 getPersistence().removeAll(); 2618 } 2619 2620 /** 2621 * Returns the number of message boards threads where groupId = ?. 2622 * 2623 * @param groupId the group ID 2624 * @return the number of matching message boards threads 2625 * @throws SystemException if a system exception occurred 2626 */ 2627 public static int countByGroupId(long groupId) 2628 throws com.liferay.portal.kernel.exception.SystemException { 2629 return getPersistence().countByGroupId(groupId); 2630 } 2631 2632 /** 2633 * Returns the number of message boards threads that the user has permission to view where groupId = ?. 2634 * 2635 * @param groupId the group ID 2636 * @return the number of matching message boards threads that the user has permission to view 2637 * @throws SystemException if a system exception occurred 2638 */ 2639 public static int filterCountByGroupId(long groupId) 2640 throws com.liferay.portal.kernel.exception.SystemException { 2641 return getPersistence().filterCountByGroupId(groupId); 2642 } 2643 2644 /** 2645 * Returns the number of message boards threads where rootMessageId = ?. 2646 * 2647 * @param rootMessageId the root message ID 2648 * @return the number of matching message boards threads 2649 * @throws SystemException if a system exception occurred 2650 */ 2651 public static int countByRootMessageId(long rootMessageId) 2652 throws com.liferay.portal.kernel.exception.SystemException { 2653 return getPersistence().countByRootMessageId(rootMessageId); 2654 } 2655 2656 /** 2657 * Returns the number of message boards threads where groupId = ? and categoryId = ?. 2658 * 2659 * @param groupId the group ID 2660 * @param categoryId the category ID 2661 * @return the number of matching message boards threads 2662 * @throws SystemException if a system exception occurred 2663 */ 2664 public static int countByG_C(long groupId, long categoryId) 2665 throws com.liferay.portal.kernel.exception.SystemException { 2666 return getPersistence().countByG_C(groupId, categoryId); 2667 } 2668 2669 /** 2670 * Returns the number of message boards threads where groupId = ? and categoryId = any ?. 2671 * 2672 * @param groupId the group ID 2673 * @param categoryIds the category IDs 2674 * @return the number of matching message boards threads 2675 * @throws SystemException if a system exception occurred 2676 */ 2677 public static int countByG_C(long groupId, long[] categoryIds) 2678 throws com.liferay.portal.kernel.exception.SystemException { 2679 return getPersistence().countByG_C(groupId, categoryIds); 2680 } 2681 2682 /** 2683 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 2684 * 2685 * @param groupId the group ID 2686 * @param categoryId the category ID 2687 * @return the number of matching message boards threads that the user has permission to view 2688 * @throws SystemException if a system exception occurred 2689 */ 2690 public static int filterCountByG_C(long groupId, long categoryId) 2691 throws com.liferay.portal.kernel.exception.SystemException { 2692 return getPersistence().filterCountByG_C(groupId, categoryId); 2693 } 2694 2695 /** 2696 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 2697 * 2698 * @param groupId the group ID 2699 * @param categoryIds the category IDs 2700 * @return the number of matching message boards threads that the user has permission to view 2701 * @throws SystemException if a system exception occurred 2702 */ 2703 public static int filterCountByG_C(long groupId, long[] categoryIds) 2704 throws com.liferay.portal.kernel.exception.SystemException { 2705 return getPersistence().filterCountByG_C(groupId, categoryIds); 2706 } 2707 2708 /** 2709 * Returns the number of message boards threads where groupId = ? and categoryId ≠ ?. 2710 * 2711 * @param groupId the group ID 2712 * @param categoryId the category ID 2713 * @return the number of matching message boards threads 2714 * @throws SystemException if a system exception occurred 2715 */ 2716 public static int countByG_NotC(long groupId, long categoryId) 2717 throws com.liferay.portal.kernel.exception.SystemException { 2718 return getPersistence().countByG_NotC(groupId, categoryId); 2719 } 2720 2721 /** 2722 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 2723 * 2724 * @param groupId the group ID 2725 * @param categoryId the category ID 2726 * @return the number of matching message boards threads that the user has permission to view 2727 * @throws SystemException if a system exception occurred 2728 */ 2729 public static int filterCountByG_NotC(long groupId, long categoryId) 2730 throws com.liferay.portal.kernel.exception.SystemException { 2731 return getPersistence().filterCountByG_NotC(groupId, categoryId); 2732 } 2733 2734 /** 2735 * Returns the number of message boards threads where groupId = ? and status = ?. 2736 * 2737 * @param groupId the group ID 2738 * @param status the status 2739 * @return the number of matching message boards threads 2740 * @throws SystemException if a system exception occurred 2741 */ 2742 public static int countByG_S(long groupId, int status) 2743 throws com.liferay.portal.kernel.exception.SystemException { 2744 return getPersistence().countByG_S(groupId, status); 2745 } 2746 2747 /** 2748 * Returns the number of message boards threads that the user has permission to view where groupId = ? and status = ?. 2749 * 2750 * @param groupId the group ID 2751 * @param status the status 2752 * @return the number of matching message boards threads that the user has permission to view 2753 * @throws SystemException if a system exception occurred 2754 */ 2755 public static int filterCountByG_S(long groupId, int status) 2756 throws com.liferay.portal.kernel.exception.SystemException { 2757 return getPersistence().filterCountByG_S(groupId, status); 2758 } 2759 2760 /** 2761 * Returns the number of message boards threads where categoryId = ? and priority = ?. 2762 * 2763 * @param categoryId the category ID 2764 * @param priority the priority 2765 * @return the number of matching message boards threads 2766 * @throws SystemException if a system exception occurred 2767 */ 2768 public static int countByC_P(long categoryId, double priority) 2769 throws com.liferay.portal.kernel.exception.SystemException { 2770 return getPersistence().countByC_P(categoryId, priority); 2771 } 2772 2773 /** 2774 * Returns the number of message boards threads where lastPostDate = ? and priority = ?. 2775 * 2776 * @param lastPostDate the last post date 2777 * @param priority the priority 2778 * @return the number of matching message boards threads 2779 * @throws SystemException if a system exception occurred 2780 */ 2781 public static int countByL_P(java.util.Date lastPostDate, double priority) 2782 throws com.liferay.portal.kernel.exception.SystemException { 2783 return getPersistence().countByL_P(lastPostDate, priority); 2784 } 2785 2786 /** 2787 * Returns the number of message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 2788 * 2789 * @param groupId the group ID 2790 * @param categoryId the category ID 2791 * @param lastPostDate the last post date 2792 * @return the number of matching message boards threads 2793 * @throws SystemException if a system exception occurred 2794 */ 2795 public static int countByG_C_L(long groupId, long categoryId, 2796 java.util.Date lastPostDate) 2797 throws com.liferay.portal.kernel.exception.SystemException { 2798 return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate); 2799 } 2800 2801 /** 2802 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 2803 * 2804 * @param groupId the group ID 2805 * @param categoryId the category ID 2806 * @param lastPostDate the last post date 2807 * @return the number of matching message boards threads that the user has permission to view 2808 * @throws SystemException if a system exception occurred 2809 */ 2810 public static int filterCountByG_C_L(long groupId, long categoryId, 2811 java.util.Date lastPostDate) 2812 throws com.liferay.portal.kernel.exception.SystemException { 2813 return getPersistence() 2814 .filterCountByG_C_L(groupId, categoryId, lastPostDate); 2815 } 2816 2817 /** 2818 * Returns the number of message boards threads where groupId = ? and categoryId = ? and status = ?. 2819 * 2820 * @param groupId the group ID 2821 * @param categoryId the category ID 2822 * @param status the status 2823 * @return the number of matching message boards threads 2824 * @throws SystemException if a system exception occurred 2825 */ 2826 public static int countByG_C_S(long groupId, long categoryId, int status) 2827 throws com.liferay.portal.kernel.exception.SystemException { 2828 return getPersistence().countByG_C_S(groupId, categoryId, status); 2829 } 2830 2831 /** 2832 * Returns the number of message boards threads where groupId = ? and categoryId = any ? and status = ?. 2833 * 2834 * @param groupId the group ID 2835 * @param categoryIds the category IDs 2836 * @param status the status 2837 * @return the number of matching message boards threads 2838 * @throws SystemException if a system exception occurred 2839 */ 2840 public static int countByG_C_S(long groupId, long[] categoryIds, int status) 2841 throws com.liferay.portal.kernel.exception.SystemException { 2842 return getPersistence().countByG_C_S(groupId, categoryIds, status); 2843 } 2844 2845 /** 2846 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2847 * 2848 * @param groupId the group ID 2849 * @param categoryId the category ID 2850 * @param status the status 2851 * @return the number of matching message boards threads that the user has permission to view 2852 * @throws SystemException if a system exception occurred 2853 */ 2854 public static int filterCountByG_C_S(long groupId, long categoryId, 2855 int status) throws com.liferay.portal.kernel.exception.SystemException { 2856 return getPersistence().filterCountByG_C_S(groupId, categoryId, status); 2857 } 2858 2859 /** 2860 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2861 * 2862 * @param groupId the group ID 2863 * @param categoryIds the category IDs 2864 * @param status the status 2865 * @return the number of matching message boards threads that the user has permission to view 2866 * @throws SystemException if a system exception occurred 2867 */ 2868 public static int filterCountByG_C_S(long groupId, long[] categoryIds, 2869 int status) throws com.liferay.portal.kernel.exception.SystemException { 2870 return getPersistence().filterCountByG_C_S(groupId, categoryIds, status); 2871 } 2872 2873 /** 2874 * Returns the number of message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 2875 * 2876 * @param groupId the group ID 2877 * @param categoryId the category ID 2878 * @param status the status 2879 * @return the number of matching message boards threads 2880 * @throws SystemException if a system exception occurred 2881 */ 2882 public static int countByG_NotC_S(long groupId, long categoryId, int status) 2883 throws com.liferay.portal.kernel.exception.SystemException { 2884 return getPersistence().countByG_NotC_S(groupId, categoryId, status); 2885 } 2886 2887 /** 2888 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 2889 * 2890 * @param groupId the group ID 2891 * @param categoryId the category ID 2892 * @param status the status 2893 * @return the number of matching message boards threads that the user has permission to view 2894 * @throws SystemException if a system exception occurred 2895 */ 2896 public static int filterCountByG_NotC_S(long groupId, long categoryId, 2897 int status) throws com.liferay.portal.kernel.exception.SystemException { 2898 return getPersistence() 2899 .filterCountByG_NotC_S(groupId, categoryId, status); 2900 } 2901 2902 /** 2903 * Returns the number of message boards threads. 2904 * 2905 * @return the number of message boards threads 2906 * @throws SystemException if a system exception occurred 2907 */ 2908 public static int countAll() 2909 throws com.liferay.portal.kernel.exception.SystemException { 2910 return getPersistence().countAll(); 2911 } 2912 2913 public static MBThreadPersistence getPersistence() { 2914 if (_persistence == null) { 2915 _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName()); 2916 2917 ReferenceRegistry.registerReference(MBThreadUtil.class, 2918 "_persistence"); 2919 } 2920 2921 return _persistence; 2922 } 2923 2924 /** 2925 * @deprecated 2926 */ 2927 public void setPersistence(MBThreadPersistence persistence) { 2928 } 2929 2930 private static MBThreadPersistence _persistence; 2931 }