001 /** 002 * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.service.ServiceContext; 022 023 import com.liferay.portlet.messageboards.model.MBThread; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the message boards thread service. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see MBThreadPersistence 036 * @see MBThreadPersistenceImpl 037 * @generated 038 */ 039 public class MBThreadUtil { 040 /** 041 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 042 */ 043 public static void clearCache() { 044 getPersistence().clearCache(); 045 } 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 049 */ 050 public static void clearCache(MBThread mbThread) { 051 getPersistence().clearCache(mbThread); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 056 */ 057 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 058 throws SystemException { 059 return getPersistence().countWithDynamicQuery(dynamicQuery); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 064 */ 065 public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery) 066 throws SystemException { 067 return getPersistence().findWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 072 */ 073 public static List<MBThread> findWithDynamicQuery( 074 DynamicQuery dynamicQuery, int start, int end) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 081 */ 082 public static List<MBThread> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end, 084 OrderByComparator orderByComparator) throws SystemException { 085 return getPersistence() 086 .findWithDynamicQuery(dynamicQuery, start, end, 087 orderByComparator); 088 } 089 090 /** 091 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 092 */ 093 public static MBThread remove(MBThread mbThread) throws SystemException { 094 return getPersistence().remove(mbThread); 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 to cache 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 to cache 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. 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 to remove 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 * Finds 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 to find 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 * Finds 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 to find 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 * Finds all the message boards threads where groupId = ?. 195 * 196 * @param groupId the group id to search with 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 * Finds 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 to search with 214 * @param start the lower bound of the range of message boards threads to return 215 * @param end the upper bound of the range of message boards threads to return (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 * Finds 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 to search with 233 * @param start the lower bound of the range of message boards threads to return 234 * @param end the upper bound of the range of message boards threads to return (not inclusive) 235 * @param orderByComparator the comparator to order the results by 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 * Finds the first message boards thread in the ordered set where groupId = ?. 249 * 250 * <p> 251 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 252 * </p> 253 * 254 * @param groupId the group id to search with 255 * @param orderByComparator the comparator to order the set by 256 * @return the first matching message boards thread 257 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 258 * @throws SystemException if a system exception occurred 259 */ 260 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First( 261 long groupId, 262 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 263 throws com.liferay.portal.kernel.exception.SystemException, 264 com.liferay.portlet.messageboards.NoSuchThreadException { 265 return getPersistence().findByGroupId_First(groupId, orderByComparator); 266 } 267 268 /** 269 * Finds the last message boards thread in the ordered set where groupId = ?. 270 * 271 * <p> 272 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 273 * </p> 274 * 275 * @param groupId the group id to search with 276 * @param orderByComparator the comparator to order the set by 277 * @return the last matching message boards thread 278 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last( 282 long groupId, 283 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 284 throws com.liferay.portal.kernel.exception.SystemException, 285 com.liferay.portlet.messageboards.NoSuchThreadException { 286 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 287 } 288 289 /** 290 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ?. 291 * 292 * <p> 293 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 294 * </p> 295 * 296 * @param threadId the primary key of the current message boards thread 297 * @param groupId the group id to search with 298 * @param orderByComparator the comparator to order the set by 299 * @return the previous, current, and next message boards thread 300 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 301 * @throws SystemException if a system exception occurred 302 */ 303 public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext( 304 long threadId, long groupId, 305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 306 throws com.liferay.portal.kernel.exception.SystemException, 307 com.liferay.portlet.messageboards.NoSuchThreadException { 308 return getPersistence() 309 .findByGroupId_PrevAndNext(threadId, groupId, 310 orderByComparator); 311 } 312 313 /** 314 * Finds all the message boards threads where groupId = ? and categoryId = ?. 315 * 316 * @param groupId the group id to search with 317 * @param categoryId the category id to search with 318 * @return the matching message boards threads 319 * @throws SystemException if a system exception occurred 320 */ 321 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 322 long groupId, long categoryId) 323 throws com.liferay.portal.kernel.exception.SystemException { 324 return getPersistence().findByG_C(groupId, categoryId); 325 } 326 327 /** 328 * Finds a range of all the message boards threads where groupId = ? and categoryId = ?. 329 * 330 * <p> 331 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 332 * </p> 333 * 334 * @param groupId the group id to search with 335 * @param categoryId the category id to search with 336 * @param start the lower bound of the range of message boards threads to return 337 * @param end the upper bound of the range of message boards threads to return (not inclusive) 338 * @return the range of matching message boards threads 339 * @throws SystemException if a system exception occurred 340 */ 341 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 342 long groupId, long categoryId, int start, int end) 343 throws com.liferay.portal.kernel.exception.SystemException { 344 return getPersistence().findByG_C(groupId, categoryId, start, end); 345 } 346 347 /** 348 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ?. 349 * 350 * <p> 351 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 352 * </p> 353 * 354 * @param groupId the group id to search with 355 * @param categoryId the category id to search with 356 * @param start the lower bound of the range of message boards threads to return 357 * @param end the upper bound of the range of message boards threads to return (not inclusive) 358 * @param orderByComparator the comparator to order the results by 359 * @return the ordered range of matching message boards threads 360 * @throws SystemException if a system exception occurred 361 */ 362 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 363 long groupId, long categoryId, int start, int end, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence() 367 .findByG_C(groupId, categoryId, start, end, orderByComparator); 368 } 369 370 /** 371 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 372 * 373 * <p> 374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 375 * </p> 376 * 377 * @param groupId the group id to search with 378 * @param categoryId the category id to search with 379 * @param orderByComparator the comparator to order the set by 380 * @return the first matching message boards thread 381 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 382 * @throws SystemException if a system exception occurred 383 */ 384 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First( 385 long groupId, long categoryId, 386 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 387 throws com.liferay.portal.kernel.exception.SystemException, 388 com.liferay.portlet.messageboards.NoSuchThreadException { 389 return getPersistence() 390 .findByG_C_First(groupId, categoryId, orderByComparator); 391 } 392 393 /** 394 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 395 * 396 * <p> 397 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 398 * </p> 399 * 400 * @param groupId the group id to search with 401 * @param categoryId the category id to search with 402 * @param orderByComparator the comparator to order the set by 403 * @return the last matching message boards thread 404 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 405 * @throws SystemException if a system exception occurred 406 */ 407 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last( 408 long groupId, long categoryId, 409 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 410 throws com.liferay.portal.kernel.exception.SystemException, 411 com.liferay.portlet.messageboards.NoSuchThreadException { 412 return getPersistence() 413 .findByG_C_Last(groupId, categoryId, orderByComparator); 414 } 415 416 /** 417 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ?. 418 * 419 * <p> 420 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 421 * </p> 422 * 423 * @param threadId the primary key of the current message boards thread 424 * @param groupId the group id to search with 425 * @param categoryId the category id to search with 426 * @param orderByComparator the comparator to order the set by 427 * @return the previous, current, and next message boards thread 428 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 429 * @throws SystemException if a system exception occurred 430 */ 431 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext( 432 long threadId, long groupId, long categoryId, 433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 434 throws com.liferay.portal.kernel.exception.SystemException, 435 com.liferay.portlet.messageboards.NoSuchThreadException { 436 return getPersistence() 437 .findByG_C_PrevAndNext(threadId, groupId, categoryId, 438 orderByComparator); 439 } 440 441 /** 442 * Finds all the message boards threads where groupId = ? and categoryId = any ?. 443 * 444 * <p> 445 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 446 * </p> 447 * 448 * @param groupId the group id to search with 449 * @param categoryIds the category ids to search with 450 * @return the matching message boards threads 451 * @throws SystemException if a system exception occurred 452 */ 453 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 454 long groupId, long[] categoryIds) 455 throws com.liferay.portal.kernel.exception.SystemException { 456 return getPersistence().findByG_C(groupId, categoryIds); 457 } 458 459 /** 460 * Finds a range of all the message boards threads where groupId = ? and categoryId = any ?. 461 * 462 * <p> 463 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 464 * </p> 465 * 466 * @param groupId the group id to search with 467 * @param categoryIds the category ids to search with 468 * @param start the lower bound of the range of message boards threads to return 469 * @param end the upper bound of the range of message boards threads to return (not inclusive) 470 * @return the range of matching message boards threads 471 * @throws SystemException if a system exception occurred 472 */ 473 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 474 long groupId, long[] categoryIds, int start, int end) 475 throws com.liferay.portal.kernel.exception.SystemException { 476 return getPersistence().findByG_C(groupId, categoryIds, start, end); 477 } 478 479 /** 480 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = any ?. 481 * 482 * <p> 483 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 484 * </p> 485 * 486 * @param groupId the group id to search with 487 * @param categoryIds the category ids to search with 488 * @param start the lower bound of the range of message boards threads to return 489 * @param end the upper bound of the range of message boards threads to return (not inclusive) 490 * @param orderByComparator the comparator to order the results by 491 * @return the ordered range of matching message boards threads 492 * @throws SystemException if a system exception occurred 493 */ 494 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 495 long groupId, long[] categoryIds, int start, int end, 496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 497 throws com.liferay.portal.kernel.exception.SystemException { 498 return getPersistence() 499 .findByG_C(groupId, categoryIds, start, end, 500 orderByComparator); 501 } 502 503 /** 504 * Finds all the message boards threads where groupId = ? and categoryId ≠ ?. 505 * 506 * @param groupId the group id to search with 507 * @param categoryId the category id to search with 508 * @return the matching message boards threads 509 * @throws SystemException if a system exception occurred 510 */ 511 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 512 long groupId, long categoryId) 513 throws com.liferay.portal.kernel.exception.SystemException { 514 return getPersistence().findByG_NotC(groupId, categoryId); 515 } 516 517 /** 518 * Finds a range of all the message boards threads where groupId = ? and categoryId ≠ ?. 519 * 520 * <p> 521 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 522 * </p> 523 * 524 * @param groupId the group id to search with 525 * @param categoryId the category id to search with 526 * @param start the lower bound of the range of message boards threads to return 527 * @param end the upper bound of the range of message boards threads to return (not inclusive) 528 * @return the range of matching message boards threads 529 * @throws SystemException if a system exception occurred 530 */ 531 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 532 long groupId, long categoryId, int start, int end) 533 throws com.liferay.portal.kernel.exception.SystemException { 534 return getPersistence().findByG_NotC(groupId, categoryId, start, end); 535 } 536 537 /** 538 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ?. 539 * 540 * <p> 541 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 542 * </p> 543 * 544 * @param groupId the group id to search with 545 * @param categoryId the category id to search with 546 * @param start the lower bound of the range of message boards threads to return 547 * @param end the upper bound of the range of message boards threads to return (not inclusive) 548 * @param orderByComparator the comparator to order the results by 549 * @return the ordered range of matching message boards threads 550 * @throws SystemException if a system exception occurred 551 */ 552 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 553 long groupId, long categoryId, int start, int end, 554 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 555 throws com.liferay.portal.kernel.exception.SystemException { 556 return getPersistence() 557 .findByG_NotC(groupId, categoryId, start, end, 558 orderByComparator); 559 } 560 561 /** 562 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 563 * 564 * <p> 565 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 566 * </p> 567 * 568 * @param groupId the group id to search with 569 * @param categoryId the category id to search with 570 * @param orderByComparator the comparator to order the set by 571 * @return the first matching message boards thread 572 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 573 * @throws SystemException if a system exception occurred 574 */ 575 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First( 576 long groupId, long categoryId, 577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 578 throws com.liferay.portal.kernel.exception.SystemException, 579 com.liferay.portlet.messageboards.NoSuchThreadException { 580 return getPersistence() 581 .findByG_NotC_First(groupId, categoryId, orderByComparator); 582 } 583 584 /** 585 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 586 * 587 * <p> 588 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 589 * </p> 590 * 591 * @param groupId the group id to search with 592 * @param categoryId the category id to search with 593 * @param orderByComparator the comparator to order the set by 594 * @return the last matching message boards thread 595 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 596 * @throws SystemException if a system exception occurred 597 */ 598 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last( 599 long groupId, long categoryId, 600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 601 throws com.liferay.portal.kernel.exception.SystemException, 602 com.liferay.portlet.messageboards.NoSuchThreadException { 603 return getPersistence() 604 .findByG_NotC_Last(groupId, categoryId, orderByComparator); 605 } 606 607 /** 608 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 609 * 610 * <p> 611 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 612 * </p> 613 * 614 * @param threadId the primary key of the current message boards thread 615 * @param groupId the group id to search with 616 * @param categoryId the category id to search with 617 * @param orderByComparator the comparator to order the set by 618 * @return the previous, current, and next message boards thread 619 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 620 * @throws SystemException if a system exception occurred 621 */ 622 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext( 623 long threadId, long groupId, long categoryId, 624 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 625 throws com.liferay.portal.kernel.exception.SystemException, 626 com.liferay.portlet.messageboards.NoSuchThreadException { 627 return getPersistence() 628 .findByG_NotC_PrevAndNext(threadId, groupId, categoryId, 629 orderByComparator); 630 } 631 632 /** 633 * Finds all the message boards threads where groupId = ? and status = ?. 634 * 635 * @param groupId the group id to search with 636 * @param status the status to search with 637 * @return the matching message boards threads 638 * @throws SystemException if a system exception occurred 639 */ 640 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 641 long groupId, int status) 642 throws com.liferay.portal.kernel.exception.SystemException { 643 return getPersistence().findByG_S(groupId, status); 644 } 645 646 /** 647 * Finds a range of all the message boards threads where groupId = ? and status = ?. 648 * 649 * <p> 650 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 651 * </p> 652 * 653 * @param groupId the group id to search with 654 * @param status the status to search with 655 * @param start the lower bound of the range of message boards threads to return 656 * @param end the upper bound of the range of message boards threads to return (not inclusive) 657 * @return the range of matching message boards threads 658 * @throws SystemException if a system exception occurred 659 */ 660 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 661 long groupId, int status, int start, int end) 662 throws com.liferay.portal.kernel.exception.SystemException { 663 return getPersistence().findByG_S(groupId, status, start, end); 664 } 665 666 /** 667 * Finds an ordered range of all the message boards threads where groupId = ? and status = ?. 668 * 669 * <p> 670 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 671 * </p> 672 * 673 * @param groupId the group id to search with 674 * @param status the status to search with 675 * @param start the lower bound of the range of message boards threads to return 676 * @param end the upper bound of the range of message boards threads to return (not inclusive) 677 * @param orderByComparator the comparator to order the results by 678 * @return the ordered range of matching message boards threads 679 * @throws SystemException if a system exception occurred 680 */ 681 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 682 long groupId, int status, int start, int end, 683 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 684 throws com.liferay.portal.kernel.exception.SystemException { 685 return getPersistence() 686 .findByG_S(groupId, status, start, end, orderByComparator); 687 } 688 689 /** 690 * Finds the first message boards thread in the ordered set where groupId = ? and status = ?. 691 * 692 * <p> 693 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 694 * </p> 695 * 696 * @param groupId the group id to search with 697 * @param status the status to search with 698 * @param orderByComparator the comparator to order the set by 699 * @return the first matching message boards thread 700 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 701 * @throws SystemException if a system exception occurred 702 */ 703 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First( 704 long groupId, int status, 705 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 706 throws com.liferay.portal.kernel.exception.SystemException, 707 com.liferay.portlet.messageboards.NoSuchThreadException { 708 return getPersistence() 709 .findByG_S_First(groupId, status, orderByComparator); 710 } 711 712 /** 713 * Finds the last message boards thread in the ordered set where groupId = ? and status = ?. 714 * 715 * <p> 716 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 717 * </p> 718 * 719 * @param groupId the group id to search with 720 * @param status the status to search with 721 * @param orderByComparator the comparator to order the set by 722 * @return the last matching message boards thread 723 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 724 * @throws SystemException if a system exception occurred 725 */ 726 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last( 727 long groupId, int status, 728 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 729 throws com.liferay.portal.kernel.exception.SystemException, 730 com.liferay.portlet.messageboards.NoSuchThreadException { 731 return getPersistence() 732 .findByG_S_Last(groupId, status, orderByComparator); 733 } 734 735 /** 736 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and status = ?. 737 * 738 * <p> 739 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 740 * </p> 741 * 742 * @param threadId the primary key of the current message boards thread 743 * @param groupId the group id to search with 744 * @param status the status to search with 745 * @param orderByComparator the comparator to order the set by 746 * @return the previous, current, and next message boards thread 747 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 748 * @throws SystemException if a system exception occurred 749 */ 750 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext( 751 long threadId, long groupId, int status, 752 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 753 throws com.liferay.portal.kernel.exception.SystemException, 754 com.liferay.portlet.messageboards.NoSuchThreadException { 755 return getPersistence() 756 .findByG_S_PrevAndNext(threadId, groupId, status, 757 orderByComparator); 758 } 759 760 /** 761 * Finds all the message boards threads where categoryId = ? and priority = ?. 762 * 763 * @param categoryId the category id to search with 764 * @param priority the priority to search with 765 * @return the matching message boards threads 766 * @throws SystemException if a system exception occurred 767 */ 768 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 769 long categoryId, double priority) 770 throws com.liferay.portal.kernel.exception.SystemException { 771 return getPersistence().findByC_P(categoryId, priority); 772 } 773 774 /** 775 * Finds a range of all the message boards threads where categoryId = ? and priority = ?. 776 * 777 * <p> 778 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 779 * </p> 780 * 781 * @param categoryId the category id to search with 782 * @param priority the priority to search with 783 * @param start the lower bound of the range of message boards threads to return 784 * @param end the upper bound of the range of message boards threads to return (not inclusive) 785 * @return the range of matching message boards threads 786 * @throws SystemException if a system exception occurred 787 */ 788 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 789 long categoryId, double priority, int start, int end) 790 throws com.liferay.portal.kernel.exception.SystemException { 791 return getPersistence().findByC_P(categoryId, priority, start, end); 792 } 793 794 /** 795 * Finds an ordered range of all the message boards threads where categoryId = ? and priority = ?. 796 * 797 * <p> 798 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 799 * </p> 800 * 801 * @param categoryId the category id to search with 802 * @param priority the priority to search with 803 * @param start the lower bound of the range of message boards threads to return 804 * @param end the upper bound of the range of message boards threads to return (not inclusive) 805 * @param orderByComparator the comparator to order the results by 806 * @return the ordered range of matching message boards threads 807 * @throws SystemException if a system exception occurred 808 */ 809 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 810 long categoryId, double priority, int start, int end, 811 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 812 throws com.liferay.portal.kernel.exception.SystemException { 813 return getPersistence() 814 .findByC_P(categoryId, priority, start, end, 815 orderByComparator); 816 } 817 818 /** 819 * Finds the first message boards thread in the ordered set where categoryId = ? and priority = ?. 820 * 821 * <p> 822 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 823 * </p> 824 * 825 * @param categoryId the category id to search with 826 * @param priority the priority to search with 827 * @param orderByComparator the comparator to order the set by 828 * @return the first matching message boards thread 829 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 830 * @throws SystemException if a system exception occurred 831 */ 832 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First( 833 long categoryId, double priority, 834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 835 throws com.liferay.portal.kernel.exception.SystemException, 836 com.liferay.portlet.messageboards.NoSuchThreadException { 837 return getPersistence() 838 .findByC_P_First(categoryId, priority, orderByComparator); 839 } 840 841 /** 842 * Finds the last message boards thread in the ordered set where categoryId = ? and priority = ?. 843 * 844 * <p> 845 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 846 * </p> 847 * 848 * @param categoryId the category id to search with 849 * @param priority the priority to search with 850 * @param orderByComparator the comparator to order the set by 851 * @return the last matching message boards thread 852 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 853 * @throws SystemException if a system exception occurred 854 */ 855 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last( 856 long categoryId, double priority, 857 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 858 throws com.liferay.portal.kernel.exception.SystemException, 859 com.liferay.portlet.messageboards.NoSuchThreadException { 860 return getPersistence() 861 .findByC_P_Last(categoryId, priority, orderByComparator); 862 } 863 864 /** 865 * Finds the message boards threads before and after the current message boards thread in the ordered set where categoryId = ? and priority = ?. 866 * 867 * <p> 868 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 869 * </p> 870 * 871 * @param threadId the primary key of the current message boards thread 872 * @param categoryId the category id to search with 873 * @param priority the priority to search with 874 * @param orderByComparator the comparator to order the set by 875 * @return the previous, current, and next message boards thread 876 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 877 * @throws SystemException if a system exception occurred 878 */ 879 public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext( 880 long threadId, long categoryId, double priority, 881 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 882 throws com.liferay.portal.kernel.exception.SystemException, 883 com.liferay.portlet.messageboards.NoSuchThreadException { 884 return getPersistence() 885 .findByC_P_PrevAndNext(threadId, categoryId, priority, 886 orderByComparator); 887 } 888 889 /** 890 * Finds all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 891 * 892 * @param groupId the group id to search with 893 * @param categoryId the category id to search with 894 * @param lastPostDate the last post date to search with 895 * @return the matching message boards threads 896 * @throws SystemException if a system exception occurred 897 */ 898 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 899 long groupId, long categoryId, java.util.Date lastPostDate) 900 throws com.liferay.portal.kernel.exception.SystemException { 901 return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate); 902 } 903 904 /** 905 * Finds a range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 906 * 907 * <p> 908 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 909 * </p> 910 * 911 * @param groupId the group id to search with 912 * @param categoryId the category id to search with 913 * @param lastPostDate the last post date to search with 914 * @param start the lower bound of the range of message boards threads to return 915 * @param end the upper bound of the range of message boards threads to return (not inclusive) 916 * @return the range of matching message boards threads 917 * @throws SystemException if a system exception occurred 918 */ 919 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 920 long groupId, long categoryId, java.util.Date lastPostDate, int start, 921 int end) throws com.liferay.portal.kernel.exception.SystemException { 922 return getPersistence() 923 .findByG_C_L(groupId, categoryId, lastPostDate, start, end); 924 } 925 926 /** 927 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 928 * 929 * <p> 930 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 931 * </p> 932 * 933 * @param groupId the group id to search with 934 * @param categoryId the category id to search with 935 * @param lastPostDate the last post date to search with 936 * @param start the lower bound of the range of message boards threads to return 937 * @param end the upper bound of the range of message boards threads to return (not inclusive) 938 * @param orderByComparator the comparator to order the results by 939 * @return the ordered range of matching message boards threads 940 * @throws SystemException if a system exception occurred 941 */ 942 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 943 long groupId, long categoryId, java.util.Date lastPostDate, int start, 944 int end, 945 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 946 throws com.liferay.portal.kernel.exception.SystemException { 947 return getPersistence() 948 .findByG_C_L(groupId, categoryId, lastPostDate, start, end, 949 orderByComparator); 950 } 951 952 /** 953 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 954 * 955 * <p> 956 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 957 * </p> 958 * 959 * @param groupId the group id to search with 960 * @param categoryId the category id to search with 961 * @param lastPostDate the last post date to search with 962 * @param orderByComparator the comparator to order the set by 963 * @return the first matching message boards thread 964 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 965 * @throws SystemException if a system exception occurred 966 */ 967 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First( 968 long groupId, long categoryId, java.util.Date lastPostDate, 969 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 970 throws com.liferay.portal.kernel.exception.SystemException, 971 com.liferay.portlet.messageboards.NoSuchThreadException { 972 return getPersistence() 973 .findByG_C_L_First(groupId, categoryId, lastPostDate, 974 orderByComparator); 975 } 976 977 /** 978 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 979 * 980 * <p> 981 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 982 * </p> 983 * 984 * @param groupId the group id to search with 985 * @param categoryId the category id to search with 986 * @param lastPostDate the last post date to search with 987 * @param orderByComparator the comparator to order the set by 988 * @return the last matching message boards thread 989 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 990 * @throws SystemException if a system exception occurred 991 */ 992 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last( 993 long groupId, long categoryId, java.util.Date lastPostDate, 994 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 995 throws com.liferay.portal.kernel.exception.SystemException, 996 com.liferay.portlet.messageboards.NoSuchThreadException { 997 return getPersistence() 998 .findByG_C_L_Last(groupId, categoryId, lastPostDate, 999 orderByComparator); 1000 } 1001 1002 /** 1003 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1004 * 1005 * <p> 1006 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1007 * </p> 1008 * 1009 * @param threadId the primary key of the current message boards thread 1010 * @param groupId the group id to search with 1011 * @param categoryId the category id to search with 1012 * @param lastPostDate the last post date to search with 1013 * @param orderByComparator the comparator to order the set by 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[] findByG_C_L_PrevAndNext( 1019 long threadId, long groupId, long categoryId, 1020 java.util.Date lastPostDate, 1021 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1022 throws com.liferay.portal.kernel.exception.SystemException, 1023 com.liferay.portlet.messageboards.NoSuchThreadException { 1024 return getPersistence() 1025 .findByG_C_L_PrevAndNext(threadId, groupId, categoryId, 1026 lastPostDate, orderByComparator); 1027 } 1028 1029 /** 1030 * Finds all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1031 * 1032 * @param groupId the group id to search with 1033 * @param categoryId the category id to search with 1034 * @param status the status to search with 1035 * @return the matching message boards threads 1036 * @throws SystemException if a system exception occurred 1037 */ 1038 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1039 long groupId, long categoryId, int status) 1040 throws com.liferay.portal.kernel.exception.SystemException { 1041 return getPersistence().findByG_C_S(groupId, categoryId, status); 1042 } 1043 1044 /** 1045 * Finds a range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1046 * 1047 * <p> 1048 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1049 * </p> 1050 * 1051 * @param groupId the group id to search with 1052 * @param categoryId the category id to search with 1053 * @param status the status to search with 1054 * @param start the lower bound of the range of message boards threads to return 1055 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1056 * @return the range of matching message boards threads 1057 * @throws SystemException if a system exception occurred 1058 */ 1059 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1060 long groupId, long categoryId, int status, int start, int end) 1061 throws com.liferay.portal.kernel.exception.SystemException { 1062 return getPersistence() 1063 .findByG_C_S(groupId, categoryId, status, start, end); 1064 } 1065 1066 /** 1067 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1068 * 1069 * <p> 1070 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1071 * </p> 1072 * 1073 * @param groupId the group id to search with 1074 * @param categoryId the category id to search with 1075 * @param status the status to search with 1076 * @param start the lower bound of the range of message boards threads to return 1077 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1078 * @param orderByComparator the comparator to order the results by 1079 * @return the ordered range of matching message boards threads 1080 * @throws SystemException if a system exception occurred 1081 */ 1082 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1083 long groupId, long categoryId, int status, int start, int end, 1084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 return getPersistence() 1087 .findByG_C_S(groupId, categoryId, status, start, end, 1088 orderByComparator); 1089 } 1090 1091 /** 1092 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1093 * 1094 * <p> 1095 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1096 * </p> 1097 * 1098 * @param groupId the group id to search with 1099 * @param categoryId the category id to search with 1100 * @param status the status to search with 1101 * @param orderByComparator the comparator to order the set by 1102 * @return the first matching message boards thread 1103 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1104 * @throws SystemException if a system exception occurred 1105 */ 1106 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First( 1107 long groupId, long categoryId, int status, 1108 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1109 throws com.liferay.portal.kernel.exception.SystemException, 1110 com.liferay.portlet.messageboards.NoSuchThreadException { 1111 return getPersistence() 1112 .findByG_C_S_First(groupId, categoryId, status, 1113 orderByComparator); 1114 } 1115 1116 /** 1117 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1118 * 1119 * <p> 1120 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1121 * </p> 1122 * 1123 * @param groupId the group id to search with 1124 * @param categoryId the category id to search with 1125 * @param status the status to search with 1126 * @param orderByComparator the comparator to order the set by 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_C_S_Last( 1132 long groupId, long categoryId, 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_C_S_Last(groupId, categoryId, status, 1138 orderByComparator); 1139 } 1140 1141 /** 1142 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1143 * 1144 * <p> 1145 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1146 * </p> 1147 * 1148 * @param threadId the primary key of the current message boards thread 1149 * @param groupId the group id to search with 1150 * @param categoryId the category id to search with 1151 * @param status the status to search with 1152 * @param orderByComparator the comparator to order the set by 1153 * @return the previous, current, and next message boards thread 1154 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1155 * @throws SystemException if a system exception occurred 1156 */ 1157 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext( 1158 long threadId, long groupId, long categoryId, int status, 1159 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1160 throws com.liferay.portal.kernel.exception.SystemException, 1161 com.liferay.portlet.messageboards.NoSuchThreadException { 1162 return getPersistence() 1163 .findByG_C_S_PrevAndNext(threadId, groupId, categoryId, 1164 status, orderByComparator); 1165 } 1166 1167 /** 1168 * Finds all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1169 * 1170 * <p> 1171 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1172 * </p> 1173 * 1174 * @param groupId the group id to search with 1175 * @param categoryIds the category ids to search with 1176 * @param status the status to search with 1177 * @return the matching message boards threads 1178 * @throws SystemException if a system exception occurred 1179 */ 1180 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1181 long groupId, long[] categoryIds, int status) 1182 throws com.liferay.portal.kernel.exception.SystemException { 1183 return getPersistence().findByG_C_S(groupId, categoryIds, status); 1184 } 1185 1186 /** 1187 * Finds a range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1188 * 1189 * <p> 1190 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1191 * </p> 1192 * 1193 * @param groupId the group id to search with 1194 * @param categoryIds the category ids to search with 1195 * @param status the status to search with 1196 * @param start the lower bound of the range of message boards threads to return 1197 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1198 * @return the range of matching message boards threads 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1202 long groupId, long[] categoryIds, int status, int start, int end) 1203 throws com.liferay.portal.kernel.exception.SystemException { 1204 return getPersistence() 1205 .findByG_C_S(groupId, categoryIds, status, start, end); 1206 } 1207 1208 /** 1209 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1210 * 1211 * <p> 1212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1213 * </p> 1214 * 1215 * @param groupId the group id to search with 1216 * @param categoryIds the category ids to search with 1217 * @param status the status to search with 1218 * @param start the lower bound of the range of message boards threads to return 1219 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1220 * @param orderByComparator the comparator to order the results by 1221 * @return the ordered range of matching message boards threads 1222 * @throws SystemException if a system exception occurred 1223 */ 1224 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1225 long groupId, long[] categoryIds, int status, int start, int end, 1226 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1227 throws com.liferay.portal.kernel.exception.SystemException { 1228 return getPersistence() 1229 .findByG_C_S(groupId, categoryIds, status, start, end, 1230 orderByComparator); 1231 } 1232 1233 /** 1234 * Finds all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1235 * 1236 * @param groupId the group id to search with 1237 * @param categoryId the category id to search with 1238 * @param status the status to search with 1239 * @return the matching message boards threads 1240 * @throws SystemException if a system exception occurred 1241 */ 1242 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1243 long groupId, long categoryId, int status) 1244 throws com.liferay.portal.kernel.exception.SystemException { 1245 return getPersistence().findByG_NotC_S(groupId, categoryId, status); 1246 } 1247 1248 /** 1249 * Finds a range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1250 * 1251 * <p> 1252 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1253 * </p> 1254 * 1255 * @param groupId the group id to search with 1256 * @param categoryId the category id to search with 1257 * @param status the status to search with 1258 * @param start the lower bound of the range of message boards threads to return 1259 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1260 * @return the range of matching message boards threads 1261 * @throws SystemException if a system exception occurred 1262 */ 1263 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1264 long groupId, long categoryId, int status, int start, int end) 1265 throws com.liferay.portal.kernel.exception.SystemException { 1266 return getPersistence() 1267 .findByG_NotC_S(groupId, categoryId, status, start, end); 1268 } 1269 1270 /** 1271 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1272 * 1273 * <p> 1274 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1275 * </p> 1276 * 1277 * @param groupId the group id to search with 1278 * @param categoryId the category id to search with 1279 * @param status the status to search with 1280 * @param start the lower bound of the range of message boards threads to return 1281 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1282 * @param orderByComparator the comparator to order the results by 1283 * @return the ordered range of matching message boards threads 1284 * @throws SystemException if a system exception occurred 1285 */ 1286 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1287 long groupId, long categoryId, int status, int start, int end, 1288 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1289 throws com.liferay.portal.kernel.exception.SystemException { 1290 return getPersistence() 1291 .findByG_NotC_S(groupId, categoryId, status, start, end, 1292 orderByComparator); 1293 } 1294 1295 /** 1296 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1297 * 1298 * <p> 1299 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1300 * </p> 1301 * 1302 * @param groupId the group id to search with 1303 * @param categoryId the category id to search with 1304 * @param status the status to search with 1305 * @param orderByComparator the comparator to order the set by 1306 * @return the first matching message boards thread 1307 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1308 * @throws SystemException if a system exception occurred 1309 */ 1310 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First( 1311 long groupId, long categoryId, int status, 1312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1313 throws com.liferay.portal.kernel.exception.SystemException, 1314 com.liferay.portlet.messageboards.NoSuchThreadException { 1315 return getPersistence() 1316 .findByG_NotC_S_First(groupId, categoryId, status, 1317 orderByComparator); 1318 } 1319 1320 /** 1321 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1322 * 1323 * <p> 1324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1325 * </p> 1326 * 1327 * @param groupId the group id to search with 1328 * @param categoryId the category id to search with 1329 * @param status the status to search with 1330 * @param orderByComparator the comparator to order the set by 1331 * @return the last matching message boards thread 1332 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1333 * @throws SystemException if a system exception occurred 1334 */ 1335 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last( 1336 long groupId, long categoryId, int status, 1337 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1338 throws com.liferay.portal.kernel.exception.SystemException, 1339 com.liferay.portlet.messageboards.NoSuchThreadException { 1340 return getPersistence() 1341 .findByG_NotC_S_Last(groupId, categoryId, status, 1342 orderByComparator); 1343 } 1344 1345 /** 1346 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1347 * 1348 * <p> 1349 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1350 * </p> 1351 * 1352 * @param threadId the primary key of the current message boards thread 1353 * @param groupId the group id to search with 1354 * @param categoryId the category id to search with 1355 * @param status the status to search with 1356 * @param orderByComparator the comparator to order the set by 1357 * @return the previous, current, and next message boards thread 1358 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1359 * @throws SystemException if a system exception occurred 1360 */ 1361 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext( 1362 long threadId, long groupId, long categoryId, int status, 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 .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId, 1368 status, orderByComparator); 1369 } 1370 1371 /** 1372 * Finds all the message boards threads. 1373 * 1374 * @return the message boards threads 1375 * @throws SystemException if a system exception occurred 1376 */ 1377 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll() 1378 throws com.liferay.portal.kernel.exception.SystemException { 1379 return getPersistence().findAll(); 1380 } 1381 1382 /** 1383 * Finds a range of all the message boards threads. 1384 * 1385 * <p> 1386 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1387 * </p> 1388 * 1389 * @param start the lower bound of the range of message boards threads to return 1390 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1391 * @return the range of message boards threads 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 1395 int start, int end) 1396 throws com.liferay.portal.kernel.exception.SystemException { 1397 return getPersistence().findAll(start, end); 1398 } 1399 1400 /** 1401 * Finds an ordered range of all the message boards threads. 1402 * 1403 * <p> 1404 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1405 * </p> 1406 * 1407 * @param start the lower bound of the range of message boards threads to return 1408 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1409 * @param orderByComparator the comparator to order the results by 1410 * @return the ordered range of message boards threads 1411 * @throws SystemException if a system exception occurred 1412 */ 1413 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 1414 int start, int end, 1415 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1416 throws com.liferay.portal.kernel.exception.SystemException { 1417 return getPersistence().findAll(start, end, orderByComparator); 1418 } 1419 1420 /** 1421 * Removes all the message boards threads where groupId = ? from the database. 1422 * 1423 * @param groupId the group id to search with 1424 * @throws SystemException if a system exception occurred 1425 */ 1426 public static void removeByGroupId(long groupId) 1427 throws com.liferay.portal.kernel.exception.SystemException { 1428 getPersistence().removeByGroupId(groupId); 1429 } 1430 1431 /** 1432 * Removes all the message boards threads where groupId = ? and categoryId = ? from the database. 1433 * 1434 * @param groupId the group id to search with 1435 * @param categoryId the category id to search with 1436 * @throws SystemException if a system exception occurred 1437 */ 1438 public static void removeByG_C(long groupId, long categoryId) 1439 throws com.liferay.portal.kernel.exception.SystemException { 1440 getPersistence().removeByG_C(groupId, categoryId); 1441 } 1442 1443 /** 1444 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? from the database. 1445 * 1446 * @param groupId the group id to search with 1447 * @param categoryId the category id to search with 1448 * @throws SystemException if a system exception occurred 1449 */ 1450 public static void removeByG_NotC(long groupId, long categoryId) 1451 throws com.liferay.portal.kernel.exception.SystemException { 1452 getPersistence().removeByG_NotC(groupId, categoryId); 1453 } 1454 1455 /** 1456 * Removes all the message boards threads where groupId = ? and status = ? from the database. 1457 * 1458 * @param groupId the group id to search with 1459 * @param status the status to search with 1460 * @throws SystemException if a system exception occurred 1461 */ 1462 public static void removeByG_S(long groupId, int status) 1463 throws com.liferay.portal.kernel.exception.SystemException { 1464 getPersistence().removeByG_S(groupId, status); 1465 } 1466 1467 /** 1468 * Removes all the message boards threads where categoryId = ? and priority = ? from the database. 1469 * 1470 * @param categoryId the category id to search with 1471 * @param priority the priority to search with 1472 * @throws SystemException if a system exception occurred 1473 */ 1474 public static void removeByC_P(long categoryId, double priority) 1475 throws com.liferay.portal.kernel.exception.SystemException { 1476 getPersistence().removeByC_P(categoryId, priority); 1477 } 1478 1479 /** 1480 * Removes all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ? from the database. 1481 * 1482 * @param groupId the group id to search with 1483 * @param categoryId the category id to search with 1484 * @param lastPostDate the last post date to search with 1485 * @throws SystemException if a system exception occurred 1486 */ 1487 public static void removeByG_C_L(long groupId, long categoryId, 1488 java.util.Date lastPostDate) 1489 throws com.liferay.portal.kernel.exception.SystemException { 1490 getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate); 1491 } 1492 1493 /** 1494 * Removes all the message boards threads where groupId = ? and categoryId = ? and status = ? from the database. 1495 * 1496 * @param groupId the group id to search with 1497 * @param categoryId the category id to search with 1498 * @param status the status to search with 1499 * @throws SystemException if a system exception occurred 1500 */ 1501 public static void removeByG_C_S(long groupId, long categoryId, int status) 1502 throws com.liferay.portal.kernel.exception.SystemException { 1503 getPersistence().removeByG_C_S(groupId, categoryId, status); 1504 } 1505 1506 /** 1507 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? and status = ? from the database. 1508 * 1509 * @param groupId the group id to search with 1510 * @param categoryId the category id to search with 1511 * @param status the status to search with 1512 * @throws SystemException if a system exception occurred 1513 */ 1514 public static void removeByG_NotC_S(long groupId, long categoryId, 1515 int status) throws com.liferay.portal.kernel.exception.SystemException { 1516 getPersistence().removeByG_NotC_S(groupId, categoryId, status); 1517 } 1518 1519 /** 1520 * Removes all the message boards threads from the database. 1521 * 1522 * @throws SystemException if a system exception occurred 1523 */ 1524 public static void removeAll() 1525 throws com.liferay.portal.kernel.exception.SystemException { 1526 getPersistence().removeAll(); 1527 } 1528 1529 /** 1530 * Counts all the message boards threads where groupId = ?. 1531 * 1532 * @param groupId the group id to search with 1533 * @return the number of matching message boards threads 1534 * @throws SystemException if a system exception occurred 1535 */ 1536 public static int countByGroupId(long groupId) 1537 throws com.liferay.portal.kernel.exception.SystemException { 1538 return getPersistence().countByGroupId(groupId); 1539 } 1540 1541 /** 1542 * Counts all the message boards threads where groupId = ? and categoryId = ?. 1543 * 1544 * @param groupId the group id to search with 1545 * @param categoryId the category id to search with 1546 * @return the number of matching message boards threads 1547 * @throws SystemException if a system exception occurred 1548 */ 1549 public static int countByG_C(long groupId, long categoryId) 1550 throws com.liferay.portal.kernel.exception.SystemException { 1551 return getPersistence().countByG_C(groupId, categoryId); 1552 } 1553 1554 /** 1555 * Counts all the message boards threads where groupId = ? and categoryId = any ?. 1556 * 1557 * @param groupId the group id to search with 1558 * @param categoryIds the category ids to search with 1559 * @return the number of matching message boards threads 1560 * @throws SystemException if a system exception occurred 1561 */ 1562 public static int countByG_C(long groupId, long[] categoryIds) 1563 throws com.liferay.portal.kernel.exception.SystemException { 1564 return getPersistence().countByG_C(groupId, categoryIds); 1565 } 1566 1567 /** 1568 * Counts all the message boards threads where groupId = ? and categoryId ≠ ?. 1569 * 1570 * @param groupId the group id to search with 1571 * @param categoryId the category id to search with 1572 * @return the number of matching message boards threads 1573 * @throws SystemException if a system exception occurred 1574 */ 1575 public static int countByG_NotC(long groupId, long categoryId) 1576 throws com.liferay.portal.kernel.exception.SystemException { 1577 return getPersistence().countByG_NotC(groupId, categoryId); 1578 } 1579 1580 /** 1581 * Counts all the message boards threads where groupId = ? and status = ?. 1582 * 1583 * @param groupId the group id to search with 1584 * @param status the status to search with 1585 * @return the number of matching message boards threads 1586 * @throws SystemException if a system exception occurred 1587 */ 1588 public static int countByG_S(long groupId, int status) 1589 throws com.liferay.portal.kernel.exception.SystemException { 1590 return getPersistence().countByG_S(groupId, status); 1591 } 1592 1593 /** 1594 * Counts all the message boards threads where categoryId = ? and priority = ?. 1595 * 1596 * @param categoryId the category id to search with 1597 * @param priority the priority to search with 1598 * @return the number of matching message boards threads 1599 * @throws SystemException if a system exception occurred 1600 */ 1601 public static int countByC_P(long categoryId, double priority) 1602 throws com.liferay.portal.kernel.exception.SystemException { 1603 return getPersistence().countByC_P(categoryId, priority); 1604 } 1605 1606 /** 1607 * Counts all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1608 * 1609 * @param groupId the group id to search with 1610 * @param categoryId the category id to search with 1611 * @param lastPostDate the last post date to search with 1612 * @return the number of matching message boards threads 1613 * @throws SystemException if a system exception occurred 1614 */ 1615 public static int countByG_C_L(long groupId, long categoryId, 1616 java.util.Date lastPostDate) 1617 throws com.liferay.portal.kernel.exception.SystemException { 1618 return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate); 1619 } 1620 1621 /** 1622 * Counts all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1623 * 1624 * @param groupId the group id to search with 1625 * @param categoryId the category id to search with 1626 * @param status the status to search with 1627 * @return the number of matching message boards threads 1628 * @throws SystemException if a system exception occurred 1629 */ 1630 public static int countByG_C_S(long groupId, long categoryId, int status) 1631 throws com.liferay.portal.kernel.exception.SystemException { 1632 return getPersistence().countByG_C_S(groupId, categoryId, status); 1633 } 1634 1635 /** 1636 * Counts all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1637 * 1638 * @param groupId the group id to search with 1639 * @param categoryIds the category ids to search with 1640 * @param status the status to search with 1641 * @return the number of matching message boards threads 1642 * @throws SystemException if a system exception occurred 1643 */ 1644 public static int countByG_C_S(long groupId, long[] categoryIds, int status) 1645 throws com.liferay.portal.kernel.exception.SystemException { 1646 return getPersistence().countByG_C_S(groupId, categoryIds, status); 1647 } 1648 1649 /** 1650 * Counts all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1651 * 1652 * @param groupId the group id to search with 1653 * @param categoryId the category id to search with 1654 * @param status the status to search with 1655 * @return the number of matching message boards threads 1656 * @throws SystemException if a system exception occurred 1657 */ 1658 public static int countByG_NotC_S(long groupId, long categoryId, int status) 1659 throws com.liferay.portal.kernel.exception.SystemException { 1660 return getPersistence().countByG_NotC_S(groupId, categoryId, status); 1661 } 1662 1663 /** 1664 * Counts all the message boards threads. 1665 * 1666 * @return the number of message boards threads 1667 * @throws SystemException if a system exception occurred 1668 */ 1669 public static int countAll() 1670 throws com.liferay.portal.kernel.exception.SystemException { 1671 return getPersistence().countAll(); 1672 } 1673 1674 public static MBThreadPersistence getPersistence() { 1675 if (_persistence == null) { 1676 _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName()); 1677 } 1678 1679 return _persistence; 1680 } 1681 1682 public void setPersistence(MBThreadPersistence persistence) { 1683 _persistence = persistence; 1684 } 1685 1686 private static MBThreadPersistence _persistence; 1687 }