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