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