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