001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.messageboards.model.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#remove(com.liferay.portal.model.BaseModel) 099 */ 100 public static MBThread remove(MBThread mbThread) throws SystemException { 101 return getPersistence().remove(mbThread); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 106 */ 107 public static MBThread update(MBThread mbThread, boolean merge) 108 throws SystemException { 109 return getPersistence().update(mbThread, merge); 110 } 111 112 /** 113 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 114 */ 115 public static MBThread update(MBThread mbThread, boolean merge, 116 ServiceContext serviceContext) throws SystemException { 117 return getPersistence().update(mbThread, merge, serviceContext); 118 } 119 120 /** 121 * Caches the message boards thread in the entity cache if it is enabled. 122 * 123 * @param mbThread the message boards thread to cache 124 */ 125 public static void cacheResult( 126 com.liferay.portlet.messageboards.model.MBThread mbThread) { 127 getPersistence().cacheResult(mbThread); 128 } 129 130 /** 131 * Caches the message boards threads in the entity cache if it is enabled. 132 * 133 * @param mbThreads the message boards threads to cache 134 */ 135 public static void cacheResult( 136 java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) { 137 getPersistence().cacheResult(mbThreads); 138 } 139 140 /** 141 * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database. 142 * 143 * @param threadId the primary key for the new message boards thread 144 * @return the new message boards thread 145 */ 146 public static com.liferay.portlet.messageboards.model.MBThread create( 147 long threadId) { 148 return getPersistence().create(threadId); 149 } 150 151 /** 152 * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners. 153 * 154 * @param threadId the primary key of the message boards thread to remove 155 * @return the message boards thread that was removed 156 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 157 * @throws SystemException if a system exception occurred 158 */ 159 public static com.liferay.portlet.messageboards.model.MBThread remove( 160 long threadId) 161 throws com.liferay.portal.kernel.exception.SystemException, 162 com.liferay.portlet.messageboards.NoSuchThreadException { 163 return getPersistence().remove(threadId); 164 } 165 166 public static com.liferay.portlet.messageboards.model.MBThread updateImpl( 167 com.liferay.portlet.messageboards.model.MBThread mbThread, boolean merge) 168 throws com.liferay.portal.kernel.exception.SystemException { 169 return getPersistence().updateImpl(mbThread, merge); 170 } 171 172 /** 173 * Finds the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 174 * 175 * @param threadId the primary key of the message boards thread to find 176 * @return the message boards thread 177 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 178 * @throws SystemException if a system exception occurred 179 */ 180 public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey( 181 long threadId) 182 throws com.liferay.portal.kernel.exception.SystemException, 183 com.liferay.portlet.messageboards.NoSuchThreadException { 184 return getPersistence().findByPrimaryKey(threadId); 185 } 186 187 /** 188 * Finds the message boards thread with the primary key or returns <code>null</code> if it could not be found. 189 * 190 * @param threadId the primary key of the message boards thread to find 191 * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey( 195 long threadId) 196 throws com.liferay.portal.kernel.exception.SystemException { 197 return getPersistence().fetchByPrimaryKey(threadId); 198 } 199 200 /** 201 * Finds all the message boards threads where groupId = ?. 202 * 203 * @param groupId the group ID to search with 204 * @return the matching message boards threads 205 * @throws SystemException if a system exception occurred 206 */ 207 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 208 long groupId) 209 throws com.liferay.portal.kernel.exception.SystemException { 210 return getPersistence().findByGroupId(groupId); 211 } 212 213 /** 214 * Finds a range of all the message boards threads where groupId = ?. 215 * 216 * <p> 217 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 218 * </p> 219 * 220 * @param groupId the group ID to search with 221 * @param start the lower bound of the range of message boards threads to return 222 * @param end the upper bound of the range of message boards threads to return (not inclusive) 223 * @return the range of matching message boards threads 224 * @throws SystemException if a system exception occurred 225 */ 226 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 227 long groupId, int start, int end) 228 throws com.liferay.portal.kernel.exception.SystemException { 229 return getPersistence().findByGroupId(groupId, start, end); 230 } 231 232 /** 233 * Finds an ordered range of all the message boards threads where groupId = ?. 234 * 235 * <p> 236 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 237 * </p> 238 * 239 * @param groupId the group ID to search with 240 * @param start the lower bound of the range of message boards threads to return 241 * @param end the upper bound of the range of message boards threads to return (not inclusive) 242 * @param orderByComparator the comparator to order the results by 243 * @return the ordered range of matching message boards threads 244 * @throws SystemException if a system exception occurred 245 */ 246 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 247 long groupId, int start, int end, 248 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 249 throws com.liferay.portal.kernel.exception.SystemException { 250 return getPersistence() 251 .findByGroupId(groupId, start, end, orderByComparator); 252 } 253 254 /** 255 * Finds the first message boards thread in the ordered set where groupId = ?. 256 * 257 * <p> 258 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 259 * </p> 260 * 261 * @param groupId the group ID to search with 262 * @param orderByComparator the comparator to order the set by 263 * @return the first matching message boards thread 264 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 265 * @throws SystemException if a system exception occurred 266 */ 267 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First( 268 long groupId, 269 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 270 throws com.liferay.portal.kernel.exception.SystemException, 271 com.liferay.portlet.messageboards.NoSuchThreadException { 272 return getPersistence().findByGroupId_First(groupId, orderByComparator); 273 } 274 275 /** 276 * Finds the last message boards thread in the ordered set where groupId = ?. 277 * 278 * <p> 279 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 280 * </p> 281 * 282 * @param groupId the group ID to search with 283 * @param orderByComparator the comparator to order the set by 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 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ?. 298 * 299 * <p> 300 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 301 * </p> 302 * 303 * @param threadId the primary key of the current message boards thread 304 * @param groupId the group ID to search with 305 * @param orderByComparator the comparator to order the set by 306 * @return the previous, current, and next message boards thread 307 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 308 * @throws SystemException if a system exception occurred 309 */ 310 public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext( 311 long threadId, long groupId, 312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 313 throws com.liferay.portal.kernel.exception.SystemException, 314 com.liferay.portlet.messageboards.NoSuchThreadException { 315 return getPersistence() 316 .findByGroupId_PrevAndNext(threadId, groupId, 317 orderByComparator); 318 } 319 320 /** 321 * Finds the message boards thread where rootMessageId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 322 * 323 * @param rootMessageId the root message ID to search with 324 * @return the matching message boards thread 325 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 326 * @throws SystemException if a system exception occurred 327 */ 328 public static com.liferay.portlet.messageboards.model.MBThread findByRootMessageId( 329 long rootMessageId) 330 throws com.liferay.portal.kernel.exception.SystemException, 331 com.liferay.portlet.messageboards.NoSuchThreadException { 332 return getPersistence().findByRootMessageId(rootMessageId); 333 } 334 335 /** 336 * Finds the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 337 * 338 * @param rootMessageId the root message ID to search with 339 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 340 * @throws SystemException if a system exception occurred 341 */ 342 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 343 long rootMessageId) 344 throws com.liferay.portal.kernel.exception.SystemException { 345 return getPersistence().fetchByRootMessageId(rootMessageId); 346 } 347 348 /** 349 * Finds the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 350 * 351 * @param rootMessageId the root message ID to search with 352 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 353 * @throws SystemException if a system exception occurred 354 */ 355 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 356 long rootMessageId, boolean retrieveFromCache) 357 throws com.liferay.portal.kernel.exception.SystemException { 358 return getPersistence() 359 .fetchByRootMessageId(rootMessageId, retrieveFromCache); 360 } 361 362 /** 363 * Finds all the message boards threads where groupId = ? and categoryId = ?. 364 * 365 * @param groupId the group ID to search with 366 * @param categoryId the category ID to search with 367 * @return the matching message boards threads 368 * @throws SystemException if a system exception occurred 369 */ 370 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 371 long groupId, long categoryId) 372 throws com.liferay.portal.kernel.exception.SystemException { 373 return getPersistence().findByG_C(groupId, categoryId); 374 } 375 376 /** 377 * Finds a range of all the message boards threads where groupId = ? and categoryId = ?. 378 * 379 * <p> 380 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 381 * </p> 382 * 383 * @param groupId the group ID to search with 384 * @param categoryId the category ID to search with 385 * @param start the lower bound of the range of message boards threads to return 386 * @param end the upper bound of the range of message boards threads to return (not inclusive) 387 * @return the range of matching message boards threads 388 * @throws SystemException if a system exception occurred 389 */ 390 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 391 long groupId, long categoryId, int start, int end) 392 throws com.liferay.portal.kernel.exception.SystemException { 393 return getPersistence().findByG_C(groupId, categoryId, start, end); 394 } 395 396 /** 397 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ?. 398 * 399 * <p> 400 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 401 * </p> 402 * 403 * @param groupId the group ID to search with 404 * @param categoryId the category ID to search with 405 * @param start the lower bound of the range of message boards threads to return 406 * @param end the upper bound of the range of message boards threads to return (not inclusive) 407 * @param orderByComparator the comparator to order the results by 408 * @return the ordered range of matching message boards threads 409 * @throws SystemException if a system exception occurred 410 */ 411 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 412 long groupId, long categoryId, int start, int end, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException { 415 return getPersistence() 416 .findByG_C(groupId, categoryId, start, end, orderByComparator); 417 } 418 419 /** 420 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 421 * 422 * <p> 423 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 424 * </p> 425 * 426 * @param groupId the group ID to search with 427 * @param categoryId the category ID to search with 428 * @param orderByComparator the comparator to order the set by 429 * @return the first matching message boards thread 430 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 431 * @throws SystemException if a system exception occurred 432 */ 433 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First( 434 long groupId, long categoryId, 435 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 436 throws com.liferay.portal.kernel.exception.SystemException, 437 com.liferay.portlet.messageboards.NoSuchThreadException { 438 return getPersistence() 439 .findByG_C_First(groupId, categoryId, orderByComparator); 440 } 441 442 /** 443 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 444 * 445 * <p> 446 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 447 * </p> 448 * 449 * @param groupId the group ID to search with 450 * @param categoryId the category ID to search with 451 * @param orderByComparator the comparator to order the set by 452 * @return the last matching message boards thread 453 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 454 * @throws SystemException if a system exception occurred 455 */ 456 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last( 457 long groupId, long categoryId, 458 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 459 throws com.liferay.portal.kernel.exception.SystemException, 460 com.liferay.portlet.messageboards.NoSuchThreadException { 461 return getPersistence() 462 .findByG_C_Last(groupId, categoryId, orderByComparator); 463 } 464 465 /** 466 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ?. 467 * 468 * <p> 469 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 470 * </p> 471 * 472 * @param threadId the primary key of the current message boards thread 473 * @param groupId the group ID to search with 474 * @param categoryId the category ID to search with 475 * @param orderByComparator the comparator to order the set by 476 * @return the previous, current, and next message boards thread 477 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 478 * @throws SystemException if a system exception occurred 479 */ 480 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext( 481 long threadId, long groupId, long categoryId, 482 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 483 throws com.liferay.portal.kernel.exception.SystemException, 484 com.liferay.portlet.messageboards.NoSuchThreadException { 485 return getPersistence() 486 .findByG_C_PrevAndNext(threadId, groupId, categoryId, 487 orderByComparator); 488 } 489 490 /** 491 * Finds all the message boards threads where groupId = ? and categoryId = any ?. 492 * 493 * <p> 494 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 495 * </p> 496 * 497 * @param groupId the group ID to search with 498 * @param categoryIds the category IDs to search with 499 * @return the matching message boards threads 500 * @throws SystemException if a system exception occurred 501 */ 502 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 503 long groupId, long[] categoryIds) 504 throws com.liferay.portal.kernel.exception.SystemException { 505 return getPersistence().findByG_C(groupId, categoryIds); 506 } 507 508 /** 509 * Finds a range of all the message boards threads where groupId = ? and categoryId = any ?. 510 * 511 * <p> 512 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 513 * </p> 514 * 515 * @param groupId the group ID to search with 516 * @param categoryIds the category IDs to search with 517 * @param start the lower bound of the range of message boards threads to return 518 * @param end the upper bound of the range of message boards threads to return (not inclusive) 519 * @return the range of matching message boards threads 520 * @throws SystemException if a system exception occurred 521 */ 522 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 523 long groupId, long[] categoryIds, int start, int end) 524 throws com.liferay.portal.kernel.exception.SystemException { 525 return getPersistence().findByG_C(groupId, categoryIds, start, end); 526 } 527 528 /** 529 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = any ?. 530 * 531 * <p> 532 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 533 * </p> 534 * 535 * @param groupId the group ID to search with 536 * @param categoryIds the category IDs to search with 537 * @param start the lower bound of the range of message boards threads to return 538 * @param end the upper bound of the range of message boards threads to return (not inclusive) 539 * @param orderByComparator the comparator to order the results by 540 * @return the ordered range of matching message boards threads 541 * @throws SystemException if a system exception occurred 542 */ 543 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 544 long groupId, long[] categoryIds, int start, int end, 545 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence() 548 .findByG_C(groupId, categoryIds, start, end, 549 orderByComparator); 550 } 551 552 /** 553 * Finds all the message boards threads where groupId = ? and categoryId ≠ ?. 554 * 555 * @param groupId the group ID to search with 556 * @param categoryId the category ID to search with 557 * @return the matching message boards threads 558 * @throws SystemException if a system exception occurred 559 */ 560 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 561 long groupId, long categoryId) 562 throws com.liferay.portal.kernel.exception.SystemException { 563 return getPersistence().findByG_NotC(groupId, categoryId); 564 } 565 566 /** 567 * Finds a range of all the message boards threads where groupId = ? and categoryId ≠ ?. 568 * 569 * <p> 570 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 571 * </p> 572 * 573 * @param groupId the group ID to search with 574 * @param categoryId the category ID to search with 575 * @param start the lower bound of the range of message boards threads to return 576 * @param end the upper bound of the range of message boards threads to return (not inclusive) 577 * @return the range of matching message boards threads 578 * @throws SystemException if a system exception occurred 579 */ 580 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 581 long groupId, long categoryId, int start, int end) 582 throws com.liferay.portal.kernel.exception.SystemException { 583 return getPersistence().findByG_NotC(groupId, categoryId, start, end); 584 } 585 586 /** 587 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ?. 588 * 589 * <p> 590 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 591 * </p> 592 * 593 * @param groupId the group ID to search with 594 * @param categoryId the category ID to search with 595 * @param start the lower bound of the range of message boards threads to return 596 * @param end the upper bound of the range of message boards threads to return (not inclusive) 597 * @param orderByComparator the comparator to order the results by 598 * @return the ordered range of matching message boards threads 599 * @throws SystemException if a system exception occurred 600 */ 601 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 602 long groupId, long categoryId, int start, int end, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException { 605 return getPersistence() 606 .findByG_NotC(groupId, categoryId, start, end, 607 orderByComparator); 608 } 609 610 /** 611 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 612 * 613 * <p> 614 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 615 * </p> 616 * 617 * @param groupId the group ID to search with 618 * @param categoryId the category ID to search with 619 * @param orderByComparator the comparator to order the set by 620 * @return the first matching message boards thread 621 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First( 625 long groupId, long categoryId, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.messageboards.NoSuchThreadException { 629 return getPersistence() 630 .findByG_NotC_First(groupId, categoryId, orderByComparator); 631 } 632 633 /** 634 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 635 * 636 * <p> 637 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 638 * </p> 639 * 640 * @param groupId the group ID to search with 641 * @param categoryId the category ID to search with 642 * @param orderByComparator the comparator to order the set by 643 * @return the last matching message boards thread 644 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 645 * @throws SystemException if a system exception occurred 646 */ 647 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last( 648 long groupId, long categoryId, 649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 650 throws com.liferay.portal.kernel.exception.SystemException, 651 com.liferay.portlet.messageboards.NoSuchThreadException { 652 return getPersistence() 653 .findByG_NotC_Last(groupId, categoryId, orderByComparator); 654 } 655 656 /** 657 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 658 * 659 * <p> 660 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 661 * </p> 662 * 663 * @param threadId the primary key of the current message boards thread 664 * @param groupId the group ID to search with 665 * @param categoryId the category ID to search with 666 * @param orderByComparator the comparator to order the set by 667 * @return the previous, current, and next message boards thread 668 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 669 * @throws SystemException if a system exception occurred 670 */ 671 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext( 672 long threadId, long groupId, long categoryId, 673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 674 throws com.liferay.portal.kernel.exception.SystemException, 675 com.liferay.portlet.messageboards.NoSuchThreadException { 676 return getPersistence() 677 .findByG_NotC_PrevAndNext(threadId, groupId, categoryId, 678 orderByComparator); 679 } 680 681 /** 682 * Finds all the message boards threads where groupId = ? and status = ?. 683 * 684 * @param groupId the group ID to search with 685 * @param status the status to search with 686 * @return the matching message boards threads 687 * @throws SystemException if a system exception occurred 688 */ 689 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 690 long groupId, int status) 691 throws com.liferay.portal.kernel.exception.SystemException { 692 return getPersistence().findByG_S(groupId, status); 693 } 694 695 /** 696 * Finds a range of all the message boards threads where groupId = ? and status = ?. 697 * 698 * <p> 699 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 700 * </p> 701 * 702 * @param groupId the group ID to search with 703 * @param status the status to search with 704 * @param start the lower bound of the range of message boards threads to return 705 * @param end the upper bound of the range of message boards threads to return (not inclusive) 706 * @return the range of matching message boards threads 707 * @throws SystemException if a system exception occurred 708 */ 709 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 710 long groupId, int status, int start, int end) 711 throws com.liferay.portal.kernel.exception.SystemException { 712 return getPersistence().findByG_S(groupId, status, start, end); 713 } 714 715 /** 716 * Finds an ordered range of all the message boards threads where groupId = ? and status = ?. 717 * 718 * <p> 719 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 720 * </p> 721 * 722 * @param groupId the group ID to search with 723 * @param status the status to search with 724 * @param start the lower bound of the range of message boards threads to return 725 * @param end the upper bound of the range of message boards threads to return (not inclusive) 726 * @param orderByComparator the comparator to order the results by 727 * @return the ordered range of matching message boards threads 728 * @throws SystemException if a system exception occurred 729 */ 730 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 731 long groupId, int status, int start, int end, 732 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 733 throws com.liferay.portal.kernel.exception.SystemException { 734 return getPersistence() 735 .findByG_S(groupId, status, start, end, orderByComparator); 736 } 737 738 /** 739 * Finds the first message boards thread in the ordered set where groupId = ? and status = ?. 740 * 741 * <p> 742 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 743 * </p> 744 * 745 * @param groupId the group ID to search with 746 * @param status the status to search with 747 * @param orderByComparator the comparator to order the set by 748 * @return the first matching message boards thread 749 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 750 * @throws SystemException if a system exception occurred 751 */ 752 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First( 753 long groupId, int status, 754 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 755 throws com.liferay.portal.kernel.exception.SystemException, 756 com.liferay.portlet.messageboards.NoSuchThreadException { 757 return getPersistence() 758 .findByG_S_First(groupId, status, orderByComparator); 759 } 760 761 /** 762 * Finds the last message boards thread in the ordered set where groupId = ? and status = ?. 763 * 764 * <p> 765 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 766 * </p> 767 * 768 * @param groupId the group ID to search with 769 * @param status the status to search with 770 * @param orderByComparator the comparator to order the set by 771 * @return the last matching message boards thread 772 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 773 * @throws SystemException if a system exception occurred 774 */ 775 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last( 776 long groupId, int status, 777 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 778 throws com.liferay.portal.kernel.exception.SystemException, 779 com.liferay.portlet.messageboards.NoSuchThreadException { 780 return getPersistence() 781 .findByG_S_Last(groupId, status, orderByComparator); 782 } 783 784 /** 785 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and status = ?. 786 * 787 * <p> 788 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 789 * </p> 790 * 791 * @param threadId the primary key of the current message boards thread 792 * @param groupId the group ID to search with 793 * @param status the status to search with 794 * @param orderByComparator the comparator to order the set by 795 * @return the previous, current, and next message boards thread 796 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 797 * @throws SystemException if a system exception occurred 798 */ 799 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext( 800 long threadId, long groupId, int status, 801 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 802 throws com.liferay.portal.kernel.exception.SystemException, 803 com.liferay.portlet.messageboards.NoSuchThreadException { 804 return getPersistence() 805 .findByG_S_PrevAndNext(threadId, groupId, status, 806 orderByComparator); 807 } 808 809 /** 810 * Finds all the message boards threads where categoryId = ? and priority = ?. 811 * 812 * @param categoryId the category ID to search with 813 * @param priority the priority to search with 814 * @return the matching message boards threads 815 * @throws SystemException if a system exception occurred 816 */ 817 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 818 long categoryId, double priority) 819 throws com.liferay.portal.kernel.exception.SystemException { 820 return getPersistence().findByC_P(categoryId, priority); 821 } 822 823 /** 824 * Finds a range of all the message boards threads where categoryId = ? and priority = ?. 825 * 826 * <p> 827 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 828 * </p> 829 * 830 * @param categoryId the category ID to search with 831 * @param priority the priority to search with 832 * @param start the lower bound of the range of message boards threads to return 833 * @param end the upper bound of the range of message boards threads to return (not inclusive) 834 * @return the range of matching message boards threads 835 * @throws SystemException if a system exception occurred 836 */ 837 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 838 long categoryId, double priority, int start, int end) 839 throws com.liferay.portal.kernel.exception.SystemException { 840 return getPersistence().findByC_P(categoryId, priority, start, end); 841 } 842 843 /** 844 * Finds an ordered range of all the message boards threads where categoryId = ? and priority = ?. 845 * 846 * <p> 847 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 848 * </p> 849 * 850 * @param categoryId the category ID to search with 851 * @param priority the priority to search with 852 * @param start the lower bound of the range of message boards threads to return 853 * @param end the upper bound of the range of message boards threads to return (not inclusive) 854 * @param orderByComparator the comparator to order the results by 855 * @return the ordered range of matching message boards threads 856 * @throws SystemException if a system exception occurred 857 */ 858 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 859 long categoryId, double priority, int start, int end, 860 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 861 throws com.liferay.portal.kernel.exception.SystemException { 862 return getPersistence() 863 .findByC_P(categoryId, priority, start, end, 864 orderByComparator); 865 } 866 867 /** 868 * Finds the first message boards thread in the ordered set where categoryId = ? and priority = ?. 869 * 870 * <p> 871 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 872 * </p> 873 * 874 * @param categoryId the category ID to search with 875 * @param priority the priority to search with 876 * @param orderByComparator the comparator to order the set by 877 * @return the first matching message boards thread 878 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 879 * @throws SystemException if a system exception occurred 880 */ 881 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First( 882 long categoryId, double priority, 883 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 884 throws com.liferay.portal.kernel.exception.SystemException, 885 com.liferay.portlet.messageboards.NoSuchThreadException { 886 return getPersistence() 887 .findByC_P_First(categoryId, priority, orderByComparator); 888 } 889 890 /** 891 * Finds the last message boards thread in the ordered set where categoryId = ? and priority = ?. 892 * 893 * <p> 894 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 895 * </p> 896 * 897 * @param categoryId the category ID to search with 898 * @param priority the priority to search with 899 * @param orderByComparator the comparator to order the set by 900 * @return the last matching message boards thread 901 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 902 * @throws SystemException if a system exception occurred 903 */ 904 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last( 905 long categoryId, double priority, 906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 907 throws com.liferay.portal.kernel.exception.SystemException, 908 com.liferay.portlet.messageboards.NoSuchThreadException { 909 return getPersistence() 910 .findByC_P_Last(categoryId, priority, orderByComparator); 911 } 912 913 /** 914 * Finds the message boards threads before and after the current message boards thread in the ordered set where categoryId = ? and priority = ?. 915 * 916 * <p> 917 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 918 * </p> 919 * 920 * @param threadId the primary key of the current message boards thread 921 * @param categoryId the category ID to search with 922 * @param priority the priority to search with 923 * @param orderByComparator the comparator to order the set by 924 * @return the previous, current, and next message boards thread 925 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 926 * @throws SystemException if a system exception occurred 927 */ 928 public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext( 929 long threadId, long categoryId, double priority, 930 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 931 throws com.liferay.portal.kernel.exception.SystemException, 932 com.liferay.portlet.messageboards.NoSuchThreadException { 933 return getPersistence() 934 .findByC_P_PrevAndNext(threadId, categoryId, priority, 935 orderByComparator); 936 } 937 938 /** 939 * Finds all the message boards threads where lastPostDate = ? and priority = ?. 940 * 941 * @param lastPostDate the last post date to search with 942 * @param priority the priority to search with 943 * @return the matching message boards threads 944 * @throws SystemException if a system exception occurred 945 */ 946 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 947 java.util.Date lastPostDate, double priority) 948 throws com.liferay.portal.kernel.exception.SystemException { 949 return getPersistence().findByL_P(lastPostDate, priority); 950 } 951 952 /** 953 * Finds a range of all the message boards threads where lastPostDate = ? and priority = ?. 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 lastPostDate the last post date to search with 960 * @param priority the priority to search with 961 * @param start the lower bound of the range of message boards threads to return 962 * @param end the upper bound of the range of message boards threads to return (not inclusive) 963 * @return the range of matching message boards threads 964 * @throws SystemException if a system exception occurred 965 */ 966 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 967 java.util.Date lastPostDate, double priority, int start, int end) 968 throws com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence().findByL_P(lastPostDate, priority, start, end); 970 } 971 972 /** 973 * Finds an ordered range of all the message boards threads where lastPostDate = ? and priority = ?. 974 * 975 * <p> 976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 977 * </p> 978 * 979 * @param lastPostDate the last post date to search with 980 * @param priority the priority to search with 981 * @param start the lower bound of the range of message boards threads to return 982 * @param end the upper bound of the range of message boards threads to return (not inclusive) 983 * @param orderByComparator the comparator to order the results by 984 * @return the ordered range of matching message boards threads 985 * @throws SystemException if a system exception occurred 986 */ 987 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 988 java.util.Date lastPostDate, double priority, int start, int end, 989 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 990 throws com.liferay.portal.kernel.exception.SystemException { 991 return getPersistence() 992 .findByL_P(lastPostDate, priority, start, end, 993 orderByComparator); 994 } 995 996 /** 997 * Finds the first message boards thread in the ordered set where lastPostDate = ? and priority = ?. 998 * 999 * <p> 1000 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1001 * </p> 1002 * 1003 * @param lastPostDate the last post date to search with 1004 * @param priority the priority to search with 1005 * @param orderByComparator the comparator to order the set by 1006 * @return the first matching message boards thread 1007 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1008 * @throws SystemException if a system exception occurred 1009 */ 1010 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_First( 1011 java.util.Date lastPostDate, double priority, 1012 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1013 throws com.liferay.portal.kernel.exception.SystemException, 1014 com.liferay.portlet.messageboards.NoSuchThreadException { 1015 return getPersistence() 1016 .findByL_P_First(lastPostDate, priority, orderByComparator); 1017 } 1018 1019 /** 1020 * Finds the last message boards thread in the ordered set where lastPostDate = ? and priority = ?. 1021 * 1022 * <p> 1023 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1024 * </p> 1025 * 1026 * @param lastPostDate the last post date to search with 1027 * @param priority the priority to search with 1028 * @param orderByComparator the comparator to order the set by 1029 * @return the last matching message boards thread 1030 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1031 * @throws SystemException if a system exception occurred 1032 */ 1033 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_Last( 1034 java.util.Date lastPostDate, double priority, 1035 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1036 throws com.liferay.portal.kernel.exception.SystemException, 1037 com.liferay.portlet.messageboards.NoSuchThreadException { 1038 return getPersistence() 1039 .findByL_P_Last(lastPostDate, priority, orderByComparator); 1040 } 1041 1042 /** 1043 * Finds the message boards threads before and after the current message boards thread in the ordered set where lastPostDate = ? and priority = ?. 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 threadId the primary key of the current message boards thread 1050 * @param lastPostDate the last post date to search with 1051 * @param priority the priority to search with 1052 * @param orderByComparator the comparator to order the set by 1053 * @return the previous, current, and next message boards thread 1054 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1055 * @throws SystemException if a system exception occurred 1056 */ 1057 public static com.liferay.portlet.messageboards.model.MBThread[] findByL_P_PrevAndNext( 1058 long threadId, java.util.Date lastPostDate, double priority, 1059 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1060 throws com.liferay.portal.kernel.exception.SystemException, 1061 com.liferay.portlet.messageboards.NoSuchThreadException { 1062 return getPersistence() 1063 .findByL_P_PrevAndNext(threadId, lastPostDate, priority, 1064 orderByComparator); 1065 } 1066 1067 /** 1068 * Finds all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1069 * 1070 * @param groupId the group ID to search with 1071 * @param categoryId the category ID to search with 1072 * @param lastPostDate the last post date to search with 1073 * @return the matching message boards threads 1074 * @throws SystemException if a system exception occurred 1075 */ 1076 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1077 long groupId, long categoryId, java.util.Date lastPostDate) 1078 throws com.liferay.portal.kernel.exception.SystemException { 1079 return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate); 1080 } 1081 1082 /** 1083 * Finds a range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1084 * 1085 * <p> 1086 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1087 * </p> 1088 * 1089 * @param groupId the group ID to search with 1090 * @param categoryId the category ID to search with 1091 * @param lastPostDate the last post date to search with 1092 * @param start the lower bound of the range of message boards threads to return 1093 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1094 * @return the range of matching message boards threads 1095 * @throws SystemException if a system exception occurred 1096 */ 1097 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1098 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1099 int end) throws com.liferay.portal.kernel.exception.SystemException { 1100 return getPersistence() 1101 .findByG_C_L(groupId, categoryId, lastPostDate, start, end); 1102 } 1103 1104 /** 1105 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1106 * 1107 * <p> 1108 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1109 * </p> 1110 * 1111 * @param groupId the group ID to search with 1112 * @param categoryId the category ID to search with 1113 * @param lastPostDate the last post date to search with 1114 * @param start the lower bound of the range of message boards threads to return 1115 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1116 * @param orderByComparator the comparator to order the results by 1117 * @return the ordered range of matching message boards threads 1118 * @throws SystemException if a system exception occurred 1119 */ 1120 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 1121 long groupId, long categoryId, java.util.Date lastPostDate, int start, 1122 int end, 1123 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1124 throws com.liferay.portal.kernel.exception.SystemException { 1125 return getPersistence() 1126 .findByG_C_L(groupId, categoryId, lastPostDate, start, end, 1127 orderByComparator); 1128 } 1129 1130 /** 1131 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1132 * 1133 * <p> 1134 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1135 * </p> 1136 * 1137 * @param groupId the group ID to search with 1138 * @param categoryId the category ID to search with 1139 * @param lastPostDate the last post date to search with 1140 * @param orderByComparator the comparator to order the set by 1141 * @return the first matching message boards thread 1142 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1143 * @throws SystemException if a system exception occurred 1144 */ 1145 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First( 1146 long groupId, long categoryId, java.util.Date lastPostDate, 1147 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1148 throws com.liferay.portal.kernel.exception.SystemException, 1149 com.liferay.portlet.messageboards.NoSuchThreadException { 1150 return getPersistence() 1151 .findByG_C_L_First(groupId, categoryId, lastPostDate, 1152 orderByComparator); 1153 } 1154 1155 /** 1156 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1157 * 1158 * <p> 1159 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1160 * </p> 1161 * 1162 * @param groupId the group ID to search with 1163 * @param categoryId the category ID to search with 1164 * @param lastPostDate the last post date to search with 1165 * @param orderByComparator the comparator to order the set by 1166 * @return the last matching message boards thread 1167 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1168 * @throws SystemException if a system exception occurred 1169 */ 1170 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last( 1171 long groupId, long categoryId, java.util.Date lastPostDate, 1172 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1173 throws com.liferay.portal.kernel.exception.SystemException, 1174 com.liferay.portlet.messageboards.NoSuchThreadException { 1175 return getPersistence() 1176 .findByG_C_L_Last(groupId, categoryId, lastPostDate, 1177 orderByComparator); 1178 } 1179 1180 /** 1181 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 1182 * 1183 * <p> 1184 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1185 * </p> 1186 * 1187 * @param threadId the primary key of the current message boards thread 1188 * @param groupId the group ID to search with 1189 * @param categoryId the category ID to search with 1190 * @param lastPostDate the last post date to search with 1191 * @param orderByComparator the comparator to order the set by 1192 * @return the previous, current, and next message boards thread 1193 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1194 * @throws SystemException if a system exception occurred 1195 */ 1196 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext( 1197 long threadId, long groupId, long categoryId, 1198 java.util.Date lastPostDate, 1199 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1200 throws com.liferay.portal.kernel.exception.SystemException, 1201 com.liferay.portlet.messageboards.NoSuchThreadException { 1202 return getPersistence() 1203 .findByG_C_L_PrevAndNext(threadId, groupId, categoryId, 1204 lastPostDate, orderByComparator); 1205 } 1206 1207 /** 1208 * Finds all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1209 * 1210 * @param groupId the group ID to search with 1211 * @param categoryId the category ID to search with 1212 * @param status the status to search with 1213 * @return the matching message boards threads 1214 * @throws SystemException if a system exception occurred 1215 */ 1216 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1217 long groupId, long categoryId, int status) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 return getPersistence().findByG_C_S(groupId, categoryId, status); 1220 } 1221 1222 /** 1223 * Finds a range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1224 * 1225 * <p> 1226 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1227 * </p> 1228 * 1229 * @param groupId the group ID to search with 1230 * @param categoryId the category ID to search with 1231 * @param status the status to search with 1232 * @param start the lower bound of the range of message boards threads to return 1233 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1234 * @return the range of matching message boards threads 1235 * @throws SystemException if a system exception occurred 1236 */ 1237 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1238 long groupId, long categoryId, int status, int start, int end) 1239 throws com.liferay.portal.kernel.exception.SystemException { 1240 return getPersistence() 1241 .findByG_C_S(groupId, categoryId, status, start, end); 1242 } 1243 1244 /** 1245 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1246 * 1247 * <p> 1248 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1249 * </p> 1250 * 1251 * @param groupId the group ID to search with 1252 * @param categoryId the category ID to search with 1253 * @param status the status to search with 1254 * @param start the lower bound of the range of message boards threads to return 1255 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1256 * @param orderByComparator the comparator to order the results by 1257 * @return the ordered range of matching message boards threads 1258 * @throws SystemException if a system exception occurred 1259 */ 1260 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1261 long groupId, long categoryId, int status, int start, int end, 1262 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1263 throws com.liferay.portal.kernel.exception.SystemException { 1264 return getPersistence() 1265 .findByG_C_S(groupId, categoryId, status, start, end, 1266 orderByComparator); 1267 } 1268 1269 /** 1270 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1271 * 1272 * <p> 1273 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1274 * </p> 1275 * 1276 * @param groupId the group ID to search with 1277 * @param categoryId the category ID to search with 1278 * @param status the status to search with 1279 * @param orderByComparator the comparator to order the set by 1280 * @return the first matching message boards thread 1281 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1282 * @throws SystemException if a system exception occurred 1283 */ 1284 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First( 1285 long groupId, long categoryId, int status, 1286 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1287 throws com.liferay.portal.kernel.exception.SystemException, 1288 com.liferay.portlet.messageboards.NoSuchThreadException { 1289 return getPersistence() 1290 .findByG_C_S_First(groupId, categoryId, status, 1291 orderByComparator); 1292 } 1293 1294 /** 1295 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1296 * 1297 * <p> 1298 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1299 * </p> 1300 * 1301 * @param groupId the group ID to search with 1302 * @param categoryId the category ID to search with 1303 * @param status the status to search with 1304 * @param orderByComparator the comparator to order the set by 1305 * @return the last matching message boards thread 1306 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1307 * @throws SystemException if a system exception occurred 1308 */ 1309 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last( 1310 long groupId, long categoryId, int status, 1311 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1312 throws com.liferay.portal.kernel.exception.SystemException, 1313 com.liferay.portlet.messageboards.NoSuchThreadException { 1314 return getPersistence() 1315 .findByG_C_S_Last(groupId, categoryId, status, 1316 orderByComparator); 1317 } 1318 1319 /** 1320 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 1321 * 1322 * <p> 1323 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1324 * </p> 1325 * 1326 * @param threadId the primary key of the current message boards thread 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 previous, current, and next message boards thread 1332 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1333 * @throws SystemException if a system exception occurred 1334 */ 1335 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext( 1336 long threadId, 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_C_S_PrevAndNext(threadId, groupId, categoryId, 1342 status, orderByComparator); 1343 } 1344 1345 /** 1346 * Finds all the message boards threads where groupId = ? and categoryId = any ? 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 groupId the group ID to search with 1353 * @param categoryIds the category IDs to search with 1354 * @param status the status to search with 1355 * @return the matching message boards threads 1356 * @throws SystemException if a system exception occurred 1357 */ 1358 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1359 long groupId, long[] categoryIds, int status) 1360 throws com.liferay.portal.kernel.exception.SystemException { 1361 return getPersistence().findByG_C_S(groupId, categoryIds, status); 1362 } 1363 1364 /** 1365 * Finds a range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1366 * 1367 * <p> 1368 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1369 * </p> 1370 * 1371 * @param groupId the group ID to search with 1372 * @param categoryIds the category IDs to search with 1373 * @param status the status to search with 1374 * @param start the lower bound of the range of message boards threads to return 1375 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1376 * @return the range of matching message boards threads 1377 * @throws SystemException if a system exception occurred 1378 */ 1379 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1380 long groupId, long[] categoryIds, int status, int start, int end) 1381 throws com.liferay.portal.kernel.exception.SystemException { 1382 return getPersistence() 1383 .findByG_C_S(groupId, categoryIds, status, start, end); 1384 } 1385 1386 /** 1387 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1388 * 1389 * <p> 1390 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1391 * </p> 1392 * 1393 * @param groupId the group ID to search with 1394 * @param categoryIds the category IDs to search with 1395 * @param status the status to search with 1396 * @param start the lower bound of the range of message boards threads to return 1397 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1398 * @param orderByComparator the comparator to order the results by 1399 * @return the ordered range of matching message boards threads 1400 * @throws SystemException if a system exception occurred 1401 */ 1402 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 1403 long groupId, long[] categoryIds, int status, int start, int end, 1404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1405 throws com.liferay.portal.kernel.exception.SystemException { 1406 return getPersistence() 1407 .findByG_C_S(groupId, categoryIds, status, start, end, 1408 orderByComparator); 1409 } 1410 1411 /** 1412 * Finds all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1413 * 1414 * @param groupId the group ID to search with 1415 * @param categoryId the category ID to search with 1416 * @param status the status to search with 1417 * @return the matching message boards threads 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1421 long groupId, long categoryId, int status) 1422 throws com.liferay.portal.kernel.exception.SystemException { 1423 return getPersistence().findByG_NotC_S(groupId, categoryId, status); 1424 } 1425 1426 /** 1427 * Finds a range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1428 * 1429 * <p> 1430 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1431 * </p> 1432 * 1433 * @param groupId the group ID to search with 1434 * @param categoryId the category ID to search with 1435 * @param status the status to search with 1436 * @param start the lower bound of the range of message boards threads to return 1437 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1438 * @return the range of matching message boards threads 1439 * @throws SystemException if a system exception occurred 1440 */ 1441 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1442 long groupId, long categoryId, int status, int start, int end) 1443 throws com.liferay.portal.kernel.exception.SystemException { 1444 return getPersistence() 1445 .findByG_NotC_S(groupId, categoryId, status, start, end); 1446 } 1447 1448 /** 1449 * Finds an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1450 * 1451 * <p> 1452 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1453 * </p> 1454 * 1455 * @param groupId the group ID to search with 1456 * @param categoryId the category ID to search with 1457 * @param status the status to search with 1458 * @param start the lower bound of the range of message boards threads to return 1459 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1460 * @param orderByComparator the comparator to order the results by 1461 * @return the ordered range of matching message boards threads 1462 * @throws SystemException if a system exception occurred 1463 */ 1464 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 1465 long groupId, long categoryId, int status, int start, int end, 1466 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1467 throws com.liferay.portal.kernel.exception.SystemException { 1468 return getPersistence() 1469 .findByG_NotC_S(groupId, categoryId, status, start, end, 1470 orderByComparator); 1471 } 1472 1473 /** 1474 * Finds the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1475 * 1476 * <p> 1477 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1478 * </p> 1479 * 1480 * @param groupId the group ID to search with 1481 * @param categoryId the category ID to search with 1482 * @param status the status to search with 1483 * @param orderByComparator the comparator to order the set by 1484 * @return the first matching message boards thread 1485 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1486 * @throws SystemException if a system exception occurred 1487 */ 1488 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First( 1489 long groupId, long categoryId, int status, 1490 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1491 throws com.liferay.portal.kernel.exception.SystemException, 1492 com.liferay.portlet.messageboards.NoSuchThreadException { 1493 return getPersistence() 1494 .findByG_NotC_S_First(groupId, categoryId, status, 1495 orderByComparator); 1496 } 1497 1498 /** 1499 * Finds the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1500 * 1501 * <p> 1502 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1503 * </p> 1504 * 1505 * @param groupId the group ID to search with 1506 * @param categoryId the category ID to search with 1507 * @param status the status to search with 1508 * @param orderByComparator the comparator to order the set by 1509 * @return the last matching message boards thread 1510 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1511 * @throws SystemException if a system exception occurred 1512 */ 1513 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last( 1514 long groupId, long categoryId, int status, 1515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1516 throws com.liferay.portal.kernel.exception.SystemException, 1517 com.liferay.portlet.messageboards.NoSuchThreadException { 1518 return getPersistence() 1519 .findByG_NotC_S_Last(groupId, categoryId, status, 1520 orderByComparator); 1521 } 1522 1523 /** 1524 * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 1525 * 1526 * <p> 1527 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1528 * </p> 1529 * 1530 * @param threadId the primary key of the current message boards thread 1531 * @param groupId the group ID to search with 1532 * @param categoryId the category ID to search with 1533 * @param status the status to search with 1534 * @param orderByComparator the comparator to order the set by 1535 * @return the previous, current, and next message boards thread 1536 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1537 * @throws SystemException if a system exception occurred 1538 */ 1539 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext( 1540 long threadId, long groupId, long categoryId, int status, 1541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1542 throws com.liferay.portal.kernel.exception.SystemException, 1543 com.liferay.portlet.messageboards.NoSuchThreadException { 1544 return getPersistence() 1545 .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId, 1546 status, orderByComparator); 1547 } 1548 1549 /** 1550 * Finds all the message boards threads. 1551 * 1552 * @return the message boards threads 1553 * @throws SystemException if a system exception occurred 1554 */ 1555 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll() 1556 throws com.liferay.portal.kernel.exception.SystemException { 1557 return getPersistence().findAll(); 1558 } 1559 1560 /** 1561 * Finds a range of all the message boards threads. 1562 * 1563 * <p> 1564 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1565 * </p> 1566 * 1567 * @param start the lower bound of the range of message boards threads to return 1568 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1569 * @return the range of message boards threads 1570 * @throws SystemException if a system exception occurred 1571 */ 1572 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 1573 int start, int end) 1574 throws com.liferay.portal.kernel.exception.SystemException { 1575 return getPersistence().findAll(start, end); 1576 } 1577 1578 /** 1579 * Finds an ordered range of all the message boards threads. 1580 * 1581 * <p> 1582 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1583 * </p> 1584 * 1585 * @param start the lower bound of the range of message boards threads to return 1586 * @param end the upper bound of the range of message boards threads to return (not inclusive) 1587 * @param orderByComparator the comparator to order the results by 1588 * @return the ordered range of message boards threads 1589 * @throws SystemException if a system exception occurred 1590 */ 1591 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 1592 int start, int end, 1593 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1594 throws com.liferay.portal.kernel.exception.SystemException { 1595 return getPersistence().findAll(start, end, orderByComparator); 1596 } 1597 1598 /** 1599 * Removes all the message boards threads where groupId = ? from the database. 1600 * 1601 * @param groupId the group ID to search with 1602 * @throws SystemException if a system exception occurred 1603 */ 1604 public static void removeByGroupId(long groupId) 1605 throws com.liferay.portal.kernel.exception.SystemException { 1606 getPersistence().removeByGroupId(groupId); 1607 } 1608 1609 /** 1610 * Removes the message boards thread where rootMessageId = ? from the database. 1611 * 1612 * @param rootMessageId the root message ID to search with 1613 * @throws SystemException if a system exception occurred 1614 */ 1615 public static void removeByRootMessageId(long rootMessageId) 1616 throws com.liferay.portal.kernel.exception.SystemException, 1617 com.liferay.portlet.messageboards.NoSuchThreadException { 1618 getPersistence().removeByRootMessageId(rootMessageId); 1619 } 1620 1621 /** 1622 * Removes all the message boards threads where groupId = ? and categoryId = ? from the database. 1623 * 1624 * @param groupId the group ID to search with 1625 * @param categoryId the category ID to search with 1626 * @throws SystemException if a system exception occurred 1627 */ 1628 public static void removeByG_C(long groupId, long categoryId) 1629 throws com.liferay.portal.kernel.exception.SystemException { 1630 getPersistence().removeByG_C(groupId, categoryId); 1631 } 1632 1633 /** 1634 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? from the database. 1635 * 1636 * @param groupId the group ID to search with 1637 * @param categoryId the category ID to search with 1638 * @throws SystemException if a system exception occurred 1639 */ 1640 public static void removeByG_NotC(long groupId, long categoryId) 1641 throws com.liferay.portal.kernel.exception.SystemException { 1642 getPersistence().removeByG_NotC(groupId, categoryId); 1643 } 1644 1645 /** 1646 * Removes all the message boards threads where groupId = ? and status = ? from the database. 1647 * 1648 * @param groupId the group ID to search with 1649 * @param status the status to search with 1650 * @throws SystemException if a system exception occurred 1651 */ 1652 public static void removeByG_S(long groupId, int status) 1653 throws com.liferay.portal.kernel.exception.SystemException { 1654 getPersistence().removeByG_S(groupId, status); 1655 } 1656 1657 /** 1658 * Removes all the message boards threads where categoryId = ? and priority = ? from the database. 1659 * 1660 * @param categoryId the category ID to search with 1661 * @param priority the priority to search with 1662 * @throws SystemException if a system exception occurred 1663 */ 1664 public static void removeByC_P(long categoryId, double priority) 1665 throws com.liferay.portal.kernel.exception.SystemException { 1666 getPersistence().removeByC_P(categoryId, priority); 1667 } 1668 1669 /** 1670 * Removes all the message boards threads where lastPostDate = ? and priority = ? from the database. 1671 * 1672 * @param lastPostDate the last post date to search with 1673 * @param priority the priority to search with 1674 * @throws SystemException if a system exception occurred 1675 */ 1676 public static void removeByL_P(java.util.Date lastPostDate, double priority) 1677 throws com.liferay.portal.kernel.exception.SystemException { 1678 getPersistence().removeByL_P(lastPostDate, priority); 1679 } 1680 1681 /** 1682 * Removes all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ? from the database. 1683 * 1684 * @param groupId the group ID to search with 1685 * @param categoryId the category ID to search with 1686 * @param lastPostDate the last post date to search with 1687 * @throws SystemException if a system exception occurred 1688 */ 1689 public static void removeByG_C_L(long groupId, long categoryId, 1690 java.util.Date lastPostDate) 1691 throws com.liferay.portal.kernel.exception.SystemException { 1692 getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate); 1693 } 1694 1695 /** 1696 * Removes all the message boards threads where groupId = ? and categoryId = ? and status = ? from the database. 1697 * 1698 * @param groupId the group ID to search with 1699 * @param categoryId the category ID to search with 1700 * @param status the status to search with 1701 * @throws SystemException if a system exception occurred 1702 */ 1703 public static void removeByG_C_S(long groupId, long categoryId, int status) 1704 throws com.liferay.portal.kernel.exception.SystemException { 1705 getPersistence().removeByG_C_S(groupId, categoryId, status); 1706 } 1707 1708 /** 1709 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? and status = ? from the database. 1710 * 1711 * @param groupId the group ID to search with 1712 * @param categoryId the category ID to search with 1713 * @param status the status to search with 1714 * @throws SystemException if a system exception occurred 1715 */ 1716 public static void removeByG_NotC_S(long groupId, long categoryId, 1717 int status) throws com.liferay.portal.kernel.exception.SystemException { 1718 getPersistence().removeByG_NotC_S(groupId, categoryId, status); 1719 } 1720 1721 /** 1722 * Removes all the message boards threads from the database. 1723 * 1724 * @throws SystemException if a system exception occurred 1725 */ 1726 public static void removeAll() 1727 throws com.liferay.portal.kernel.exception.SystemException { 1728 getPersistence().removeAll(); 1729 } 1730 1731 /** 1732 * Counts all the message boards threads where groupId = ?. 1733 * 1734 * @param groupId the group ID to search with 1735 * @return the number of matching message boards threads 1736 * @throws SystemException if a system exception occurred 1737 */ 1738 public static int countByGroupId(long groupId) 1739 throws com.liferay.portal.kernel.exception.SystemException { 1740 return getPersistence().countByGroupId(groupId); 1741 } 1742 1743 /** 1744 * Counts all the message boards threads where rootMessageId = ?. 1745 * 1746 * @param rootMessageId the root message ID to search with 1747 * @return the number of matching message boards threads 1748 * @throws SystemException if a system exception occurred 1749 */ 1750 public static int countByRootMessageId(long rootMessageId) 1751 throws com.liferay.portal.kernel.exception.SystemException { 1752 return getPersistence().countByRootMessageId(rootMessageId); 1753 } 1754 1755 /** 1756 * Counts all the message boards threads where groupId = ? and categoryId = ?. 1757 * 1758 * @param groupId the group ID to search with 1759 * @param categoryId the category ID to search with 1760 * @return the number of matching message boards threads 1761 * @throws SystemException if a system exception occurred 1762 */ 1763 public static int countByG_C(long groupId, long categoryId) 1764 throws com.liferay.portal.kernel.exception.SystemException { 1765 return getPersistence().countByG_C(groupId, categoryId); 1766 } 1767 1768 /** 1769 * Counts all the message boards threads where groupId = ? and categoryId = any ?. 1770 * 1771 * @param groupId the group ID to search with 1772 * @param categoryIds the category IDs to search with 1773 * @return the number of matching message boards threads 1774 * @throws SystemException if a system exception occurred 1775 */ 1776 public static int countByG_C(long groupId, long[] categoryIds) 1777 throws com.liferay.portal.kernel.exception.SystemException { 1778 return getPersistence().countByG_C(groupId, categoryIds); 1779 } 1780 1781 /** 1782 * Counts all the message boards threads where groupId = ? and categoryId ≠ ?. 1783 * 1784 * @param groupId the group ID to search with 1785 * @param categoryId the category ID to search with 1786 * @return the number of matching message boards threads 1787 * @throws SystemException if a system exception occurred 1788 */ 1789 public static int countByG_NotC(long groupId, long categoryId) 1790 throws com.liferay.portal.kernel.exception.SystemException { 1791 return getPersistence().countByG_NotC(groupId, categoryId); 1792 } 1793 1794 /** 1795 * Counts all the message boards threads where groupId = ? and status = ?. 1796 * 1797 * @param groupId the group ID to search with 1798 * @param status the status to search with 1799 * @return the number of matching message boards threads 1800 * @throws SystemException if a system exception occurred 1801 */ 1802 public static int countByG_S(long groupId, int status) 1803 throws com.liferay.portal.kernel.exception.SystemException { 1804 return getPersistence().countByG_S(groupId, status); 1805 } 1806 1807 /** 1808 * Counts all the message boards threads where categoryId = ? and priority = ?. 1809 * 1810 * @param categoryId the category ID to search with 1811 * @param priority the priority to search with 1812 * @return the number of matching message boards threads 1813 * @throws SystemException if a system exception occurred 1814 */ 1815 public static int countByC_P(long categoryId, double priority) 1816 throws com.liferay.portal.kernel.exception.SystemException { 1817 return getPersistence().countByC_P(categoryId, priority); 1818 } 1819 1820 /** 1821 * Counts all the message boards threads where lastPostDate = ? and priority = ?. 1822 * 1823 * @param lastPostDate the last post date to search with 1824 * @param priority the priority to search with 1825 * @return the number of matching message boards threads 1826 * @throws SystemException if a system exception occurred 1827 */ 1828 public static int countByL_P(java.util.Date lastPostDate, double priority) 1829 throws com.liferay.portal.kernel.exception.SystemException { 1830 return getPersistence().countByL_P(lastPostDate, priority); 1831 } 1832 1833 /** 1834 * Counts all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 1835 * 1836 * @param groupId the group ID to search with 1837 * @param categoryId the category ID to search with 1838 * @param lastPostDate the last post date to search with 1839 * @return the number of matching message boards threads 1840 * @throws SystemException if a system exception occurred 1841 */ 1842 public static int countByG_C_L(long groupId, long categoryId, 1843 java.util.Date lastPostDate) 1844 throws com.liferay.portal.kernel.exception.SystemException { 1845 return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate); 1846 } 1847 1848 /** 1849 * Counts all the message boards threads where groupId = ? and categoryId = ? and status = ?. 1850 * 1851 * @param groupId the group ID to search with 1852 * @param categoryId the category ID to search with 1853 * @param status the status to search with 1854 * @return the number of matching message boards threads 1855 * @throws SystemException if a system exception occurred 1856 */ 1857 public static int countByG_C_S(long groupId, long categoryId, int status) 1858 throws com.liferay.portal.kernel.exception.SystemException { 1859 return getPersistence().countByG_C_S(groupId, categoryId, status); 1860 } 1861 1862 /** 1863 * Counts all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 1864 * 1865 * @param groupId the group ID to search with 1866 * @param categoryIds the category IDs to search with 1867 * @param status the status to search with 1868 * @return the number of matching message boards threads 1869 * @throws SystemException if a system exception occurred 1870 */ 1871 public static int countByG_C_S(long groupId, long[] categoryIds, int status) 1872 throws com.liferay.portal.kernel.exception.SystemException { 1873 return getPersistence().countByG_C_S(groupId, categoryIds, status); 1874 } 1875 1876 /** 1877 * Counts all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 1878 * 1879 * @param groupId the group ID to search with 1880 * @param categoryId the category ID to search with 1881 * @param status the status to search with 1882 * @return the number of matching message boards threads 1883 * @throws SystemException if a system exception occurred 1884 */ 1885 public static int countByG_NotC_S(long groupId, long categoryId, int status) 1886 throws com.liferay.portal.kernel.exception.SystemException { 1887 return getPersistence().countByG_NotC_S(groupId, categoryId, status); 1888 } 1889 1890 /** 1891 * Counts all the message boards threads. 1892 * 1893 * @return the number of message boards threads 1894 * @throws SystemException if a system exception occurred 1895 */ 1896 public static int countAll() 1897 throws com.liferay.portal.kernel.exception.SystemException { 1898 return getPersistence().countAll(); 1899 } 1900 1901 public static MBThreadPersistence getPersistence() { 1902 if (_persistence == null) { 1903 _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName()); 1904 1905 ReferenceRegistry.registerReference(MBThreadUtil.class, 1906 "_persistence"); 1907 } 1908 1909 return _persistence; 1910 } 1911 1912 public void setPersistence(MBThreadPersistence persistence) { 1913 _persistence = persistence; 1914 1915 ReferenceRegistry.registerReference(MBThreadUtil.class, "_persistence"); 1916 } 1917 1918 private static MBThreadPersistence _persistence; 1919 }