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