001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.messageboards.model.MBThread; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the message boards thread service. This utility wraps {@link MBThreadPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see MBThreadPersistence 037 * @see MBThreadPersistenceImpl 038 * @generated 039 */ 040 public class MBThreadUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(MBThread mbThread) { 058 getPersistence().clearCache(mbThread); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery) 073 throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<MBThread> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<MBThread> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static MBThread update(MBThread mbThread) throws SystemException { 101 return getPersistence().update(mbThread); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static MBThread update(MBThread mbThread, 108 ServiceContext serviceContext) throws SystemException { 109 return getPersistence().update(mbThread, serviceContext); 110 } 111 112 /** 113 * Returns all the message boards threads where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching message boards threads 117 * @throws SystemException if a system exception occurred 118 */ 119 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid( 120 java.lang.String uuid) 121 throws com.liferay.portal.kernel.exception.SystemException { 122 return getPersistence().findByUuid(uuid); 123 } 124 125 /** 126 * Returns a range of all the message boards threads where uuid = ?. 127 * 128 * <p> 129 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 130 * </p> 131 * 132 * @param uuid the uuid 133 * @param start the lower bound of the range of message boards threads 134 * @param end the upper bound of the range of message boards threads (not inclusive) 135 * @return the range of matching message boards threads 136 * @throws SystemException if a system exception occurred 137 */ 138 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid( 139 java.lang.String uuid, int start, int end) 140 throws com.liferay.portal.kernel.exception.SystemException { 141 return getPersistence().findByUuid(uuid, start, end); 142 } 143 144 /** 145 * Returns an ordered range of all the message boards threads where uuid = ?. 146 * 147 * <p> 148 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 149 * </p> 150 * 151 * @param uuid the uuid 152 * @param start the lower bound of the range of message boards threads 153 * @param end the upper bound of the range of message boards threads (not inclusive) 154 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 155 * @return the ordered range of matching message boards threads 156 * @throws SystemException if a system exception occurred 157 */ 158 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid( 159 java.lang.String uuid, int start, int end, 160 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 161 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 163 } 164 165 /** 166 * Returns the first message boards thread in the ordered set where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 170 * @return the first matching message boards thread 171 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portlet.messageboards.model.MBThread findByUuid_First( 175 java.lang.String uuid, 176 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 177 throws com.liferay.portal.kernel.exception.SystemException, 178 com.liferay.portlet.messageboards.NoSuchThreadException { 179 return getPersistence().findByUuid_First(uuid, orderByComparator); 180 } 181 182 /** 183 * Returns the first message boards thread in the ordered set where uuid = ?. 184 * 185 * @param uuid the uuid 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 188 * @throws SystemException if a system exception occurred 189 */ 190 public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_First( 191 java.lang.String uuid, 192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 193 throws com.liferay.portal.kernel.exception.SystemException { 194 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last message boards thread in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching message boards thread 203 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 204 * @throws SystemException if a system exception occurred 205 */ 206 public static com.liferay.portlet.messageboards.model.MBThread findByUuid_Last( 207 java.lang.String uuid, 208 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 209 throws com.liferay.portal.kernel.exception.SystemException, 210 com.liferay.portlet.messageboards.NoSuchThreadException { 211 return getPersistence().findByUuid_Last(uuid, orderByComparator); 212 } 213 214 /** 215 * Returns the last message boards thread in the ordered set where uuid = ?. 216 * 217 * @param uuid the uuid 218 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 219 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 220 * @throws SystemException if a system exception occurred 221 */ 222 public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_Last( 223 java.lang.String uuid, 224 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 225 throws com.liferay.portal.kernel.exception.SystemException { 226 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 227 } 228 229 /** 230 * Returns the message boards threads before and after the current message boards thread in the ordered set where uuid = ?. 231 * 232 * @param threadId the primary key of the current message boards thread 233 * @param uuid the uuid 234 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 235 * @return the previous, current, and next message boards thread 236 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 237 * @throws SystemException if a system exception occurred 238 */ 239 public static com.liferay.portlet.messageboards.model.MBThread[] findByUuid_PrevAndNext( 240 long threadId, java.lang.String uuid, 241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 242 throws com.liferay.portal.kernel.exception.SystemException, 243 com.liferay.portlet.messageboards.NoSuchThreadException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(threadId, uuid, orderByComparator); 246 } 247 248 /** 249 * Removes all the message boards threads where uuid = ? from the database. 250 * 251 * @param uuid the uuid 252 * @throws SystemException if a system exception occurred 253 */ 254 public static void removeByUuid(java.lang.String uuid) 255 throws com.liferay.portal.kernel.exception.SystemException { 256 getPersistence().removeByUuid(uuid); 257 } 258 259 /** 260 * Returns the number of message boards threads where uuid = ?. 261 * 262 * @param uuid the uuid 263 * @return the number of matching message boards threads 264 * @throws SystemException if a system exception occurred 265 */ 266 public static int countByUuid(java.lang.String uuid) 267 throws com.liferay.portal.kernel.exception.SystemException { 268 return getPersistence().countByUuid(uuid); 269 } 270 271 /** 272 * Returns the message boards thread where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 273 * 274 * @param uuid the uuid 275 * @param groupId the group ID 276 * @return the matching message boards thread 277 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 278 * @throws SystemException if a system exception occurred 279 */ 280 public static com.liferay.portlet.messageboards.model.MBThread findByUUID_G( 281 java.lang.String uuid, long groupId) 282 throws com.liferay.portal.kernel.exception.SystemException, 283 com.liferay.portlet.messageboards.NoSuchThreadException { 284 return getPersistence().findByUUID_G(uuid, groupId); 285 } 286 287 /** 288 * Returns the message boards thread where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 289 * 290 * @param uuid the uuid 291 * @param groupId the group ID 292 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 293 * @throws SystemException if a system exception occurred 294 */ 295 public static com.liferay.portlet.messageboards.model.MBThread fetchByUUID_G( 296 java.lang.String uuid, long groupId) 297 throws com.liferay.portal.kernel.exception.SystemException { 298 return getPersistence().fetchByUUID_G(uuid, groupId); 299 } 300 301 /** 302 * Returns the message boards thread where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 303 * 304 * @param uuid the uuid 305 * @param groupId the group ID 306 * @param retrieveFromCache whether to use the finder cache 307 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 308 * @throws SystemException if a system exception occurred 309 */ 310 public static com.liferay.portlet.messageboards.model.MBThread fetchByUUID_G( 311 java.lang.String uuid, long groupId, boolean retrieveFromCache) 312 throws com.liferay.portal.kernel.exception.SystemException { 313 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 314 } 315 316 /** 317 * Removes the message boards thread where uuid = ? and groupId = ? from the database. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the message boards thread that was removed 322 * @throws SystemException if a system exception occurred 323 */ 324 public static com.liferay.portlet.messageboards.model.MBThread removeByUUID_G( 325 java.lang.String uuid, long groupId) 326 throws com.liferay.portal.kernel.exception.SystemException, 327 com.liferay.portlet.messageboards.NoSuchThreadException { 328 return getPersistence().removeByUUID_G(uuid, groupId); 329 } 330 331 /** 332 * Returns the number of message boards threads where uuid = ? and groupId = ?. 333 * 334 * @param uuid the uuid 335 * @param groupId the group ID 336 * @return the number of matching message boards threads 337 * @throws SystemException if a system exception occurred 338 */ 339 public static int countByUUID_G(java.lang.String uuid, long groupId) 340 throws com.liferay.portal.kernel.exception.SystemException { 341 return getPersistence().countByUUID_G(uuid, groupId); 342 } 343 344 /** 345 * Returns all the message boards threads where uuid = ? and companyId = ?. 346 * 347 * @param uuid the uuid 348 * @param companyId the company ID 349 * @return the matching message boards threads 350 * @throws SystemException if a system exception occurred 351 */ 352 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C( 353 java.lang.String uuid, long companyId) 354 throws com.liferay.portal.kernel.exception.SystemException { 355 return getPersistence().findByUuid_C(uuid, companyId); 356 } 357 358 /** 359 * Returns a range of all the message boards threads where uuid = ? and companyId = ?. 360 * 361 * <p> 362 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 363 * </p> 364 * 365 * @param uuid the uuid 366 * @param companyId the company ID 367 * @param start the lower bound of the range of message boards threads 368 * @param end the upper bound of the range of message boards threads (not inclusive) 369 * @return the range of matching message boards threads 370 * @throws SystemException if a system exception occurred 371 */ 372 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C( 373 java.lang.String uuid, long companyId, int start, int end) 374 throws com.liferay.portal.kernel.exception.SystemException { 375 return getPersistence().findByUuid_C(uuid, companyId, start, end); 376 } 377 378 /** 379 * Returns an ordered range of all the message boards threads where uuid = ? and companyId = ?. 380 * 381 * <p> 382 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 383 * </p> 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param start the lower bound of the range of message boards threads 388 * @param end the upper bound of the range of message boards threads (not inclusive) 389 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 390 * @return the ordered range of matching message boards threads 391 * @throws SystemException if a system exception occurred 392 */ 393 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C( 394 java.lang.String uuid, long companyId, int start, int end, 395 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 396 throws com.liferay.portal.kernel.exception.SystemException { 397 return getPersistence() 398 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 399 } 400 401 /** 402 * Returns the first message boards thread in the ordered set where uuid = ? and companyId = ?. 403 * 404 * @param uuid the uuid 405 * @param companyId the company ID 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the first 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 findByUuid_C_First( 412 java.lang.String uuid, long companyId, 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 .findByUuid_C_First(uuid, companyId, orderByComparator); 418 } 419 420 /** 421 * Returns the first message boards thread in the ordered set where uuid = ? and companyId = ?. 422 * 423 * @param uuid the uuid 424 * @param companyId the company ID 425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 426 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 427 * @throws SystemException if a system exception occurred 428 */ 429 public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_C_First( 430 java.lang.String uuid, long companyId, 431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 432 throws com.liferay.portal.kernel.exception.SystemException { 433 return getPersistence() 434 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 435 } 436 437 /** 438 * Returns the last message boards thread in the ordered set where uuid = ? and companyId = ?. 439 * 440 * @param uuid the uuid 441 * @param companyId the company ID 442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 443 * @return the last matching message boards thread 444 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 445 * @throws SystemException if a system exception occurred 446 */ 447 public static com.liferay.portlet.messageboards.model.MBThread findByUuid_C_Last( 448 java.lang.String uuid, long companyId, 449 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 450 throws com.liferay.portal.kernel.exception.SystemException, 451 com.liferay.portlet.messageboards.NoSuchThreadException { 452 return getPersistence() 453 .findByUuid_C_Last(uuid, companyId, orderByComparator); 454 } 455 456 /** 457 * Returns the last message boards thread in the ordered set where uuid = ? and companyId = ?. 458 * 459 * @param uuid the uuid 460 * @param companyId the company ID 461 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 462 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 463 * @throws SystemException if a system exception occurred 464 */ 465 public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_C_Last( 466 java.lang.String uuid, long companyId, 467 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 468 throws com.liferay.portal.kernel.exception.SystemException { 469 return getPersistence() 470 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 471 } 472 473 /** 474 * Returns the message boards threads before and after the current message boards thread in the ordered set where uuid = ? and companyId = ?. 475 * 476 * @param threadId the primary key of the current message boards thread 477 * @param uuid the uuid 478 * @param companyId the company ID 479 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 480 * @return the previous, current, and next message boards thread 481 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 482 * @throws SystemException if a system exception occurred 483 */ 484 public static com.liferay.portlet.messageboards.model.MBThread[] findByUuid_C_PrevAndNext( 485 long threadId, java.lang.String uuid, long companyId, 486 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 487 throws com.liferay.portal.kernel.exception.SystemException, 488 com.liferay.portlet.messageboards.NoSuchThreadException { 489 return getPersistence() 490 .findByUuid_C_PrevAndNext(threadId, uuid, companyId, 491 orderByComparator); 492 } 493 494 /** 495 * Removes all the message boards threads where uuid = ? and companyId = ? from the database. 496 * 497 * @param uuid the uuid 498 * @param companyId the company ID 499 * @throws SystemException if a system exception occurred 500 */ 501 public static void removeByUuid_C(java.lang.String uuid, long companyId) 502 throws com.liferay.portal.kernel.exception.SystemException { 503 getPersistence().removeByUuid_C(uuid, companyId); 504 } 505 506 /** 507 * Returns the number of message boards threads where uuid = ? and companyId = ?. 508 * 509 * @param uuid the uuid 510 * @param companyId the company ID 511 * @return the number of matching message boards threads 512 * @throws SystemException if a system exception occurred 513 */ 514 public static int countByUuid_C(java.lang.String uuid, long companyId) 515 throws com.liferay.portal.kernel.exception.SystemException { 516 return getPersistence().countByUuid_C(uuid, companyId); 517 } 518 519 /** 520 * Returns all the message boards threads where groupId = ?. 521 * 522 * @param groupId the group ID 523 * @return the matching message boards threads 524 * @throws SystemException if a system exception occurred 525 */ 526 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 527 long groupId) 528 throws com.liferay.portal.kernel.exception.SystemException { 529 return getPersistence().findByGroupId(groupId); 530 } 531 532 /** 533 * Returns a range of all the message boards threads where groupId = ?. 534 * 535 * <p> 536 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 537 * </p> 538 * 539 * @param groupId the group ID 540 * @param start the lower bound of the range of message boards threads 541 * @param end the upper bound of the range of message boards threads (not inclusive) 542 * @return the range of matching message boards threads 543 * @throws SystemException if a system exception occurred 544 */ 545 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 546 long groupId, int start, int end) 547 throws com.liferay.portal.kernel.exception.SystemException { 548 return getPersistence().findByGroupId(groupId, start, end); 549 } 550 551 /** 552 * Returns an ordered range of all the message boards threads where groupId = ?. 553 * 554 * <p> 555 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 556 * </p> 557 * 558 * @param groupId the group ID 559 * @param start the lower bound of the range of message boards threads 560 * @param end the upper bound of the range of message boards threads (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @return the ordered range of matching message boards threads 563 * @throws SystemException if a system exception occurred 564 */ 565 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId( 566 long groupId, int start, int end, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence() 570 .findByGroupId(groupId, start, end, orderByComparator); 571 } 572 573 /** 574 * Returns the first message boards thread in the ordered set where groupId = ?. 575 * 576 * @param groupId the group ID 577 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 578 * @return the first matching message boards thread 579 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 580 * @throws SystemException if a system exception occurred 581 */ 582 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First( 583 long groupId, 584 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 585 throws com.liferay.portal.kernel.exception.SystemException, 586 com.liferay.portlet.messageboards.NoSuchThreadException { 587 return getPersistence().findByGroupId_First(groupId, orderByComparator); 588 } 589 590 /** 591 * Returns the first message boards thread in the ordered set where groupId = ?. 592 * 593 * @param groupId the group ID 594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 595 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 596 * @throws SystemException if a system exception occurred 597 */ 598 public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_First( 599 long groupId, 600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 601 throws com.liferay.portal.kernel.exception.SystemException { 602 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 603 } 604 605 /** 606 * Returns the last message boards thread in the ordered set where groupId = ?. 607 * 608 * @param groupId the group ID 609 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 610 * @return the last matching message boards thread 611 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 612 * @throws SystemException if a system exception occurred 613 */ 614 public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last( 615 long groupId, 616 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 617 throws com.liferay.portal.kernel.exception.SystemException, 618 com.liferay.portlet.messageboards.NoSuchThreadException { 619 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 620 } 621 622 /** 623 * Returns the last message boards thread in the ordered set where groupId = ?. 624 * 625 * @param groupId the group ID 626 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 627 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 628 * @throws SystemException if a system exception occurred 629 */ 630 public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_Last( 631 long groupId, 632 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 633 throws com.liferay.portal.kernel.exception.SystemException { 634 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 635 } 636 637 /** 638 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ?. 639 * 640 * @param threadId the primary key of the current message boards thread 641 * @param groupId the group ID 642 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 643 * @return the previous, current, and next message boards thread 644 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 645 * @throws SystemException if a system exception occurred 646 */ 647 public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext( 648 long threadId, long groupId, 649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 650 throws com.liferay.portal.kernel.exception.SystemException, 651 com.liferay.portlet.messageboards.NoSuchThreadException { 652 return getPersistence() 653 .findByGroupId_PrevAndNext(threadId, groupId, 654 orderByComparator); 655 } 656 657 /** 658 * Returns all the message boards threads that the user has permission to view where groupId = ?. 659 * 660 * @param groupId the group ID 661 * @return the matching message boards threads that the user has permission to view 662 * @throws SystemException if a system exception occurred 663 */ 664 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 665 long groupId) 666 throws com.liferay.portal.kernel.exception.SystemException { 667 return getPersistence().filterFindByGroupId(groupId); 668 } 669 670 /** 671 * Returns a range of all the message boards threads that the user has permission to view where groupId = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 675 * </p> 676 * 677 * @param groupId the group ID 678 * @param start the lower bound of the range of message boards threads 679 * @param end the upper bound of the range of message boards threads (not inclusive) 680 * @return the range of matching message boards threads that the user has permission to view 681 * @throws SystemException if a system exception occurred 682 */ 683 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 684 long groupId, int start, int end) 685 throws com.liferay.portal.kernel.exception.SystemException { 686 return getPersistence().filterFindByGroupId(groupId, start, end); 687 } 688 689 /** 690 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ?. 691 * 692 * <p> 693 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 694 * </p> 695 * 696 * @param groupId the group ID 697 * @param start the lower bound of the range of message boards threads 698 * @param end the upper bound of the range of message boards threads (not inclusive) 699 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 700 * @return the ordered range of matching message boards threads that the user has permission to view 701 * @throws SystemException if a system exception occurred 702 */ 703 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId( 704 long groupId, int start, int end, 705 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 706 throws com.liferay.portal.kernel.exception.SystemException { 707 return getPersistence() 708 .filterFindByGroupId(groupId, start, end, orderByComparator); 709 } 710 711 /** 712 * 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 = ?. 713 * 714 * @param threadId the primary key of the current message boards thread 715 * @param groupId the group ID 716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 717 * @return the previous, current, and next message boards thread 718 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 719 * @throws SystemException if a system exception occurred 720 */ 721 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByGroupId_PrevAndNext( 722 long threadId, long groupId, 723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 724 throws com.liferay.portal.kernel.exception.SystemException, 725 com.liferay.portlet.messageboards.NoSuchThreadException { 726 return getPersistence() 727 .filterFindByGroupId_PrevAndNext(threadId, groupId, 728 orderByComparator); 729 } 730 731 /** 732 * Removes all the message boards threads where groupId = ? from the database. 733 * 734 * @param groupId the group ID 735 * @throws SystemException if a system exception occurred 736 */ 737 public static void removeByGroupId(long groupId) 738 throws com.liferay.portal.kernel.exception.SystemException { 739 getPersistence().removeByGroupId(groupId); 740 } 741 742 /** 743 * Returns the number of message boards threads where groupId = ?. 744 * 745 * @param groupId the group ID 746 * @return the number of matching message boards threads 747 * @throws SystemException if a system exception occurred 748 */ 749 public static int countByGroupId(long groupId) 750 throws com.liferay.portal.kernel.exception.SystemException { 751 return getPersistence().countByGroupId(groupId); 752 } 753 754 /** 755 * Returns the number of message boards threads that the user has permission to view where groupId = ?. 756 * 757 * @param groupId the group ID 758 * @return the number of matching message boards threads that the user has permission to view 759 * @throws SystemException if a system exception occurred 760 */ 761 public static int filterCountByGroupId(long groupId) 762 throws com.liferay.portal.kernel.exception.SystemException { 763 return getPersistence().filterCountByGroupId(groupId); 764 } 765 766 /** 767 * Returns the message boards thread where rootMessageId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 768 * 769 * @param rootMessageId the root message ID 770 * @return the matching message boards thread 771 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 772 * @throws SystemException if a system exception occurred 773 */ 774 public static com.liferay.portlet.messageboards.model.MBThread findByRootMessageId( 775 long rootMessageId) 776 throws com.liferay.portal.kernel.exception.SystemException, 777 com.liferay.portlet.messageboards.NoSuchThreadException { 778 return getPersistence().findByRootMessageId(rootMessageId); 779 } 780 781 /** 782 * Returns the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 783 * 784 * @param rootMessageId the root message ID 785 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 786 * @throws SystemException if a system exception occurred 787 */ 788 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 789 long rootMessageId) 790 throws com.liferay.portal.kernel.exception.SystemException { 791 return getPersistence().fetchByRootMessageId(rootMessageId); 792 } 793 794 /** 795 * Returns the message boards thread where rootMessageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 796 * 797 * @param rootMessageId the root message ID 798 * @param retrieveFromCache whether to use the finder cache 799 * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId( 803 long rootMessageId, boolean retrieveFromCache) 804 throws com.liferay.portal.kernel.exception.SystemException { 805 return getPersistence() 806 .fetchByRootMessageId(rootMessageId, retrieveFromCache); 807 } 808 809 /** 810 * Removes the message boards thread where rootMessageId = ? from the database. 811 * 812 * @param rootMessageId the root message ID 813 * @return the message boards thread that was removed 814 * @throws SystemException if a system exception occurred 815 */ 816 public static com.liferay.portlet.messageboards.model.MBThread removeByRootMessageId( 817 long rootMessageId) 818 throws com.liferay.portal.kernel.exception.SystemException, 819 com.liferay.portlet.messageboards.NoSuchThreadException { 820 return getPersistence().removeByRootMessageId(rootMessageId); 821 } 822 823 /** 824 * Returns the number of message boards threads where rootMessageId = ?. 825 * 826 * @param rootMessageId the root message ID 827 * @return the number of matching message boards threads 828 * @throws SystemException if a system exception occurred 829 */ 830 public static int countByRootMessageId(long rootMessageId) 831 throws com.liferay.portal.kernel.exception.SystemException { 832 return getPersistence().countByRootMessageId(rootMessageId); 833 } 834 835 /** 836 * Returns all the message boards threads where groupId = ? and categoryId = ?. 837 * 838 * @param groupId the group ID 839 * @param categoryId the category ID 840 * @return the matching message boards threads 841 * @throws SystemException if a system exception occurred 842 */ 843 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 844 long groupId, long categoryId) 845 throws com.liferay.portal.kernel.exception.SystemException { 846 return getPersistence().findByG_C(groupId, categoryId); 847 } 848 849 /** 850 * Returns a range of all the message boards threads where groupId = ? and categoryId = ?. 851 * 852 * <p> 853 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 854 * </p> 855 * 856 * @param groupId the group ID 857 * @param categoryId the category ID 858 * @param start the lower bound of the range of message boards threads 859 * @param end the upper bound of the range of message boards threads (not inclusive) 860 * @return the range of matching message boards threads 861 * @throws SystemException if a system exception occurred 862 */ 863 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 864 long groupId, long categoryId, int start, int end) 865 throws com.liferay.portal.kernel.exception.SystemException { 866 return getPersistence().findByG_C(groupId, categoryId, start, end); 867 } 868 869 /** 870 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ?. 871 * 872 * <p> 873 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 874 * </p> 875 * 876 * @param groupId the group ID 877 * @param categoryId the category ID 878 * @param start the lower bound of the range of message boards threads 879 * @param end the upper bound of the range of message boards threads (not inclusive) 880 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 881 * @return the ordered range of matching message boards threads 882 * @throws SystemException if a system exception occurred 883 */ 884 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 885 long groupId, long categoryId, int start, int end, 886 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 887 throws com.liferay.portal.kernel.exception.SystemException { 888 return getPersistence() 889 .findByG_C(groupId, categoryId, start, end, orderByComparator); 890 } 891 892 /** 893 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 894 * 895 * @param groupId the group ID 896 * @param categoryId the category ID 897 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 898 * @return the first matching message boards thread 899 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 900 * @throws SystemException if a system exception occurred 901 */ 902 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First( 903 long groupId, long categoryId, 904 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 905 throws com.liferay.portal.kernel.exception.SystemException, 906 com.liferay.portlet.messageboards.NoSuchThreadException { 907 return getPersistence() 908 .findByG_C_First(groupId, categoryId, orderByComparator); 909 } 910 911 /** 912 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ?. 913 * 914 * @param groupId the group ID 915 * @param categoryId the category ID 916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 917 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 918 * @throws SystemException if a system exception occurred 919 */ 920 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_First( 921 long groupId, long categoryId, 922 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 923 throws com.liferay.portal.kernel.exception.SystemException { 924 return getPersistence() 925 .fetchByG_C_First(groupId, categoryId, orderByComparator); 926 } 927 928 /** 929 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 930 * 931 * @param groupId the group ID 932 * @param categoryId the category ID 933 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 934 * @return the last matching message boards thread 935 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 936 * @throws SystemException if a system exception occurred 937 */ 938 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last( 939 long groupId, long categoryId, 940 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 941 throws com.liferay.portal.kernel.exception.SystemException, 942 com.liferay.portlet.messageboards.NoSuchThreadException { 943 return getPersistence() 944 .findByG_C_Last(groupId, categoryId, orderByComparator); 945 } 946 947 /** 948 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ?. 949 * 950 * @param groupId the group ID 951 * @param categoryId the category ID 952 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 953 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 954 * @throws SystemException if a system exception occurred 955 */ 956 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_Last( 957 long groupId, long categoryId, 958 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 959 throws com.liferay.portal.kernel.exception.SystemException { 960 return getPersistence() 961 .fetchByG_C_Last(groupId, categoryId, orderByComparator); 962 } 963 964 /** 965 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ?. 966 * 967 * @param threadId the primary key of the current message boards thread 968 * @param groupId the group ID 969 * @param categoryId the category ID 970 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 971 * @return the previous, current, and next message boards thread 972 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 973 * @throws SystemException if a system exception occurred 974 */ 975 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext( 976 long threadId, long groupId, long categoryId, 977 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 978 throws com.liferay.portal.kernel.exception.SystemException, 979 com.liferay.portlet.messageboards.NoSuchThreadException { 980 return getPersistence() 981 .findByG_C_PrevAndNext(threadId, groupId, categoryId, 982 orderByComparator); 983 } 984 985 /** 986 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 987 * 988 * @param groupId the group ID 989 * @param categoryId the category ID 990 * @return the matching message boards threads that the user has permission to view 991 * @throws SystemException if a system exception occurred 992 */ 993 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 994 long groupId, long categoryId) 995 throws com.liferay.portal.kernel.exception.SystemException { 996 return getPersistence().filterFindByG_C(groupId, categoryId); 997 } 998 999 /** 1000 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 1001 * 1002 * <p> 1003 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1004 * </p> 1005 * 1006 * @param groupId the group ID 1007 * @param categoryId the category ID 1008 * @param start the lower bound of the range of message boards threads 1009 * @param end the upper bound of the range of message boards threads (not inclusive) 1010 * @return the range of matching message boards threads that the user has permission to view 1011 * @throws SystemException if a system exception occurred 1012 */ 1013 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 1014 long groupId, long categoryId, int start, int end) 1015 throws com.liferay.portal.kernel.exception.SystemException { 1016 return getPersistence().filterFindByG_C(groupId, categoryId, start, end); 1017 } 1018 1019 /** 1020 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ?. 1021 * 1022 * <p> 1023 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1024 * </p> 1025 * 1026 * @param groupId the group ID 1027 * @param categoryId the category ID 1028 * @param start the lower bound of the range of message boards threads 1029 * @param end the upper bound of the range of message boards threads (not inclusive) 1030 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1031 * @return the ordered range of matching message boards threads that the user has permission to view 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 1035 long groupId, long categoryId, int start, int end, 1036 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1037 throws com.liferay.portal.kernel.exception.SystemException { 1038 return getPersistence() 1039 .filterFindByG_C(groupId, categoryId, start, end, 1040 orderByComparator); 1041 } 1042 1043 /** 1044 * 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 = ?. 1045 * 1046 * @param threadId the primary key of the current message boards thread 1047 * @param groupId the group ID 1048 * @param categoryId the category ID 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the previous, current, and next message boards thread 1051 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_PrevAndNext( 1055 long threadId, long groupId, long categoryId, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.kernel.exception.SystemException, 1058 com.liferay.portlet.messageboards.NoSuchThreadException { 1059 return getPersistence() 1060 .filterFindByG_C_PrevAndNext(threadId, groupId, categoryId, 1061 orderByComparator); 1062 } 1063 1064 /** 1065 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 1066 * 1067 * @param groupId the group ID 1068 * @param categoryIds the category IDs 1069 * @return the matching message boards threads that the user has permission to view 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 1073 long groupId, long[] categoryIds) 1074 throws com.liferay.portal.kernel.exception.SystemException { 1075 return getPersistence().filterFindByG_C(groupId, categoryIds); 1076 } 1077 1078 /** 1079 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 1080 * 1081 * <p> 1082 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1083 * </p> 1084 * 1085 * @param groupId the group ID 1086 * @param categoryIds the category IDs 1087 * @param start the lower bound of the range of message boards threads 1088 * @param end the upper bound of the range of message boards threads (not inclusive) 1089 * @return the range of matching message boards threads that the user has permission to view 1090 * @throws SystemException if a system exception occurred 1091 */ 1092 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 1093 long groupId, long[] categoryIds, int start, int end) 1094 throws com.liferay.portal.kernel.exception.SystemException { 1095 return getPersistence().filterFindByG_C(groupId, categoryIds, start, end); 1096 } 1097 1098 /** 1099 * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 1100 * 1101 * <p> 1102 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1103 * </p> 1104 * 1105 * @param groupId the group ID 1106 * @param categoryIds the category IDs 1107 * @param start the lower bound of the range of message boards threads 1108 * @param end the upper bound of the range of message boards threads (not inclusive) 1109 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1110 * @return the ordered range of matching message boards threads that the user has permission to view 1111 * @throws SystemException if a system exception occurred 1112 */ 1113 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C( 1114 long groupId, long[] categoryIds, int start, int end, 1115 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1116 throws com.liferay.portal.kernel.exception.SystemException { 1117 return getPersistence() 1118 .filterFindByG_C(groupId, categoryIds, start, end, 1119 orderByComparator); 1120 } 1121 1122 /** 1123 * Returns all the message boards threads where groupId = ? and categoryId = any ?. 1124 * 1125 * <p> 1126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1127 * </p> 1128 * 1129 * @param groupId the group ID 1130 * @param categoryIds the category IDs 1131 * @return the matching message boards threads 1132 * @throws SystemException if a system exception occurred 1133 */ 1134 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 1135 long groupId, long[] categoryIds) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 return getPersistence().findByG_C(groupId, categoryIds); 1138 } 1139 1140 /** 1141 * Returns a range of all the message boards threads where groupId = ? and categoryId = any ?. 1142 * 1143 * <p> 1144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1145 * </p> 1146 * 1147 * @param groupId the group ID 1148 * @param categoryIds the category IDs 1149 * @param start the lower bound of the range of message boards threads 1150 * @param end the upper bound of the range of message boards threads (not inclusive) 1151 * @return the range of matching message boards threads 1152 * @throws SystemException if a system exception occurred 1153 */ 1154 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 1155 long groupId, long[] categoryIds, int start, int end) 1156 throws com.liferay.portal.kernel.exception.SystemException { 1157 return getPersistence().findByG_C(groupId, categoryIds, start, end); 1158 } 1159 1160 /** 1161 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = any ?. 1162 * 1163 * <p> 1164 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1165 * </p> 1166 * 1167 * @param groupId the group ID 1168 * @param categoryIds the category IDs 1169 * @param start the lower bound of the range of message boards threads 1170 * @param end the upper bound of the range of message boards threads (not inclusive) 1171 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1172 * @return the ordered range of matching message boards threads 1173 * @throws SystemException if a system exception occurred 1174 */ 1175 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C( 1176 long groupId, long[] categoryIds, int start, int end, 1177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1178 throws com.liferay.portal.kernel.exception.SystemException { 1179 return getPersistence() 1180 .findByG_C(groupId, categoryIds, start, end, 1181 orderByComparator); 1182 } 1183 1184 /** 1185 * Removes all the message boards threads where groupId = ? and categoryId = ? from the database. 1186 * 1187 * @param groupId the group ID 1188 * @param categoryId the category ID 1189 * @throws SystemException if a system exception occurred 1190 */ 1191 public static void removeByG_C(long groupId, long categoryId) 1192 throws com.liferay.portal.kernel.exception.SystemException { 1193 getPersistence().removeByG_C(groupId, categoryId); 1194 } 1195 1196 /** 1197 * Returns the number of message boards threads where groupId = ? and categoryId = ?. 1198 * 1199 * @param groupId the group ID 1200 * @param categoryId the category ID 1201 * @return the number of matching message boards threads 1202 * @throws SystemException if a system exception occurred 1203 */ 1204 public static int countByG_C(long groupId, long categoryId) 1205 throws com.liferay.portal.kernel.exception.SystemException { 1206 return getPersistence().countByG_C(groupId, categoryId); 1207 } 1208 1209 /** 1210 * Returns the number of message boards threads where groupId = ? and categoryId = any ?. 1211 * 1212 * @param groupId the group ID 1213 * @param categoryIds the category IDs 1214 * @return the number of matching message boards threads 1215 * @throws SystemException if a system exception occurred 1216 */ 1217 public static int countByG_C(long groupId, long[] categoryIds) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 return getPersistence().countByG_C(groupId, categoryIds); 1220 } 1221 1222 /** 1223 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ?. 1224 * 1225 * @param groupId the group ID 1226 * @param categoryId the category ID 1227 * @return the number of matching message boards threads that the user has permission to view 1228 * @throws SystemException if a system exception occurred 1229 */ 1230 public static int filterCountByG_C(long groupId, long categoryId) 1231 throws com.liferay.portal.kernel.exception.SystemException { 1232 return getPersistence().filterCountByG_C(groupId, categoryId); 1233 } 1234 1235 /** 1236 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = any ?. 1237 * 1238 * @param groupId the group ID 1239 * @param categoryIds the category IDs 1240 * @return the number of matching message boards threads that the user has permission to view 1241 * @throws SystemException if a system exception occurred 1242 */ 1243 public static int filterCountByG_C(long groupId, long[] categoryIds) 1244 throws com.liferay.portal.kernel.exception.SystemException { 1245 return getPersistence().filterCountByG_C(groupId, categoryIds); 1246 } 1247 1248 /** 1249 * Returns all the message boards threads where groupId = ? and categoryId ≠ ?. 1250 * 1251 * @param groupId the group ID 1252 * @param categoryId the category ID 1253 * @return the matching message boards threads 1254 * @throws SystemException if a system exception occurred 1255 */ 1256 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 1257 long groupId, long categoryId) 1258 throws com.liferay.portal.kernel.exception.SystemException { 1259 return getPersistence().findByG_NotC(groupId, categoryId); 1260 } 1261 1262 /** 1263 * Returns a range of all the message boards threads where groupId = ? and categoryId ≠ ?. 1264 * 1265 * <p> 1266 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1267 * </p> 1268 * 1269 * @param groupId the group ID 1270 * @param categoryId the category ID 1271 * @param start the lower bound of the range of message boards threads 1272 * @param end the upper bound of the range of message boards threads (not inclusive) 1273 * @return the range of matching message boards threads 1274 * @throws SystemException if a system exception occurred 1275 */ 1276 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 1277 long groupId, long categoryId, int start, int end) 1278 throws com.liferay.portal.kernel.exception.SystemException { 1279 return getPersistence().findByG_NotC(groupId, categoryId, start, end); 1280 } 1281 1282 /** 1283 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ?. 1284 * 1285 * <p> 1286 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1287 * </p> 1288 * 1289 * @param groupId the group ID 1290 * @param categoryId the category ID 1291 * @param start the lower bound of the range of message boards threads 1292 * @param end the upper bound of the range of message boards threads (not inclusive) 1293 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1294 * @return the ordered range of matching message boards threads 1295 * @throws SystemException if a system exception occurred 1296 */ 1297 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC( 1298 long groupId, long categoryId, int start, int end, 1299 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1300 throws com.liferay.portal.kernel.exception.SystemException { 1301 return getPersistence() 1302 .findByG_NotC(groupId, categoryId, start, end, 1303 orderByComparator); 1304 } 1305 1306 /** 1307 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 1308 * 1309 * @param groupId the group ID 1310 * @param categoryId the category ID 1311 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1312 * @return the first matching message boards thread 1313 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1314 * @throws SystemException if a system exception occurred 1315 */ 1316 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First( 1317 long groupId, long categoryId, 1318 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1319 throws com.liferay.portal.kernel.exception.SystemException, 1320 com.liferay.portlet.messageboards.NoSuchThreadException { 1321 return getPersistence() 1322 .findByG_NotC_First(groupId, categoryId, orderByComparator); 1323 } 1324 1325 /** 1326 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 1327 * 1328 * @param groupId the group ID 1329 * @param categoryId the category ID 1330 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1331 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1332 * @throws SystemException if a system exception occurred 1333 */ 1334 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_First( 1335 long groupId, long categoryId, 1336 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1337 throws com.liferay.portal.kernel.exception.SystemException { 1338 return getPersistence() 1339 .fetchByG_NotC_First(groupId, categoryId, orderByComparator); 1340 } 1341 1342 /** 1343 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 1344 * 1345 * @param groupId the group ID 1346 * @param categoryId the category ID 1347 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1348 * @return the last matching message boards thread 1349 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1350 * @throws SystemException if a system exception occurred 1351 */ 1352 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last( 1353 long groupId, long categoryId, 1354 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1355 throws com.liferay.portal.kernel.exception.SystemException, 1356 com.liferay.portlet.messageboards.NoSuchThreadException { 1357 return getPersistence() 1358 .findByG_NotC_Last(groupId, categoryId, orderByComparator); 1359 } 1360 1361 /** 1362 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 1363 * 1364 * @param groupId the group ID 1365 * @param categoryId the category ID 1366 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1367 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1368 * @throws SystemException if a system exception occurred 1369 */ 1370 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_Last( 1371 long groupId, long categoryId, 1372 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1373 throws com.liferay.portal.kernel.exception.SystemException { 1374 return getPersistence() 1375 .fetchByG_NotC_Last(groupId, categoryId, orderByComparator); 1376 } 1377 1378 /** 1379 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ?. 1380 * 1381 * @param threadId the primary key of the current message boards thread 1382 * @param groupId the group ID 1383 * @param categoryId the category ID 1384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1385 * @return the previous, current, and next message boards thread 1386 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1387 * @throws SystemException if a system exception occurred 1388 */ 1389 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext( 1390 long threadId, long groupId, long categoryId, 1391 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1392 throws com.liferay.portal.kernel.exception.SystemException, 1393 com.liferay.portlet.messageboards.NoSuchThreadException { 1394 return getPersistence() 1395 .findByG_NotC_PrevAndNext(threadId, groupId, categoryId, 1396 orderByComparator); 1397 } 1398 1399 /** 1400 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 1401 * 1402 * @param groupId the group ID 1403 * @param categoryId the category ID 1404 * @return the matching message boards threads that the user has permission to view 1405 * @throws SystemException if a system exception occurred 1406 */ 1407 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 1408 long groupId, long categoryId) 1409 throws com.liferay.portal.kernel.exception.SystemException { 1410 return getPersistence().filterFindByG_NotC(groupId, categoryId); 1411 } 1412 1413 /** 1414 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1418 * </p> 1419 * 1420 * @param groupId the group ID 1421 * @param categoryId the category ID 1422 * @param start the lower bound of the range of message boards threads 1423 * @param end the upper bound of the range of message boards threads (not inclusive) 1424 * @return the range of matching message boards threads that the user has permission to view 1425 * @throws SystemException if a system exception occurred 1426 */ 1427 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 1428 long groupId, long categoryId, int start, int end) 1429 throws com.liferay.portal.kernel.exception.SystemException { 1430 return getPersistence() 1431 .filterFindByG_NotC(groupId, categoryId, start, end); 1432 } 1433 1434 /** 1435 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId ≠ ?. 1436 * 1437 * <p> 1438 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1439 * </p> 1440 * 1441 * @param groupId the group ID 1442 * @param categoryId the category ID 1443 * @param start the lower bound of the range of message boards threads 1444 * @param end the upper bound of the range of message boards threads (not inclusive) 1445 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1446 * @return the ordered range of matching message boards threads that the user has permission to view 1447 * @throws SystemException if a system exception occurred 1448 */ 1449 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC( 1450 long groupId, long categoryId, int start, int end, 1451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1452 throws com.liferay.portal.kernel.exception.SystemException { 1453 return getPersistence() 1454 .filterFindByG_NotC(groupId, categoryId, start, end, 1455 orderByComparator); 1456 } 1457 1458 /** 1459 * 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 ≠ ?. 1460 * 1461 * @param threadId the primary key of the current message boards thread 1462 * @param groupId the group ID 1463 * @param categoryId the category ID 1464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1465 * @return the previous, current, and next message boards thread 1466 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1467 * @throws SystemException if a system exception occurred 1468 */ 1469 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_PrevAndNext( 1470 long threadId, long groupId, long categoryId, 1471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1472 throws com.liferay.portal.kernel.exception.SystemException, 1473 com.liferay.portlet.messageboards.NoSuchThreadException { 1474 return getPersistence() 1475 .filterFindByG_NotC_PrevAndNext(threadId, groupId, 1476 categoryId, orderByComparator); 1477 } 1478 1479 /** 1480 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? from the database. 1481 * 1482 * @param groupId the group ID 1483 * @param categoryId the category ID 1484 * @throws SystemException if a system exception occurred 1485 */ 1486 public static void removeByG_NotC(long groupId, long categoryId) 1487 throws com.liferay.portal.kernel.exception.SystemException { 1488 getPersistence().removeByG_NotC(groupId, categoryId); 1489 } 1490 1491 /** 1492 * Returns the number of message boards threads where groupId = ? and categoryId ≠ ?. 1493 * 1494 * @param groupId the group ID 1495 * @param categoryId the category ID 1496 * @return the number of matching message boards threads 1497 * @throws SystemException if a system exception occurred 1498 */ 1499 public static int countByG_NotC(long groupId, long categoryId) 1500 throws com.liferay.portal.kernel.exception.SystemException { 1501 return getPersistence().countByG_NotC(groupId, categoryId); 1502 } 1503 1504 /** 1505 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ?. 1506 * 1507 * @param groupId the group ID 1508 * @param categoryId the category ID 1509 * @return the number of matching message boards threads that the user has permission to view 1510 * @throws SystemException if a system exception occurred 1511 */ 1512 public static int filterCountByG_NotC(long groupId, long categoryId) 1513 throws com.liferay.portal.kernel.exception.SystemException { 1514 return getPersistence().filterCountByG_NotC(groupId, categoryId); 1515 } 1516 1517 /** 1518 * Returns all the message boards threads where groupId = ? and status = ?. 1519 * 1520 * @param groupId the group ID 1521 * @param status the status 1522 * @return the matching message boards threads 1523 * @throws SystemException if a system exception occurred 1524 */ 1525 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1526 long groupId, int status) 1527 throws com.liferay.portal.kernel.exception.SystemException { 1528 return getPersistence().findByG_S(groupId, status); 1529 } 1530 1531 /** 1532 * Returns a range of all the message boards threads where groupId = ? and status = ?. 1533 * 1534 * <p> 1535 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1536 * </p> 1537 * 1538 * @param groupId the group ID 1539 * @param status the status 1540 * @param start the lower bound of the range of message boards threads 1541 * @param end the upper bound of the range of message boards threads (not inclusive) 1542 * @return the range of matching message boards threads 1543 * @throws SystemException if a system exception occurred 1544 */ 1545 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1546 long groupId, int status, int start, int end) 1547 throws com.liferay.portal.kernel.exception.SystemException { 1548 return getPersistence().findByG_S(groupId, status, start, end); 1549 } 1550 1551 /** 1552 * Returns an ordered range of all the message boards threads where groupId = ? and status = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1556 * </p> 1557 * 1558 * @param groupId the group ID 1559 * @param status the status 1560 * @param start the lower bound of the range of message boards threads 1561 * @param end the upper bound of the range of message boards threads (not inclusive) 1562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1563 * @return the ordered range of matching message boards threads 1564 * @throws SystemException if a system exception occurred 1565 */ 1566 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S( 1567 long groupId, int status, int start, int end, 1568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1569 throws com.liferay.portal.kernel.exception.SystemException { 1570 return getPersistence() 1571 .findByG_S(groupId, status, start, end, orderByComparator); 1572 } 1573 1574 /** 1575 * Returns the first message boards thread in the ordered set where groupId = ? and status = ?. 1576 * 1577 * @param groupId the group ID 1578 * @param status the status 1579 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1580 * @return the first matching message boards thread 1581 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1582 * @throws SystemException if a system exception occurred 1583 */ 1584 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First( 1585 long groupId, int status, 1586 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1587 throws com.liferay.portal.kernel.exception.SystemException, 1588 com.liferay.portlet.messageboards.NoSuchThreadException { 1589 return getPersistence() 1590 .findByG_S_First(groupId, status, orderByComparator); 1591 } 1592 1593 /** 1594 * Returns the first message boards thread in the ordered set where groupId = ? and status = ?. 1595 * 1596 * @param groupId the group ID 1597 * @param status the status 1598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1599 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1600 * @throws SystemException if a system exception occurred 1601 */ 1602 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_First( 1603 long groupId, int status, 1604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1605 throws com.liferay.portal.kernel.exception.SystemException { 1606 return getPersistence() 1607 .fetchByG_S_First(groupId, status, orderByComparator); 1608 } 1609 1610 /** 1611 * Returns the last message boards thread in the ordered set where groupId = ? and status = ?. 1612 * 1613 * @param groupId the group ID 1614 * @param status the status 1615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1616 * @return the last matching message boards thread 1617 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1618 * @throws SystemException if a system exception occurred 1619 */ 1620 public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last( 1621 long groupId, int status, 1622 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1623 throws com.liferay.portal.kernel.exception.SystemException, 1624 com.liferay.portlet.messageboards.NoSuchThreadException { 1625 return getPersistence() 1626 .findByG_S_Last(groupId, status, orderByComparator); 1627 } 1628 1629 /** 1630 * Returns the last message boards thread in the ordered set where groupId = ? and status = ?. 1631 * 1632 * @param groupId the group ID 1633 * @param status the status 1634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1635 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1636 * @throws SystemException if a system exception occurred 1637 */ 1638 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_Last( 1639 long groupId, int status, 1640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1641 throws com.liferay.portal.kernel.exception.SystemException { 1642 return getPersistence() 1643 .fetchByG_S_Last(groupId, status, orderByComparator); 1644 } 1645 1646 /** 1647 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and status = ?. 1648 * 1649 * @param threadId the primary key of the current message boards thread 1650 * @param groupId the group ID 1651 * @param status the status 1652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1653 * @return the previous, current, and next message boards thread 1654 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1655 * @throws SystemException if a system exception occurred 1656 */ 1657 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext( 1658 long threadId, long groupId, int status, 1659 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1660 throws com.liferay.portal.kernel.exception.SystemException, 1661 com.liferay.portlet.messageboards.NoSuchThreadException { 1662 return getPersistence() 1663 .findByG_S_PrevAndNext(threadId, groupId, status, 1664 orderByComparator); 1665 } 1666 1667 /** 1668 * Returns all the message boards threads that the user has permission to view where groupId = ? and status = ?. 1669 * 1670 * @param groupId the group ID 1671 * @param status the status 1672 * @return the matching message boards threads that the user has permission to view 1673 * @throws SystemException if a system exception occurred 1674 */ 1675 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1676 long groupId, int status) 1677 throws com.liferay.portal.kernel.exception.SystemException { 1678 return getPersistence().filterFindByG_S(groupId, status); 1679 } 1680 1681 /** 1682 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1686 * </p> 1687 * 1688 * @param groupId the group ID 1689 * @param status the status 1690 * @param start the lower bound of the range of message boards threads 1691 * @param end the upper bound of the range of message boards threads (not inclusive) 1692 * @return the range of matching message boards threads that the user has permission to view 1693 * @throws SystemException if a system exception occurred 1694 */ 1695 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1696 long groupId, int status, int start, int end) 1697 throws com.liferay.portal.kernel.exception.SystemException { 1698 return getPersistence().filterFindByG_S(groupId, status, start, end); 1699 } 1700 1701 /** 1702 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and status = ?. 1703 * 1704 * <p> 1705 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1706 * </p> 1707 * 1708 * @param groupId the group ID 1709 * @param status the status 1710 * @param start the lower bound of the range of message boards threads 1711 * @param end the upper bound of the range of message boards threads (not inclusive) 1712 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1713 * @return the ordered range of matching message boards threads that the user has permission to view 1714 * @throws SystemException if a system exception occurred 1715 */ 1716 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S( 1717 long groupId, int status, int start, int end, 1718 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1719 throws com.liferay.portal.kernel.exception.SystemException { 1720 return getPersistence() 1721 .filterFindByG_S(groupId, status, start, end, 1722 orderByComparator); 1723 } 1724 1725 /** 1726 * 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 = ?. 1727 * 1728 * @param threadId the primary key of the current message boards thread 1729 * @param groupId the group ID 1730 * @param status the status 1731 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1732 * @return the previous, current, and next message boards thread 1733 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1734 * @throws SystemException if a system exception occurred 1735 */ 1736 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_S_PrevAndNext( 1737 long threadId, long groupId, int status, 1738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1739 throws com.liferay.portal.kernel.exception.SystemException, 1740 com.liferay.portlet.messageboards.NoSuchThreadException { 1741 return getPersistence() 1742 .filterFindByG_S_PrevAndNext(threadId, groupId, status, 1743 orderByComparator); 1744 } 1745 1746 /** 1747 * Removes all the message boards threads where groupId = ? and status = ? from the database. 1748 * 1749 * @param groupId the group ID 1750 * @param status the status 1751 * @throws SystemException if a system exception occurred 1752 */ 1753 public static void removeByG_S(long groupId, int status) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 getPersistence().removeByG_S(groupId, status); 1756 } 1757 1758 /** 1759 * Returns the number of message boards threads where groupId = ? and status = ?. 1760 * 1761 * @param groupId the group ID 1762 * @param status the status 1763 * @return the number of matching message boards threads 1764 * @throws SystemException if a system exception occurred 1765 */ 1766 public static int countByG_S(long groupId, int status) 1767 throws com.liferay.portal.kernel.exception.SystemException { 1768 return getPersistence().countByG_S(groupId, status); 1769 } 1770 1771 /** 1772 * Returns the number of message boards threads that the user has permission to view where groupId = ? and status = ?. 1773 * 1774 * @param groupId the group ID 1775 * @param status the status 1776 * @return the number of matching message boards threads that the user has permission to view 1777 * @throws SystemException if a system exception occurred 1778 */ 1779 public static int filterCountByG_S(long groupId, int status) 1780 throws com.liferay.portal.kernel.exception.SystemException { 1781 return getPersistence().filterCountByG_S(groupId, status); 1782 } 1783 1784 /** 1785 * Returns all the message boards threads where categoryId = ? and priority = ?. 1786 * 1787 * @param categoryId the category ID 1788 * @param priority the priority 1789 * @return the matching message boards threads 1790 * @throws SystemException if a system exception occurred 1791 */ 1792 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1793 long categoryId, double priority) 1794 throws com.liferay.portal.kernel.exception.SystemException { 1795 return getPersistence().findByC_P(categoryId, priority); 1796 } 1797 1798 /** 1799 * Returns a range of all the message boards threads where categoryId = ? and priority = ?. 1800 * 1801 * <p> 1802 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1803 * </p> 1804 * 1805 * @param categoryId the category ID 1806 * @param priority the priority 1807 * @param start the lower bound of the range of message boards threads 1808 * @param end the upper bound of the range of message boards threads (not inclusive) 1809 * @return the range of matching message boards threads 1810 * @throws SystemException if a system exception occurred 1811 */ 1812 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1813 long categoryId, double priority, int start, int end) 1814 throws com.liferay.portal.kernel.exception.SystemException { 1815 return getPersistence().findByC_P(categoryId, priority, start, end); 1816 } 1817 1818 /** 1819 * Returns an ordered range of all the message boards threads where categoryId = ? and priority = ?. 1820 * 1821 * <p> 1822 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1823 * </p> 1824 * 1825 * @param categoryId the category ID 1826 * @param priority the priority 1827 * @param start the lower bound of the range of message boards threads 1828 * @param end the upper bound of the range of message boards threads (not inclusive) 1829 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1830 * @return the ordered range of matching message boards threads 1831 * @throws SystemException if a system exception occurred 1832 */ 1833 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P( 1834 long categoryId, double priority, int start, int end, 1835 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1836 throws com.liferay.portal.kernel.exception.SystemException { 1837 return getPersistence() 1838 .findByC_P(categoryId, priority, start, end, 1839 orderByComparator); 1840 } 1841 1842 /** 1843 * Returns the first message boards thread in the ordered set where categoryId = ? and priority = ?. 1844 * 1845 * @param categoryId the category ID 1846 * @param priority the priority 1847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1848 * @return the first matching message boards thread 1849 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1850 * @throws SystemException if a system exception occurred 1851 */ 1852 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First( 1853 long categoryId, double priority, 1854 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1855 throws com.liferay.portal.kernel.exception.SystemException, 1856 com.liferay.portlet.messageboards.NoSuchThreadException { 1857 return getPersistence() 1858 .findByC_P_First(categoryId, priority, orderByComparator); 1859 } 1860 1861 /** 1862 * Returns the first message boards thread in the ordered set where categoryId = ? and priority = ?. 1863 * 1864 * @param categoryId the category ID 1865 * @param priority the priority 1866 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1867 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1868 * @throws SystemException if a system exception occurred 1869 */ 1870 public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_First( 1871 long categoryId, double priority, 1872 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1873 throws com.liferay.portal.kernel.exception.SystemException { 1874 return getPersistence() 1875 .fetchByC_P_First(categoryId, priority, orderByComparator); 1876 } 1877 1878 /** 1879 * Returns the last message boards thread in the ordered set where categoryId = ? and priority = ?. 1880 * 1881 * @param categoryId the category ID 1882 * @param priority the priority 1883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1884 * @return the last matching message boards thread 1885 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 1886 * @throws SystemException if a system exception occurred 1887 */ 1888 public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last( 1889 long categoryId, double priority, 1890 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1891 throws com.liferay.portal.kernel.exception.SystemException, 1892 com.liferay.portlet.messageboards.NoSuchThreadException { 1893 return getPersistence() 1894 .findByC_P_Last(categoryId, priority, orderByComparator); 1895 } 1896 1897 /** 1898 * Returns the last message boards thread in the ordered set where categoryId = ? and priority = ?. 1899 * 1900 * @param categoryId the category ID 1901 * @param priority the priority 1902 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1903 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 1904 * @throws SystemException if a system exception occurred 1905 */ 1906 public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_Last( 1907 long categoryId, double priority, 1908 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1909 throws com.liferay.portal.kernel.exception.SystemException { 1910 return getPersistence() 1911 .fetchByC_P_Last(categoryId, priority, orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the message boards threads before and after the current message boards thread in the ordered set where categoryId = ? and priority = ?. 1916 * 1917 * @param threadId the primary key of the current message boards thread 1918 * @param categoryId the category ID 1919 * @param priority the priority 1920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1921 * @return the previous, current, and next message boards thread 1922 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 1923 * @throws SystemException if a system exception occurred 1924 */ 1925 public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext( 1926 long threadId, long categoryId, double priority, 1927 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1928 throws com.liferay.portal.kernel.exception.SystemException, 1929 com.liferay.portlet.messageboards.NoSuchThreadException { 1930 return getPersistence() 1931 .findByC_P_PrevAndNext(threadId, categoryId, priority, 1932 orderByComparator); 1933 } 1934 1935 /** 1936 * Removes all the message boards threads where categoryId = ? and priority = ? from the database. 1937 * 1938 * @param categoryId the category ID 1939 * @param priority the priority 1940 * @throws SystemException if a system exception occurred 1941 */ 1942 public static void removeByC_P(long categoryId, double priority) 1943 throws com.liferay.portal.kernel.exception.SystemException { 1944 getPersistence().removeByC_P(categoryId, priority); 1945 } 1946 1947 /** 1948 * Returns the number of message boards threads where categoryId = ? and priority = ?. 1949 * 1950 * @param categoryId the category ID 1951 * @param priority the priority 1952 * @return the number of matching message boards threads 1953 * @throws SystemException if a system exception occurred 1954 */ 1955 public static int countByC_P(long categoryId, double priority) 1956 throws com.liferay.portal.kernel.exception.SystemException { 1957 return getPersistence().countByC_P(categoryId, priority); 1958 } 1959 1960 /** 1961 * Returns all the message boards threads where lastPostDate = ? and priority = ?. 1962 * 1963 * @param lastPostDate the last post date 1964 * @param priority the priority 1965 * @return the matching message boards threads 1966 * @throws SystemException if a system exception occurred 1967 */ 1968 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 1969 java.util.Date lastPostDate, double priority) 1970 throws com.liferay.portal.kernel.exception.SystemException { 1971 return getPersistence().findByL_P(lastPostDate, priority); 1972 } 1973 1974 /** 1975 * Returns a range of all the message boards threads where lastPostDate = ? and priority = ?. 1976 * 1977 * <p> 1978 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1979 * </p> 1980 * 1981 * @param lastPostDate the last post date 1982 * @param priority the priority 1983 * @param start the lower bound of the range of message boards threads 1984 * @param end the upper bound of the range of message boards threads (not inclusive) 1985 * @return the range of matching message boards threads 1986 * @throws SystemException if a system exception occurred 1987 */ 1988 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 1989 java.util.Date lastPostDate, double priority, int start, int end) 1990 throws com.liferay.portal.kernel.exception.SystemException { 1991 return getPersistence().findByL_P(lastPostDate, priority, start, end); 1992 } 1993 1994 /** 1995 * Returns an ordered range of all the message boards threads where lastPostDate = ? and priority = ?. 1996 * 1997 * <p> 1998 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1999 * </p> 2000 * 2001 * @param lastPostDate the last post date 2002 * @param priority the priority 2003 * @param start the lower bound of the range of message boards threads 2004 * @param end the upper bound of the range of message boards threads (not inclusive) 2005 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2006 * @return the ordered range of matching message boards threads 2007 * @throws SystemException if a system exception occurred 2008 */ 2009 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P( 2010 java.util.Date lastPostDate, double priority, int start, int end, 2011 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2012 throws com.liferay.portal.kernel.exception.SystemException { 2013 return getPersistence() 2014 .findByL_P(lastPostDate, priority, start, end, 2015 orderByComparator); 2016 } 2017 2018 /** 2019 * Returns the first message boards thread in the ordered set where lastPostDate = ? and priority = ?. 2020 * 2021 * @param lastPostDate the last post date 2022 * @param priority the priority 2023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2024 * @return the first matching message boards thread 2025 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2026 * @throws SystemException if a system exception occurred 2027 */ 2028 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_First( 2029 java.util.Date lastPostDate, double priority, 2030 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2031 throws com.liferay.portal.kernel.exception.SystemException, 2032 com.liferay.portlet.messageboards.NoSuchThreadException { 2033 return getPersistence() 2034 .findByL_P_First(lastPostDate, priority, orderByComparator); 2035 } 2036 2037 /** 2038 * Returns the first message boards thread in the ordered set where lastPostDate = ? and priority = ?. 2039 * 2040 * @param lastPostDate the last post date 2041 * @param priority the priority 2042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2043 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2044 * @throws SystemException if a system exception occurred 2045 */ 2046 public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_First( 2047 java.util.Date lastPostDate, double priority, 2048 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2049 throws com.liferay.portal.kernel.exception.SystemException { 2050 return getPersistence() 2051 .fetchByL_P_First(lastPostDate, priority, orderByComparator); 2052 } 2053 2054 /** 2055 * Returns the last message boards thread in the ordered set where lastPostDate = ? and priority = ?. 2056 * 2057 * @param lastPostDate the last post date 2058 * @param priority the priority 2059 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2060 * @return the last matching message boards thread 2061 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2062 * @throws SystemException if a system exception occurred 2063 */ 2064 public static com.liferay.portlet.messageboards.model.MBThread findByL_P_Last( 2065 java.util.Date lastPostDate, double priority, 2066 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2067 throws com.liferay.portal.kernel.exception.SystemException, 2068 com.liferay.portlet.messageboards.NoSuchThreadException { 2069 return getPersistence() 2070 .findByL_P_Last(lastPostDate, priority, orderByComparator); 2071 } 2072 2073 /** 2074 * Returns the last message boards thread in the ordered set where lastPostDate = ? and priority = ?. 2075 * 2076 * @param lastPostDate the last post date 2077 * @param priority the priority 2078 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2079 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2080 * @throws SystemException if a system exception occurred 2081 */ 2082 public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_Last( 2083 java.util.Date lastPostDate, double priority, 2084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2085 throws com.liferay.portal.kernel.exception.SystemException { 2086 return getPersistence() 2087 .fetchByL_P_Last(lastPostDate, priority, orderByComparator); 2088 } 2089 2090 /** 2091 * Returns the message boards threads before and after the current message boards thread in the ordered set where lastPostDate = ? and priority = ?. 2092 * 2093 * @param threadId the primary key of the current message boards thread 2094 * @param lastPostDate the last post date 2095 * @param priority the priority 2096 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2097 * @return the previous, current, and next message boards thread 2098 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2099 * @throws SystemException if a system exception occurred 2100 */ 2101 public static com.liferay.portlet.messageboards.model.MBThread[] findByL_P_PrevAndNext( 2102 long threadId, java.util.Date lastPostDate, double priority, 2103 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2104 throws com.liferay.portal.kernel.exception.SystemException, 2105 com.liferay.portlet.messageboards.NoSuchThreadException { 2106 return getPersistence() 2107 .findByL_P_PrevAndNext(threadId, lastPostDate, priority, 2108 orderByComparator); 2109 } 2110 2111 /** 2112 * Removes all the message boards threads where lastPostDate = ? and priority = ? from the database. 2113 * 2114 * @param lastPostDate the last post date 2115 * @param priority the priority 2116 * @throws SystemException if a system exception occurred 2117 */ 2118 public static void removeByL_P(java.util.Date lastPostDate, double priority) 2119 throws com.liferay.portal.kernel.exception.SystemException { 2120 getPersistence().removeByL_P(lastPostDate, priority); 2121 } 2122 2123 /** 2124 * Returns the number of message boards threads where lastPostDate = ? and priority = ?. 2125 * 2126 * @param lastPostDate the last post date 2127 * @param priority the priority 2128 * @return the number of matching message boards threads 2129 * @throws SystemException if a system exception occurred 2130 */ 2131 public static int countByL_P(java.util.Date lastPostDate, double priority) 2132 throws com.liferay.portal.kernel.exception.SystemException { 2133 return getPersistence().countByL_P(lastPostDate, priority); 2134 } 2135 2136 /** 2137 * Returns all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 2138 * 2139 * @param groupId the group ID 2140 * @param categoryId the category ID 2141 * @param lastPostDate the last post date 2142 * @return the matching message boards threads 2143 * @throws SystemException if a system exception occurred 2144 */ 2145 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 2146 long groupId, long categoryId, java.util.Date lastPostDate) 2147 throws com.liferay.portal.kernel.exception.SystemException { 2148 return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate); 2149 } 2150 2151 /** 2152 * Returns a range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 2153 * 2154 * <p> 2155 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2156 * </p> 2157 * 2158 * @param groupId the group ID 2159 * @param categoryId the category ID 2160 * @param lastPostDate the last post date 2161 * @param start the lower bound of the range of message boards threads 2162 * @param end the upper bound of the range of message boards threads (not inclusive) 2163 * @return the range of matching message boards threads 2164 * @throws SystemException if a system exception occurred 2165 */ 2166 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 2167 long groupId, long categoryId, java.util.Date lastPostDate, int start, 2168 int end) throws com.liferay.portal.kernel.exception.SystemException { 2169 return getPersistence() 2170 .findByG_C_L(groupId, categoryId, lastPostDate, start, end); 2171 } 2172 2173 /** 2174 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 2175 * 2176 * <p> 2177 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2178 * </p> 2179 * 2180 * @param groupId the group ID 2181 * @param categoryId the category ID 2182 * @param lastPostDate the last post date 2183 * @param start the lower bound of the range of message boards threads 2184 * @param end the upper bound of the range of message boards threads (not inclusive) 2185 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2186 * @return the ordered range of matching message boards threads 2187 * @throws SystemException if a system exception occurred 2188 */ 2189 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L( 2190 long groupId, long categoryId, java.util.Date lastPostDate, int start, 2191 int end, 2192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2193 throws com.liferay.portal.kernel.exception.SystemException { 2194 return getPersistence() 2195 .findByG_C_L(groupId, categoryId, lastPostDate, start, end, 2196 orderByComparator); 2197 } 2198 2199 /** 2200 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 2201 * 2202 * @param groupId the group ID 2203 * @param categoryId the category ID 2204 * @param lastPostDate the last post date 2205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2206 * @return the first matching message boards thread 2207 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2208 * @throws SystemException if a system exception occurred 2209 */ 2210 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First( 2211 long groupId, long categoryId, java.util.Date lastPostDate, 2212 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2213 throws com.liferay.portal.kernel.exception.SystemException, 2214 com.liferay.portlet.messageboards.NoSuchThreadException { 2215 return getPersistence() 2216 .findByG_C_L_First(groupId, categoryId, lastPostDate, 2217 orderByComparator); 2218 } 2219 2220 /** 2221 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 2222 * 2223 * @param groupId the group ID 2224 * @param categoryId the category ID 2225 * @param lastPostDate the last post date 2226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2227 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2228 * @throws SystemException if a system exception occurred 2229 */ 2230 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_First( 2231 long groupId, long categoryId, java.util.Date lastPostDate, 2232 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2233 throws com.liferay.portal.kernel.exception.SystemException { 2234 return getPersistence() 2235 .fetchByG_C_L_First(groupId, categoryId, lastPostDate, 2236 orderByComparator); 2237 } 2238 2239 /** 2240 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 2241 * 2242 * @param groupId the group ID 2243 * @param categoryId the category ID 2244 * @param lastPostDate the last post date 2245 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2246 * @return the last matching message boards thread 2247 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2248 * @throws SystemException if a system exception occurred 2249 */ 2250 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last( 2251 long groupId, long categoryId, java.util.Date lastPostDate, 2252 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2253 throws com.liferay.portal.kernel.exception.SystemException, 2254 com.liferay.portlet.messageboards.NoSuchThreadException { 2255 return getPersistence() 2256 .findByG_C_L_Last(groupId, categoryId, lastPostDate, 2257 orderByComparator); 2258 } 2259 2260 /** 2261 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 2262 * 2263 * @param groupId the group ID 2264 * @param categoryId the category ID 2265 * @param lastPostDate the last post date 2266 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2267 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2268 * @throws SystemException if a system exception occurred 2269 */ 2270 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_Last( 2271 long groupId, long categoryId, java.util.Date lastPostDate, 2272 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2273 throws com.liferay.portal.kernel.exception.SystemException { 2274 return getPersistence() 2275 .fetchByG_C_L_Last(groupId, categoryId, lastPostDate, 2276 orderByComparator); 2277 } 2278 2279 /** 2280 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and lastPostDate = ?. 2281 * 2282 * @param threadId the primary key of the current message boards thread 2283 * @param groupId the group ID 2284 * @param categoryId the category ID 2285 * @param lastPostDate the last post date 2286 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2287 * @return the previous, current, and next message boards thread 2288 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2289 * @throws SystemException if a system exception occurred 2290 */ 2291 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext( 2292 long threadId, long groupId, long categoryId, 2293 java.util.Date lastPostDate, 2294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2295 throws com.liferay.portal.kernel.exception.SystemException, 2296 com.liferay.portlet.messageboards.NoSuchThreadException { 2297 return getPersistence() 2298 .findByG_C_L_PrevAndNext(threadId, groupId, categoryId, 2299 lastPostDate, orderByComparator); 2300 } 2301 2302 /** 2303 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 2304 * 2305 * @param groupId the group ID 2306 * @param categoryId the category ID 2307 * @param lastPostDate the last post date 2308 * @return the matching message boards threads that the user has permission to view 2309 * @throws SystemException if a system exception occurred 2310 */ 2311 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 2312 long groupId, long categoryId, java.util.Date lastPostDate) 2313 throws com.liferay.portal.kernel.exception.SystemException { 2314 return getPersistence() 2315 .filterFindByG_C_L(groupId, categoryId, lastPostDate); 2316 } 2317 2318 /** 2319 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 2320 * 2321 * <p> 2322 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2323 * </p> 2324 * 2325 * @param groupId the group ID 2326 * @param categoryId the category ID 2327 * @param lastPostDate the last post date 2328 * @param start the lower bound of the range of message boards threads 2329 * @param end the upper bound of the range of message boards threads (not inclusive) 2330 * @return the range of matching message boards threads that the user has permission to view 2331 * @throws SystemException if a system exception occurred 2332 */ 2333 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 2334 long groupId, long categoryId, java.util.Date lastPostDate, int start, 2335 int end) throws com.liferay.portal.kernel.exception.SystemException { 2336 return getPersistence() 2337 .filterFindByG_C_L(groupId, categoryId, lastPostDate, start, 2338 end); 2339 } 2340 2341 /** 2342 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ? and lastPostDate = ?. 2343 * 2344 * <p> 2345 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2346 * </p> 2347 * 2348 * @param groupId the group ID 2349 * @param categoryId the category ID 2350 * @param lastPostDate the last post date 2351 * @param start the lower bound of the range of message boards threads 2352 * @param end the upper bound of the range of message boards threads (not inclusive) 2353 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2354 * @return the ordered range of matching message boards threads that the user has permission to view 2355 * @throws SystemException if a system exception occurred 2356 */ 2357 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L( 2358 long groupId, long categoryId, java.util.Date lastPostDate, int start, 2359 int end, 2360 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2361 throws com.liferay.portal.kernel.exception.SystemException { 2362 return getPersistence() 2363 .filterFindByG_C_L(groupId, categoryId, lastPostDate, start, 2364 end, orderByComparator); 2365 } 2366 2367 /** 2368 * 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 = ?. 2369 * 2370 * @param threadId the primary key of the current message boards thread 2371 * @param groupId the group ID 2372 * @param categoryId the category ID 2373 * @param lastPostDate the last post date 2374 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2375 * @return the previous, current, and next message boards thread 2376 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2377 * @throws SystemException if a system exception occurred 2378 */ 2379 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_L_PrevAndNext( 2380 long threadId, long groupId, long categoryId, 2381 java.util.Date lastPostDate, 2382 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2383 throws com.liferay.portal.kernel.exception.SystemException, 2384 com.liferay.portlet.messageboards.NoSuchThreadException { 2385 return getPersistence() 2386 .filterFindByG_C_L_PrevAndNext(threadId, groupId, 2387 categoryId, lastPostDate, orderByComparator); 2388 } 2389 2390 /** 2391 * Removes all the message boards threads where groupId = ? and categoryId = ? and lastPostDate = ? from the database. 2392 * 2393 * @param groupId the group ID 2394 * @param categoryId the category ID 2395 * @param lastPostDate the last post date 2396 * @throws SystemException if a system exception occurred 2397 */ 2398 public static void removeByG_C_L(long groupId, long categoryId, 2399 java.util.Date lastPostDate) 2400 throws com.liferay.portal.kernel.exception.SystemException { 2401 getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate); 2402 } 2403 2404 /** 2405 * Returns the number of message boards threads where groupId = ? and categoryId = ? and lastPostDate = ?. 2406 * 2407 * @param groupId the group ID 2408 * @param categoryId the category ID 2409 * @param lastPostDate the last post date 2410 * @return the number of matching message boards threads 2411 * @throws SystemException if a system exception occurred 2412 */ 2413 public static int countByG_C_L(long groupId, long categoryId, 2414 java.util.Date lastPostDate) 2415 throws com.liferay.portal.kernel.exception.SystemException { 2416 return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate); 2417 } 2418 2419 /** 2420 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and lastPostDate = ?. 2421 * 2422 * @param groupId the group ID 2423 * @param categoryId the category ID 2424 * @param lastPostDate the last post date 2425 * @return the number of matching message boards threads that the user has permission to view 2426 * @throws SystemException if a system exception occurred 2427 */ 2428 public static int filterCountByG_C_L(long groupId, long categoryId, 2429 java.util.Date lastPostDate) 2430 throws com.liferay.portal.kernel.exception.SystemException { 2431 return getPersistence() 2432 .filterCountByG_C_L(groupId, categoryId, lastPostDate); 2433 } 2434 2435 /** 2436 * Returns all the message boards threads where groupId = ? and categoryId = ? and status = ?. 2437 * 2438 * @param groupId the group ID 2439 * @param categoryId the category ID 2440 * @param status the status 2441 * @return the matching message boards threads 2442 * @throws SystemException if a system exception occurred 2443 */ 2444 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2445 long groupId, long categoryId, int status) 2446 throws com.liferay.portal.kernel.exception.SystemException { 2447 return getPersistence().findByG_C_S(groupId, categoryId, status); 2448 } 2449 2450 /** 2451 * Returns a range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 2452 * 2453 * <p> 2454 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2455 * </p> 2456 * 2457 * @param groupId the group ID 2458 * @param categoryId the category ID 2459 * @param status the status 2460 * @param start the lower bound of the range of message boards threads 2461 * @param end the upper bound of the range of message boards threads (not inclusive) 2462 * @return the range of matching message boards threads 2463 * @throws SystemException if a system exception occurred 2464 */ 2465 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2466 long groupId, long categoryId, int status, int start, int end) 2467 throws com.liferay.portal.kernel.exception.SystemException { 2468 return getPersistence() 2469 .findByG_C_S(groupId, categoryId, status, start, end); 2470 } 2471 2472 /** 2473 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ? and status = ?. 2474 * 2475 * <p> 2476 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2477 * </p> 2478 * 2479 * @param groupId the group ID 2480 * @param categoryId the category ID 2481 * @param status the status 2482 * @param start the lower bound of the range of message boards threads 2483 * @param end the upper bound of the range of message boards threads (not inclusive) 2484 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2485 * @return the ordered range of matching message boards threads 2486 * @throws SystemException if a system exception occurred 2487 */ 2488 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2489 long groupId, long categoryId, int status, int start, int end, 2490 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2491 throws com.liferay.portal.kernel.exception.SystemException { 2492 return getPersistence() 2493 .findByG_C_S(groupId, categoryId, status, start, end, 2494 orderByComparator); 2495 } 2496 2497 /** 2498 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 2499 * 2500 * @param groupId the group ID 2501 * @param categoryId the category ID 2502 * @param status the status 2503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2504 * @return the first matching message boards thread 2505 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2506 * @throws SystemException if a system exception occurred 2507 */ 2508 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First( 2509 long groupId, long categoryId, int status, 2510 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2511 throws com.liferay.portal.kernel.exception.SystemException, 2512 com.liferay.portlet.messageboards.NoSuchThreadException { 2513 return getPersistence() 2514 .findByG_C_S_First(groupId, categoryId, status, 2515 orderByComparator); 2516 } 2517 2518 /** 2519 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 2520 * 2521 * @param groupId the group ID 2522 * @param categoryId the category ID 2523 * @param status the status 2524 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2525 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2526 * @throws SystemException if a system exception occurred 2527 */ 2528 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_First( 2529 long groupId, long categoryId, int status, 2530 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2531 throws com.liferay.portal.kernel.exception.SystemException { 2532 return getPersistence() 2533 .fetchByG_C_S_First(groupId, categoryId, status, 2534 orderByComparator); 2535 } 2536 2537 /** 2538 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 2539 * 2540 * @param groupId the group ID 2541 * @param categoryId the category ID 2542 * @param status the status 2543 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2544 * @return the last matching message boards thread 2545 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2546 * @throws SystemException if a system exception occurred 2547 */ 2548 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last( 2549 long groupId, long categoryId, int status, 2550 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2551 throws com.liferay.portal.kernel.exception.SystemException, 2552 com.liferay.portlet.messageboards.NoSuchThreadException { 2553 return getPersistence() 2554 .findByG_C_S_Last(groupId, categoryId, status, 2555 orderByComparator); 2556 } 2557 2558 /** 2559 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 2560 * 2561 * @param groupId the group ID 2562 * @param categoryId the category ID 2563 * @param status the status 2564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2565 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2566 * @throws SystemException if a system exception occurred 2567 */ 2568 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_Last( 2569 long groupId, long categoryId, int status, 2570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2571 throws com.liferay.portal.kernel.exception.SystemException { 2572 return getPersistence() 2573 .fetchByG_C_S_Last(groupId, categoryId, status, 2574 orderByComparator); 2575 } 2576 2577 /** 2578 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and status = ?. 2579 * 2580 * @param threadId the primary key of the current message boards thread 2581 * @param groupId the group ID 2582 * @param categoryId the category ID 2583 * @param status the status 2584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2585 * @return the previous, current, and next message boards thread 2586 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2587 * @throws SystemException if a system exception occurred 2588 */ 2589 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext( 2590 long threadId, long groupId, long categoryId, int status, 2591 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2592 throws com.liferay.portal.kernel.exception.SystemException, 2593 com.liferay.portlet.messageboards.NoSuchThreadException { 2594 return getPersistence() 2595 .findByG_C_S_PrevAndNext(threadId, groupId, categoryId, 2596 status, orderByComparator); 2597 } 2598 2599 /** 2600 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2601 * 2602 * @param groupId the group ID 2603 * @param categoryId the category ID 2604 * @param status the status 2605 * @return the matching message boards threads that the user has permission to view 2606 * @throws SystemException if a system exception occurred 2607 */ 2608 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2609 long groupId, long categoryId, int status) 2610 throws com.liferay.portal.kernel.exception.SystemException { 2611 return getPersistence().filterFindByG_C_S(groupId, categoryId, status); 2612 } 2613 2614 /** 2615 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2616 * 2617 * <p> 2618 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2619 * </p> 2620 * 2621 * @param groupId the group ID 2622 * @param categoryId the category ID 2623 * @param status the status 2624 * @param start the lower bound of the range of message boards threads 2625 * @param end the upper bound of the range of message boards threads (not inclusive) 2626 * @return the range of matching message boards threads that the user has permission to view 2627 * @throws SystemException if a system exception occurred 2628 */ 2629 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2630 long groupId, long categoryId, int status, int start, int end) 2631 throws com.liferay.portal.kernel.exception.SystemException { 2632 return getPersistence() 2633 .filterFindByG_C_S(groupId, categoryId, status, start, end); 2634 } 2635 2636 /** 2637 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ? and status = ?. 2638 * 2639 * <p> 2640 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2641 * </p> 2642 * 2643 * @param groupId the group ID 2644 * @param categoryId the category ID 2645 * @param status the status 2646 * @param start the lower bound of the range of message boards threads 2647 * @param end the upper bound of the range of message boards threads (not inclusive) 2648 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2649 * @return the ordered range of matching message boards threads that the user has permission to view 2650 * @throws SystemException if a system exception occurred 2651 */ 2652 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2653 long groupId, long categoryId, int status, int start, int end, 2654 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2655 throws com.liferay.portal.kernel.exception.SystemException { 2656 return getPersistence() 2657 .filterFindByG_C_S(groupId, categoryId, status, start, end, 2658 orderByComparator); 2659 } 2660 2661 /** 2662 * 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 = ?. 2663 * 2664 * @param threadId the primary key of the current message boards thread 2665 * @param groupId the group ID 2666 * @param categoryId the category ID 2667 * @param status the status 2668 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2669 * @return the previous, current, and next message boards thread 2670 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 2671 * @throws SystemException if a system exception occurred 2672 */ 2673 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_S_PrevAndNext( 2674 long threadId, long groupId, long categoryId, int status, 2675 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2676 throws com.liferay.portal.kernel.exception.SystemException, 2677 com.liferay.portlet.messageboards.NoSuchThreadException { 2678 return getPersistence() 2679 .filterFindByG_C_S_PrevAndNext(threadId, groupId, 2680 categoryId, status, orderByComparator); 2681 } 2682 2683 /** 2684 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2685 * 2686 * @param groupId the group ID 2687 * @param categoryIds the category IDs 2688 * @param status the status 2689 * @return the matching message boards threads that the user has permission to view 2690 * @throws SystemException if a system exception occurred 2691 */ 2692 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2693 long groupId, long[] categoryIds, int status) 2694 throws com.liferay.portal.kernel.exception.SystemException { 2695 return getPersistence().filterFindByG_C_S(groupId, categoryIds, status); 2696 } 2697 2698 /** 2699 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2700 * 2701 * <p> 2702 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2703 * </p> 2704 * 2705 * @param groupId the group ID 2706 * @param categoryIds the category IDs 2707 * @param status the status 2708 * @param start the lower bound of the range of message boards threads 2709 * @param end the upper bound of the range of message boards threads (not inclusive) 2710 * @return the range of matching message boards threads that the user has permission to view 2711 * @throws SystemException if a system exception occurred 2712 */ 2713 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2714 long groupId, long[] categoryIds, int status, int start, int end) 2715 throws com.liferay.portal.kernel.exception.SystemException { 2716 return getPersistence() 2717 .filterFindByG_C_S(groupId, categoryIds, status, start, end); 2718 } 2719 2720 /** 2721 * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2722 * 2723 * <p> 2724 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2725 * </p> 2726 * 2727 * @param groupId the group ID 2728 * @param categoryIds the category IDs 2729 * @param status the status 2730 * @param start the lower bound of the range of message boards threads 2731 * @param end the upper bound of the range of message boards threads (not inclusive) 2732 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2733 * @return the ordered range of matching message boards threads that the user has permission to view 2734 * @throws SystemException if a system exception occurred 2735 */ 2736 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S( 2737 long groupId, long[] categoryIds, int status, int start, int end, 2738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2739 throws com.liferay.portal.kernel.exception.SystemException { 2740 return getPersistence() 2741 .filterFindByG_C_S(groupId, categoryIds, status, start, end, 2742 orderByComparator); 2743 } 2744 2745 /** 2746 * Returns all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 2747 * 2748 * <p> 2749 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2750 * </p> 2751 * 2752 * @param groupId the group ID 2753 * @param categoryIds the category IDs 2754 * @param status the status 2755 * @return the matching message boards threads 2756 * @throws SystemException if a system exception occurred 2757 */ 2758 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2759 long groupId, long[] categoryIds, int status) 2760 throws com.liferay.portal.kernel.exception.SystemException { 2761 return getPersistence().findByG_C_S(groupId, categoryIds, status); 2762 } 2763 2764 /** 2765 * Returns a range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 2766 * 2767 * <p> 2768 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2769 * </p> 2770 * 2771 * @param groupId the group ID 2772 * @param categoryIds the category IDs 2773 * @param status the status 2774 * @param start the lower bound of the range of message boards threads 2775 * @param end the upper bound of the range of message boards threads (not inclusive) 2776 * @return the range of matching message boards threads 2777 * @throws SystemException if a system exception occurred 2778 */ 2779 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2780 long groupId, long[] categoryIds, int status, int start, int end) 2781 throws com.liferay.portal.kernel.exception.SystemException { 2782 return getPersistence() 2783 .findByG_C_S(groupId, categoryIds, status, start, end); 2784 } 2785 2786 /** 2787 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = any ? and status = ?. 2788 * 2789 * <p> 2790 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2791 * </p> 2792 * 2793 * @param groupId the group ID 2794 * @param categoryIds the category IDs 2795 * @param status the status 2796 * @param start the lower bound of the range of message boards threads 2797 * @param end the upper bound of the range of message boards threads (not inclusive) 2798 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2799 * @return the ordered range of matching message boards threads 2800 * @throws SystemException if a system exception occurred 2801 */ 2802 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S( 2803 long groupId, long[] categoryIds, int status, int start, int end, 2804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2805 throws com.liferay.portal.kernel.exception.SystemException { 2806 return getPersistence() 2807 .findByG_C_S(groupId, categoryIds, status, start, end, 2808 orderByComparator); 2809 } 2810 2811 /** 2812 * Removes all the message boards threads where groupId = ? and categoryId = ? and status = ? from the database. 2813 * 2814 * @param groupId the group ID 2815 * @param categoryId the category ID 2816 * @param status the status 2817 * @throws SystemException if a system exception occurred 2818 */ 2819 public static void removeByG_C_S(long groupId, long categoryId, int status) 2820 throws com.liferay.portal.kernel.exception.SystemException { 2821 getPersistence().removeByG_C_S(groupId, categoryId, status); 2822 } 2823 2824 /** 2825 * Returns the number of message boards threads where groupId = ? and categoryId = ? and status = ?. 2826 * 2827 * @param groupId the group ID 2828 * @param categoryId the category ID 2829 * @param status the status 2830 * @return the number of matching message boards threads 2831 * @throws SystemException if a system exception occurred 2832 */ 2833 public static int countByG_C_S(long groupId, long categoryId, int status) 2834 throws com.liferay.portal.kernel.exception.SystemException { 2835 return getPersistence().countByG_C_S(groupId, categoryId, status); 2836 } 2837 2838 /** 2839 * Returns the number of message boards threads where groupId = ? and categoryId = any ? and status = ?. 2840 * 2841 * @param groupId the group ID 2842 * @param categoryIds the category IDs 2843 * @param status the status 2844 * @return the number of matching message boards threads 2845 * @throws SystemException if a system exception occurred 2846 */ 2847 public static int countByG_C_S(long groupId, long[] categoryIds, int status) 2848 throws com.liferay.portal.kernel.exception.SystemException { 2849 return getPersistence().countByG_C_S(groupId, categoryIds, status); 2850 } 2851 2852 /** 2853 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status = ?. 2854 * 2855 * @param groupId the group ID 2856 * @param categoryId the category ID 2857 * @param status the status 2858 * @return the number of matching message boards threads that the user has permission to view 2859 * @throws SystemException if a system exception occurred 2860 */ 2861 public static int filterCountByG_C_S(long groupId, long categoryId, 2862 int status) throws com.liferay.portal.kernel.exception.SystemException { 2863 return getPersistence().filterCountByG_C_S(groupId, categoryId, status); 2864 } 2865 2866 /** 2867 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status = ?. 2868 * 2869 * @param groupId the group ID 2870 * @param categoryIds the category IDs 2871 * @param status the status 2872 * @return the number of matching message boards threads that the user has permission to view 2873 * @throws SystemException if a system exception occurred 2874 */ 2875 public static int filterCountByG_C_S(long groupId, long[] categoryIds, 2876 int status) throws com.liferay.portal.kernel.exception.SystemException { 2877 return getPersistence().filterCountByG_C_S(groupId, categoryIds, status); 2878 } 2879 2880 /** 2881 * Returns all the message boards threads where groupId = ? and categoryId = ? and status ≠ ?. 2882 * 2883 * @param groupId the group ID 2884 * @param categoryId the category ID 2885 * @param status the status 2886 * @return the matching message boards threads 2887 * @throws SystemException if a system exception occurred 2888 */ 2889 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 2890 long groupId, long categoryId, int status) 2891 throws com.liferay.portal.kernel.exception.SystemException { 2892 return getPersistence().findByG_C_NotS(groupId, categoryId, status); 2893 } 2894 2895 /** 2896 * Returns a range of all the message boards threads where groupId = ? and categoryId = ? and status ≠ ?. 2897 * 2898 * <p> 2899 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2900 * </p> 2901 * 2902 * @param groupId the group ID 2903 * @param categoryId the category ID 2904 * @param status the status 2905 * @param start the lower bound of the range of message boards threads 2906 * @param end the upper bound of the range of message boards threads (not inclusive) 2907 * @return the range of matching message boards threads 2908 * @throws SystemException if a system exception occurred 2909 */ 2910 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 2911 long groupId, long categoryId, int status, int start, int end) 2912 throws com.liferay.portal.kernel.exception.SystemException { 2913 return getPersistence() 2914 .findByG_C_NotS(groupId, categoryId, status, start, end); 2915 } 2916 2917 /** 2918 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = ? and status ≠ ?. 2919 * 2920 * <p> 2921 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2922 * </p> 2923 * 2924 * @param groupId the group ID 2925 * @param categoryId the category ID 2926 * @param status the status 2927 * @param start the lower bound of the range of message boards threads 2928 * @param end the upper bound of the range of message boards threads (not inclusive) 2929 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2930 * @return the ordered range of matching message boards threads 2931 * @throws SystemException if a system exception occurred 2932 */ 2933 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 2934 long groupId, long categoryId, int status, int start, int end, 2935 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2936 throws com.liferay.portal.kernel.exception.SystemException { 2937 return getPersistence() 2938 .findByG_C_NotS(groupId, categoryId, status, start, end, 2939 orderByComparator); 2940 } 2941 2942 /** 2943 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status ≠ ?. 2944 * 2945 * @param groupId the group ID 2946 * @param categoryId the category ID 2947 * @param status the status 2948 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2949 * @return the first matching message boards thread 2950 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2951 * @throws SystemException if a system exception occurred 2952 */ 2953 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_NotS_First( 2954 long groupId, long categoryId, int status, 2955 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2956 throws com.liferay.portal.kernel.exception.SystemException, 2957 com.liferay.portlet.messageboards.NoSuchThreadException { 2958 return getPersistence() 2959 .findByG_C_NotS_First(groupId, categoryId, status, 2960 orderByComparator); 2961 } 2962 2963 /** 2964 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId = ? and status ≠ ?. 2965 * 2966 * @param groupId the group ID 2967 * @param categoryId the category ID 2968 * @param status the status 2969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2970 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 2971 * @throws SystemException if a system exception occurred 2972 */ 2973 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_NotS_First( 2974 long groupId, long categoryId, int status, 2975 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2976 throws com.liferay.portal.kernel.exception.SystemException { 2977 return getPersistence() 2978 .fetchByG_C_NotS_First(groupId, categoryId, status, 2979 orderByComparator); 2980 } 2981 2982 /** 2983 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status ≠ ?. 2984 * 2985 * @param groupId the group ID 2986 * @param categoryId the category ID 2987 * @param status the status 2988 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2989 * @return the last matching message boards thread 2990 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 2991 * @throws SystemException if a system exception occurred 2992 */ 2993 public static com.liferay.portlet.messageboards.model.MBThread findByG_C_NotS_Last( 2994 long groupId, long categoryId, int status, 2995 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2996 throws com.liferay.portal.kernel.exception.SystemException, 2997 com.liferay.portlet.messageboards.NoSuchThreadException { 2998 return getPersistence() 2999 .findByG_C_NotS_Last(groupId, categoryId, status, 3000 orderByComparator); 3001 } 3002 3003 /** 3004 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId = ? and status ≠ ?. 3005 * 3006 * @param groupId the group ID 3007 * @param categoryId the category ID 3008 * @param status the status 3009 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3010 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 3011 * @throws SystemException if a system exception occurred 3012 */ 3013 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_NotS_Last( 3014 long groupId, long categoryId, int status, 3015 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3016 throws com.liferay.portal.kernel.exception.SystemException { 3017 return getPersistence() 3018 .fetchByG_C_NotS_Last(groupId, categoryId, status, 3019 orderByComparator); 3020 } 3021 3022 /** 3023 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId = ? and status ≠ ?. 3024 * 3025 * @param threadId the primary key of the current message boards thread 3026 * @param groupId the group ID 3027 * @param categoryId the category ID 3028 * @param status the status 3029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3030 * @return the previous, current, and next message boards thread 3031 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3032 * @throws SystemException if a system exception occurred 3033 */ 3034 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_NotS_PrevAndNext( 3035 long threadId, long groupId, long categoryId, int status, 3036 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3037 throws com.liferay.portal.kernel.exception.SystemException, 3038 com.liferay.portlet.messageboards.NoSuchThreadException { 3039 return getPersistence() 3040 .findByG_C_NotS_PrevAndNext(threadId, groupId, categoryId, 3041 status, orderByComparator); 3042 } 3043 3044 /** 3045 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status ≠ ?. 3046 * 3047 * @param groupId the group ID 3048 * @param categoryId the category ID 3049 * @param status the status 3050 * @return the matching message boards threads that the user has permission to view 3051 * @throws SystemException if a system exception occurred 3052 */ 3053 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3054 long groupId, long categoryId, int status) 3055 throws com.liferay.portal.kernel.exception.SystemException { 3056 return getPersistence().filterFindByG_C_NotS(groupId, categoryId, status); 3057 } 3058 3059 /** 3060 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status ≠ ?. 3061 * 3062 * <p> 3063 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3064 * </p> 3065 * 3066 * @param groupId the group ID 3067 * @param categoryId the category ID 3068 * @param status the status 3069 * @param start the lower bound of the range of message boards threads 3070 * @param end the upper bound of the range of message boards threads (not inclusive) 3071 * @return the range of matching message boards threads that the user has permission to view 3072 * @throws SystemException if a system exception occurred 3073 */ 3074 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3075 long groupId, long categoryId, int status, int start, int end) 3076 throws com.liferay.portal.kernel.exception.SystemException { 3077 return getPersistence() 3078 .filterFindByG_C_NotS(groupId, categoryId, status, start, end); 3079 } 3080 3081 /** 3082 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId = ? and status ≠ ?. 3083 * 3084 * <p> 3085 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3086 * </p> 3087 * 3088 * @param groupId the group ID 3089 * @param categoryId the category ID 3090 * @param status the status 3091 * @param start the lower bound of the range of message boards threads 3092 * @param end the upper bound of the range of message boards threads (not inclusive) 3093 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3094 * @return the ordered range of matching message boards threads that the user has permission to view 3095 * @throws SystemException if a system exception occurred 3096 */ 3097 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3098 long groupId, long categoryId, int status, int start, int end, 3099 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3100 throws com.liferay.portal.kernel.exception.SystemException { 3101 return getPersistence() 3102 .filterFindByG_C_NotS(groupId, categoryId, status, start, 3103 end, orderByComparator); 3104 } 3105 3106 /** 3107 * 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 ≠ ?. 3108 * 3109 * @param threadId the primary key of the current message boards thread 3110 * @param groupId the group ID 3111 * @param categoryId the category ID 3112 * @param status the status 3113 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3114 * @return the previous, current, and next message boards thread 3115 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3116 * @throws SystemException if a system exception occurred 3117 */ 3118 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_NotS_PrevAndNext( 3119 long threadId, long groupId, long categoryId, int status, 3120 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3121 throws com.liferay.portal.kernel.exception.SystemException, 3122 com.liferay.portlet.messageboards.NoSuchThreadException { 3123 return getPersistence() 3124 .filterFindByG_C_NotS_PrevAndNext(threadId, groupId, 3125 categoryId, status, orderByComparator); 3126 } 3127 3128 /** 3129 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status ≠ ?. 3130 * 3131 * @param groupId the group ID 3132 * @param categoryIds the category IDs 3133 * @param status the status 3134 * @return the matching message boards threads that the user has permission to view 3135 * @throws SystemException if a system exception occurred 3136 */ 3137 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3138 long groupId, long[] categoryIds, int status) 3139 throws com.liferay.portal.kernel.exception.SystemException { 3140 return getPersistence() 3141 .filterFindByG_C_NotS(groupId, categoryIds, status); 3142 } 3143 3144 /** 3145 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status ≠ ?. 3146 * 3147 * <p> 3148 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3149 * </p> 3150 * 3151 * @param groupId the group ID 3152 * @param categoryIds the category IDs 3153 * @param status the status 3154 * @param start the lower bound of the range of message boards threads 3155 * @param end the upper bound of the range of message boards threads (not inclusive) 3156 * @return the range of matching message boards threads that the user has permission to view 3157 * @throws SystemException if a system exception occurred 3158 */ 3159 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3160 long groupId, long[] categoryIds, int status, int start, int end) 3161 throws com.liferay.portal.kernel.exception.SystemException { 3162 return getPersistence() 3163 .filterFindByG_C_NotS(groupId, categoryIds, status, start, 3164 end); 3165 } 3166 3167 /** 3168 * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status ≠ ?. 3169 * 3170 * <p> 3171 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3172 * </p> 3173 * 3174 * @param groupId the group ID 3175 * @param categoryIds the category IDs 3176 * @param status the status 3177 * @param start the lower bound of the range of message boards threads 3178 * @param end the upper bound of the range of message boards threads (not inclusive) 3179 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3180 * @return the ordered range of matching message boards threads that the user has permission to view 3181 * @throws SystemException if a system exception occurred 3182 */ 3183 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS( 3184 long groupId, long[] categoryIds, int status, int start, int end, 3185 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3186 throws com.liferay.portal.kernel.exception.SystemException { 3187 return getPersistence() 3188 .filterFindByG_C_NotS(groupId, categoryIds, status, start, 3189 end, orderByComparator); 3190 } 3191 3192 /** 3193 * Returns all the message boards threads where groupId = ? and categoryId = any ? and status ≠ ?. 3194 * 3195 * <p> 3196 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3197 * </p> 3198 * 3199 * @param groupId the group ID 3200 * @param categoryIds the category IDs 3201 * @param status the status 3202 * @return the matching message boards threads 3203 * @throws SystemException if a system exception occurred 3204 */ 3205 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 3206 long groupId, long[] categoryIds, int status) 3207 throws com.liferay.portal.kernel.exception.SystemException { 3208 return getPersistence().findByG_C_NotS(groupId, categoryIds, status); 3209 } 3210 3211 /** 3212 * Returns a range of all the message boards threads where groupId = ? and categoryId = any ? and status ≠ ?. 3213 * 3214 * <p> 3215 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3216 * </p> 3217 * 3218 * @param groupId the group ID 3219 * @param categoryIds the category IDs 3220 * @param status the status 3221 * @param start the lower bound of the range of message boards threads 3222 * @param end the upper bound of the range of message boards threads (not inclusive) 3223 * @return the range of matching message boards threads 3224 * @throws SystemException if a system exception occurred 3225 */ 3226 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 3227 long groupId, long[] categoryIds, int status, int start, int end) 3228 throws com.liferay.portal.kernel.exception.SystemException { 3229 return getPersistence() 3230 .findByG_C_NotS(groupId, categoryIds, status, start, end); 3231 } 3232 3233 /** 3234 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId = any ? and status ≠ ?. 3235 * 3236 * <p> 3237 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3238 * </p> 3239 * 3240 * @param groupId the group ID 3241 * @param categoryIds the category IDs 3242 * @param status the status 3243 * @param start the lower bound of the range of message boards threads 3244 * @param end the upper bound of the range of message boards threads (not inclusive) 3245 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3246 * @return the ordered range of matching message boards threads 3247 * @throws SystemException if a system exception occurred 3248 */ 3249 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS( 3250 long groupId, long[] categoryIds, int status, int start, int end, 3251 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3252 throws com.liferay.portal.kernel.exception.SystemException { 3253 return getPersistence() 3254 .findByG_C_NotS(groupId, categoryIds, status, start, end, 3255 orderByComparator); 3256 } 3257 3258 /** 3259 * Removes all the message boards threads where groupId = ? and categoryId = ? and status ≠ ? from the database. 3260 * 3261 * @param groupId the group ID 3262 * @param categoryId the category ID 3263 * @param status the status 3264 * @throws SystemException if a system exception occurred 3265 */ 3266 public static void removeByG_C_NotS(long groupId, long categoryId, 3267 int status) throws com.liferay.portal.kernel.exception.SystemException { 3268 getPersistence().removeByG_C_NotS(groupId, categoryId, status); 3269 } 3270 3271 /** 3272 * Returns the number of message boards threads where groupId = ? and categoryId = ? and status ≠ ?. 3273 * 3274 * @param groupId the group ID 3275 * @param categoryId the category ID 3276 * @param status the status 3277 * @return the number of matching message boards threads 3278 * @throws SystemException if a system exception occurred 3279 */ 3280 public static int countByG_C_NotS(long groupId, long categoryId, int status) 3281 throws com.liferay.portal.kernel.exception.SystemException { 3282 return getPersistence().countByG_C_NotS(groupId, categoryId, status); 3283 } 3284 3285 /** 3286 * Returns the number of message boards threads where groupId = ? and categoryId = any ? and status ≠ ?. 3287 * 3288 * @param groupId the group ID 3289 * @param categoryIds the category IDs 3290 * @param status the status 3291 * @return the number of matching message boards threads 3292 * @throws SystemException if a system exception occurred 3293 */ 3294 public static int countByG_C_NotS(long groupId, long[] categoryIds, 3295 int status) throws com.liferay.portal.kernel.exception.SystemException { 3296 return getPersistence().countByG_C_NotS(groupId, categoryIds, status); 3297 } 3298 3299 /** 3300 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = ? and status ≠ ?. 3301 * 3302 * @param groupId the group ID 3303 * @param categoryId the category ID 3304 * @param status the status 3305 * @return the number of matching message boards threads that the user has permission to view 3306 * @throws SystemException if a system exception occurred 3307 */ 3308 public static int filterCountByG_C_NotS(long groupId, long categoryId, 3309 int status) throws com.liferay.portal.kernel.exception.SystemException { 3310 return getPersistence() 3311 .filterCountByG_C_NotS(groupId, categoryId, status); 3312 } 3313 3314 /** 3315 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId = any ? and status ≠ ?. 3316 * 3317 * @param groupId the group ID 3318 * @param categoryIds the category IDs 3319 * @param status the status 3320 * @return the number of matching message boards threads that the user has permission to view 3321 * @throws SystemException if a system exception occurred 3322 */ 3323 public static int filterCountByG_C_NotS(long groupId, long[] categoryIds, 3324 int status) throws com.liferay.portal.kernel.exception.SystemException { 3325 return getPersistence() 3326 .filterCountByG_C_NotS(groupId, categoryIds, status); 3327 } 3328 3329 /** 3330 * Returns all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 3331 * 3332 * @param groupId the group ID 3333 * @param categoryId the category ID 3334 * @param status the status 3335 * @return the matching message boards threads 3336 * @throws SystemException if a system exception occurred 3337 */ 3338 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 3339 long groupId, long categoryId, int status) 3340 throws com.liferay.portal.kernel.exception.SystemException { 3341 return getPersistence().findByG_NotC_S(groupId, categoryId, status); 3342 } 3343 3344 /** 3345 * Returns a range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 3346 * 3347 * <p> 3348 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3349 * </p> 3350 * 3351 * @param groupId the group ID 3352 * @param categoryId the category ID 3353 * @param status the status 3354 * @param start the lower bound of the range of message boards threads 3355 * @param end the upper bound of the range of message boards threads (not inclusive) 3356 * @return the range of matching message boards threads 3357 * @throws SystemException if a system exception occurred 3358 */ 3359 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 3360 long groupId, long categoryId, int status, int start, int end) 3361 throws com.liferay.portal.kernel.exception.SystemException { 3362 return getPersistence() 3363 .findByG_NotC_S(groupId, categoryId, status, start, end); 3364 } 3365 3366 /** 3367 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 3368 * 3369 * <p> 3370 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3371 * </p> 3372 * 3373 * @param groupId the group ID 3374 * @param categoryId the category ID 3375 * @param status the status 3376 * @param start the lower bound of the range of message boards threads 3377 * @param end the upper bound of the range of message boards threads (not inclusive) 3378 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3379 * @return the ordered range of matching message boards threads 3380 * @throws SystemException if a system exception occurred 3381 */ 3382 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S( 3383 long groupId, long categoryId, int status, int start, int end, 3384 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3385 throws com.liferay.portal.kernel.exception.SystemException { 3386 return getPersistence() 3387 .findByG_NotC_S(groupId, categoryId, status, start, end, 3388 orderByComparator); 3389 } 3390 3391 /** 3392 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 3393 * 3394 * @param groupId the group ID 3395 * @param categoryId the category ID 3396 * @param status the status 3397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3398 * @return the first matching message boards thread 3399 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 3400 * @throws SystemException if a system exception occurred 3401 */ 3402 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First( 3403 long groupId, long categoryId, int status, 3404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3405 throws com.liferay.portal.kernel.exception.SystemException, 3406 com.liferay.portlet.messageboards.NoSuchThreadException { 3407 return getPersistence() 3408 .findByG_NotC_S_First(groupId, categoryId, status, 3409 orderByComparator); 3410 } 3411 3412 /** 3413 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 3414 * 3415 * @param groupId the group ID 3416 * @param categoryId the category ID 3417 * @param status the status 3418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3419 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 3420 * @throws SystemException if a system exception occurred 3421 */ 3422 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_First( 3423 long groupId, long categoryId, int status, 3424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3425 throws com.liferay.portal.kernel.exception.SystemException { 3426 return getPersistence() 3427 .fetchByG_NotC_S_First(groupId, categoryId, status, 3428 orderByComparator); 3429 } 3430 3431 /** 3432 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 3433 * 3434 * @param groupId the group ID 3435 * @param categoryId the category ID 3436 * @param status the status 3437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3438 * @return the last matching message boards thread 3439 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 3440 * @throws SystemException if a system exception occurred 3441 */ 3442 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last( 3443 long groupId, long categoryId, int status, 3444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3445 throws com.liferay.portal.kernel.exception.SystemException, 3446 com.liferay.portlet.messageboards.NoSuchThreadException { 3447 return getPersistence() 3448 .findByG_NotC_S_Last(groupId, categoryId, status, 3449 orderByComparator); 3450 } 3451 3452 /** 3453 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 3454 * 3455 * @param groupId the group ID 3456 * @param categoryId the category ID 3457 * @param status the status 3458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3459 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 3460 * @throws SystemException if a system exception occurred 3461 */ 3462 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_Last( 3463 long groupId, long categoryId, int status, 3464 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3465 throws com.liferay.portal.kernel.exception.SystemException { 3466 return getPersistence() 3467 .fetchByG_NotC_S_Last(groupId, categoryId, status, 3468 orderByComparator); 3469 } 3470 3471 /** 3472 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status = ?. 3473 * 3474 * @param threadId the primary key of the current message boards thread 3475 * @param groupId the group ID 3476 * @param categoryId the category ID 3477 * @param status the status 3478 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3479 * @return the previous, current, and next message boards thread 3480 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3481 * @throws SystemException if a system exception occurred 3482 */ 3483 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext( 3484 long threadId, long groupId, long categoryId, int status, 3485 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3486 throws com.liferay.portal.kernel.exception.SystemException, 3487 com.liferay.portlet.messageboards.NoSuchThreadException { 3488 return getPersistence() 3489 .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId, 3490 status, orderByComparator); 3491 } 3492 3493 /** 3494 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 3495 * 3496 * @param groupId the group ID 3497 * @param categoryId the category ID 3498 * @param status the status 3499 * @return the matching message boards threads that the user has permission to view 3500 * @throws SystemException if a system exception occurred 3501 */ 3502 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 3503 long groupId, long categoryId, int status) 3504 throws com.liferay.portal.kernel.exception.SystemException { 3505 return getPersistence().filterFindByG_NotC_S(groupId, categoryId, status); 3506 } 3507 3508 /** 3509 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 3510 * 3511 * <p> 3512 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3513 * </p> 3514 * 3515 * @param groupId the group ID 3516 * @param categoryId the category ID 3517 * @param status the status 3518 * @param start the lower bound of the range of message boards threads 3519 * @param end the upper bound of the range of message boards threads (not inclusive) 3520 * @return the range of matching message boards threads that the user has permission to view 3521 * @throws SystemException if a system exception occurred 3522 */ 3523 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 3524 long groupId, long categoryId, int status, int start, int end) 3525 throws com.liferay.portal.kernel.exception.SystemException { 3526 return getPersistence() 3527 .filterFindByG_NotC_S(groupId, categoryId, status, start, end); 3528 } 3529 3530 /** 3531 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId ≠ ? and status = ?. 3532 * 3533 * <p> 3534 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3535 * </p> 3536 * 3537 * @param groupId the group ID 3538 * @param categoryId the category ID 3539 * @param status the status 3540 * @param start the lower bound of the range of message boards threads 3541 * @param end the upper bound of the range of message boards threads (not inclusive) 3542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3543 * @return the ordered range of matching message boards threads that the user has permission to view 3544 * @throws SystemException if a system exception occurred 3545 */ 3546 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S( 3547 long groupId, long categoryId, int status, int start, int end, 3548 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3549 throws com.liferay.portal.kernel.exception.SystemException { 3550 return getPersistence() 3551 .filterFindByG_NotC_S(groupId, categoryId, status, start, 3552 end, orderByComparator); 3553 } 3554 3555 /** 3556 * 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 = ?. 3557 * 3558 * @param threadId the primary key of the current message boards thread 3559 * @param groupId the group ID 3560 * @param categoryId the category ID 3561 * @param status the status 3562 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3563 * @return the previous, current, and next message boards thread 3564 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3565 * @throws SystemException if a system exception occurred 3566 */ 3567 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_S_PrevAndNext( 3568 long threadId, long groupId, long categoryId, int status, 3569 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3570 throws com.liferay.portal.kernel.exception.SystemException, 3571 com.liferay.portlet.messageboards.NoSuchThreadException { 3572 return getPersistence() 3573 .filterFindByG_NotC_S_PrevAndNext(threadId, groupId, 3574 categoryId, status, orderByComparator); 3575 } 3576 3577 /** 3578 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? and status = ? from the database. 3579 * 3580 * @param groupId the group ID 3581 * @param categoryId the category ID 3582 * @param status the status 3583 * @throws SystemException if a system exception occurred 3584 */ 3585 public static void removeByG_NotC_S(long groupId, long categoryId, 3586 int status) throws com.liferay.portal.kernel.exception.SystemException { 3587 getPersistence().removeByG_NotC_S(groupId, categoryId, status); 3588 } 3589 3590 /** 3591 * Returns the number of message boards threads where groupId = ? and categoryId ≠ ? and status = ?. 3592 * 3593 * @param groupId the group ID 3594 * @param categoryId the category ID 3595 * @param status the status 3596 * @return the number of matching message boards threads 3597 * @throws SystemException if a system exception occurred 3598 */ 3599 public static int countByG_NotC_S(long groupId, long categoryId, int status) 3600 throws com.liferay.portal.kernel.exception.SystemException { 3601 return getPersistence().countByG_NotC_S(groupId, categoryId, status); 3602 } 3603 3604 /** 3605 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status = ?. 3606 * 3607 * @param groupId the group ID 3608 * @param categoryId the category ID 3609 * @param status the status 3610 * @return the number of matching message boards threads that the user has permission to view 3611 * @throws SystemException if a system exception occurred 3612 */ 3613 public static int filterCountByG_NotC_S(long groupId, long categoryId, 3614 int status) throws com.liferay.portal.kernel.exception.SystemException { 3615 return getPersistence() 3616 .filterCountByG_NotC_S(groupId, categoryId, status); 3617 } 3618 3619 /** 3620 * Returns all the message boards threads where groupId = ? and categoryId ≠ ? and status ≠ ?. 3621 * 3622 * @param groupId the group ID 3623 * @param categoryId the category ID 3624 * @param status the status 3625 * @return the matching message boards threads 3626 * @throws SystemException if a system exception occurred 3627 */ 3628 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS( 3629 long groupId, long categoryId, int status) 3630 throws com.liferay.portal.kernel.exception.SystemException { 3631 return getPersistence().findByG_NotC_NotS(groupId, categoryId, status); 3632 } 3633 3634 /** 3635 * Returns a range of all the message boards threads where groupId = ? and categoryId ≠ ? and status ≠ ?. 3636 * 3637 * <p> 3638 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3639 * </p> 3640 * 3641 * @param groupId the group ID 3642 * @param categoryId the category ID 3643 * @param status the status 3644 * @param start the lower bound of the range of message boards threads 3645 * @param end the upper bound of the range of message boards threads (not inclusive) 3646 * @return the range of matching message boards threads 3647 * @throws SystemException if a system exception occurred 3648 */ 3649 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS( 3650 long groupId, long categoryId, int status, int start, int end) 3651 throws com.liferay.portal.kernel.exception.SystemException { 3652 return getPersistence() 3653 .findByG_NotC_NotS(groupId, categoryId, status, start, end); 3654 } 3655 3656 /** 3657 * Returns an ordered range of all the message boards threads where groupId = ? and categoryId ≠ ? and status ≠ ?. 3658 * 3659 * <p> 3660 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3661 * </p> 3662 * 3663 * @param groupId the group ID 3664 * @param categoryId the category ID 3665 * @param status the status 3666 * @param start the lower bound of the range of message boards threads 3667 * @param end the upper bound of the range of message boards threads (not inclusive) 3668 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3669 * @return the ordered range of matching message boards threads 3670 * @throws SystemException if a system exception occurred 3671 */ 3672 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS( 3673 long groupId, long categoryId, int status, int start, int end, 3674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3675 throws com.liferay.portal.kernel.exception.SystemException { 3676 return getPersistence() 3677 .findByG_NotC_NotS(groupId, categoryId, status, start, end, 3678 orderByComparator); 3679 } 3680 3681 /** 3682 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status ≠ ?. 3683 * 3684 * @param groupId the group ID 3685 * @param categoryId the category ID 3686 * @param status the status 3687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3688 * @return the first matching message boards thread 3689 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 3690 * @throws SystemException if a system exception occurred 3691 */ 3692 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_NotS_First( 3693 long groupId, long categoryId, int status, 3694 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3695 throws com.liferay.portal.kernel.exception.SystemException, 3696 com.liferay.portlet.messageboards.NoSuchThreadException { 3697 return getPersistence() 3698 .findByG_NotC_NotS_First(groupId, categoryId, status, 3699 orderByComparator); 3700 } 3701 3702 /** 3703 * Returns the first message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status ≠ ?. 3704 * 3705 * @param groupId the group ID 3706 * @param categoryId the category ID 3707 * @param status the status 3708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3709 * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 3710 * @throws SystemException if a system exception occurred 3711 */ 3712 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_NotS_First( 3713 long groupId, long categoryId, int status, 3714 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3715 throws com.liferay.portal.kernel.exception.SystemException { 3716 return getPersistence() 3717 .fetchByG_NotC_NotS_First(groupId, categoryId, status, 3718 orderByComparator); 3719 } 3720 3721 /** 3722 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status ≠ ?. 3723 * 3724 * @param groupId the group ID 3725 * @param categoryId the category ID 3726 * @param status the status 3727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3728 * @return the last matching message boards thread 3729 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found 3730 * @throws SystemException if a system exception occurred 3731 */ 3732 public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_NotS_Last( 3733 long groupId, long categoryId, int status, 3734 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3735 throws com.liferay.portal.kernel.exception.SystemException, 3736 com.liferay.portlet.messageboards.NoSuchThreadException { 3737 return getPersistence() 3738 .findByG_NotC_NotS_Last(groupId, categoryId, status, 3739 orderByComparator); 3740 } 3741 3742 /** 3743 * Returns the last message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status ≠ ?. 3744 * 3745 * @param groupId the group ID 3746 * @param categoryId the category ID 3747 * @param status the status 3748 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3749 * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found 3750 * @throws SystemException if a system exception occurred 3751 */ 3752 public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_NotS_Last( 3753 long groupId, long categoryId, int status, 3754 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3755 throws com.liferay.portal.kernel.exception.SystemException { 3756 return getPersistence() 3757 .fetchByG_NotC_NotS_Last(groupId, categoryId, status, 3758 orderByComparator); 3759 } 3760 3761 /** 3762 * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = ? and categoryId ≠ ? and status ≠ ?. 3763 * 3764 * @param threadId the primary key of the current message boards thread 3765 * @param groupId the group ID 3766 * @param categoryId the category ID 3767 * @param status the status 3768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3769 * @return the previous, current, and next message boards thread 3770 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3771 * @throws SystemException if a system exception occurred 3772 */ 3773 public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_NotS_PrevAndNext( 3774 long threadId, long groupId, long categoryId, int status, 3775 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3776 throws com.liferay.portal.kernel.exception.SystemException, 3777 com.liferay.portlet.messageboards.NoSuchThreadException { 3778 return getPersistence() 3779 .findByG_NotC_NotS_PrevAndNext(threadId, groupId, 3780 categoryId, status, orderByComparator); 3781 } 3782 3783 /** 3784 * Returns all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status ≠ ?. 3785 * 3786 * @param groupId the group ID 3787 * @param categoryId the category ID 3788 * @param status the status 3789 * @return the matching message boards threads that the user has permission to view 3790 * @throws SystemException if a system exception occurred 3791 */ 3792 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS( 3793 long groupId, long categoryId, int status) 3794 throws com.liferay.portal.kernel.exception.SystemException { 3795 return getPersistence() 3796 .filterFindByG_NotC_NotS(groupId, categoryId, status); 3797 } 3798 3799 /** 3800 * Returns a range of all the message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status ≠ ?. 3801 * 3802 * <p> 3803 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3804 * </p> 3805 * 3806 * @param groupId the group ID 3807 * @param categoryId the category ID 3808 * @param status the status 3809 * @param start the lower bound of the range of message boards threads 3810 * @param end the upper bound of the range of message boards threads (not inclusive) 3811 * @return the range of matching message boards threads that the user has permission to view 3812 * @throws SystemException if a system exception occurred 3813 */ 3814 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS( 3815 long groupId, long categoryId, int status, int start, int end) 3816 throws com.liferay.portal.kernel.exception.SystemException { 3817 return getPersistence() 3818 .filterFindByG_NotC_NotS(groupId, categoryId, status, start, 3819 end); 3820 } 3821 3822 /** 3823 * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = ? and categoryId ≠ ? and status ≠ ?. 3824 * 3825 * <p> 3826 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3827 * </p> 3828 * 3829 * @param groupId the group ID 3830 * @param categoryId the category ID 3831 * @param status the status 3832 * @param start the lower bound of the range of message boards threads 3833 * @param end the upper bound of the range of message boards threads (not inclusive) 3834 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3835 * @return the ordered range of matching message boards threads that the user has permission to view 3836 * @throws SystemException if a system exception occurred 3837 */ 3838 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS( 3839 long groupId, long categoryId, int status, int start, int end, 3840 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3841 throws com.liferay.portal.kernel.exception.SystemException { 3842 return getPersistence() 3843 .filterFindByG_NotC_NotS(groupId, categoryId, status, start, 3844 end, orderByComparator); 3845 } 3846 3847 /** 3848 * 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 ≠ ?. 3849 * 3850 * @param threadId the primary key of the current message boards thread 3851 * @param groupId the group ID 3852 * @param categoryId the category ID 3853 * @param status the status 3854 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3855 * @return the previous, current, and next message boards thread 3856 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3857 * @throws SystemException if a system exception occurred 3858 */ 3859 public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_NotS_PrevAndNext( 3860 long threadId, long groupId, long categoryId, int status, 3861 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3862 throws com.liferay.portal.kernel.exception.SystemException, 3863 com.liferay.portlet.messageboards.NoSuchThreadException { 3864 return getPersistence() 3865 .filterFindByG_NotC_NotS_PrevAndNext(threadId, groupId, 3866 categoryId, status, orderByComparator); 3867 } 3868 3869 /** 3870 * Removes all the message boards threads where groupId = ? and categoryId ≠ ? and status ≠ ? from the database. 3871 * 3872 * @param groupId the group ID 3873 * @param categoryId the category ID 3874 * @param status the status 3875 * @throws SystemException if a system exception occurred 3876 */ 3877 public static void removeByG_NotC_NotS(long groupId, long categoryId, 3878 int status) throws com.liferay.portal.kernel.exception.SystemException { 3879 getPersistence().removeByG_NotC_NotS(groupId, categoryId, status); 3880 } 3881 3882 /** 3883 * Returns the number of message boards threads where groupId = ? and categoryId ≠ ? and status ≠ ?. 3884 * 3885 * @param groupId the group ID 3886 * @param categoryId the category ID 3887 * @param status the status 3888 * @return the number of matching message boards threads 3889 * @throws SystemException if a system exception occurred 3890 */ 3891 public static int countByG_NotC_NotS(long groupId, long categoryId, 3892 int status) throws com.liferay.portal.kernel.exception.SystemException { 3893 return getPersistence().countByG_NotC_NotS(groupId, categoryId, status); 3894 } 3895 3896 /** 3897 * Returns the number of message boards threads that the user has permission to view where groupId = ? and categoryId ≠ ? and status ≠ ?. 3898 * 3899 * @param groupId the group ID 3900 * @param categoryId the category ID 3901 * @param status the status 3902 * @return the number of matching message boards threads that the user has permission to view 3903 * @throws SystemException if a system exception occurred 3904 */ 3905 public static int filterCountByG_NotC_NotS(long groupId, long categoryId, 3906 int status) throws com.liferay.portal.kernel.exception.SystemException { 3907 return getPersistence() 3908 .filterCountByG_NotC_NotS(groupId, categoryId, status); 3909 } 3910 3911 /** 3912 * Caches the message boards thread in the entity cache if it is enabled. 3913 * 3914 * @param mbThread the message boards thread 3915 */ 3916 public static void cacheResult( 3917 com.liferay.portlet.messageboards.model.MBThread mbThread) { 3918 getPersistence().cacheResult(mbThread); 3919 } 3920 3921 /** 3922 * Caches the message boards threads in the entity cache if it is enabled. 3923 * 3924 * @param mbThreads the message boards threads 3925 */ 3926 public static void cacheResult( 3927 java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) { 3928 getPersistence().cacheResult(mbThreads); 3929 } 3930 3931 /** 3932 * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database. 3933 * 3934 * @param threadId the primary key for the new message boards thread 3935 * @return the new message boards thread 3936 */ 3937 public static com.liferay.portlet.messageboards.model.MBThread create( 3938 long threadId) { 3939 return getPersistence().create(threadId); 3940 } 3941 3942 /** 3943 * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners. 3944 * 3945 * @param threadId the primary key of the message boards thread 3946 * @return the message boards thread that was removed 3947 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3948 * @throws SystemException if a system exception occurred 3949 */ 3950 public static com.liferay.portlet.messageboards.model.MBThread remove( 3951 long threadId) 3952 throws com.liferay.portal.kernel.exception.SystemException, 3953 com.liferay.portlet.messageboards.NoSuchThreadException { 3954 return getPersistence().remove(threadId); 3955 } 3956 3957 public static com.liferay.portlet.messageboards.model.MBThread updateImpl( 3958 com.liferay.portlet.messageboards.model.MBThread mbThread) 3959 throws com.liferay.portal.kernel.exception.SystemException { 3960 return getPersistence().updateImpl(mbThread); 3961 } 3962 3963 /** 3964 * Returns the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found. 3965 * 3966 * @param threadId the primary key of the message boards thread 3967 * @return the message boards thread 3968 * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found 3969 * @throws SystemException if a system exception occurred 3970 */ 3971 public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey( 3972 long threadId) 3973 throws com.liferay.portal.kernel.exception.SystemException, 3974 com.liferay.portlet.messageboards.NoSuchThreadException { 3975 return getPersistence().findByPrimaryKey(threadId); 3976 } 3977 3978 /** 3979 * Returns the message boards thread with the primary key or returns <code>null</code> if it could not be found. 3980 * 3981 * @param threadId the primary key of the message boards thread 3982 * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found 3983 * @throws SystemException if a system exception occurred 3984 */ 3985 public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey( 3986 long threadId) 3987 throws com.liferay.portal.kernel.exception.SystemException { 3988 return getPersistence().fetchByPrimaryKey(threadId); 3989 } 3990 3991 /** 3992 * Returns all the message boards threads. 3993 * 3994 * @return the message boards threads 3995 * @throws SystemException if a system exception occurred 3996 */ 3997 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll() 3998 throws com.liferay.portal.kernel.exception.SystemException { 3999 return getPersistence().findAll(); 4000 } 4001 4002 /** 4003 * Returns a range of all the message boards threads. 4004 * 4005 * <p> 4006 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4007 * </p> 4008 * 4009 * @param start the lower bound of the range of message boards threads 4010 * @param end the upper bound of the range of message boards threads (not inclusive) 4011 * @return the range of message boards threads 4012 * @throws SystemException if a system exception occurred 4013 */ 4014 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 4015 int start, int end) 4016 throws com.liferay.portal.kernel.exception.SystemException { 4017 return getPersistence().findAll(start, end); 4018 } 4019 4020 /** 4021 * Returns an ordered range of all the message boards threads. 4022 * 4023 * <p> 4024 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4025 * </p> 4026 * 4027 * @param start the lower bound of the range of message boards threads 4028 * @param end the upper bound of the range of message boards threads (not inclusive) 4029 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4030 * @return the ordered range of message boards threads 4031 * @throws SystemException if a system exception occurred 4032 */ 4033 public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll( 4034 int start, int end, 4035 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4036 throws com.liferay.portal.kernel.exception.SystemException { 4037 return getPersistence().findAll(start, end, orderByComparator); 4038 } 4039 4040 /** 4041 * Removes all the message boards threads from the database. 4042 * 4043 * @throws SystemException if a system exception occurred 4044 */ 4045 public static void removeAll() 4046 throws com.liferay.portal.kernel.exception.SystemException { 4047 getPersistence().removeAll(); 4048 } 4049 4050 /** 4051 * Returns the number of message boards threads. 4052 * 4053 * @return the number of message boards threads 4054 * @throws SystemException if a system exception occurred 4055 */ 4056 public static int countAll() 4057 throws com.liferay.portal.kernel.exception.SystemException { 4058 return getPersistence().countAll(); 4059 } 4060 4061 public static MBThreadPersistence getPersistence() { 4062 if (_persistence == null) { 4063 _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName()); 4064 4065 ReferenceRegistry.registerReference(MBThreadUtil.class, 4066 "_persistence"); 4067 } 4068 4069 return _persistence; 4070 } 4071 4072 /** 4073 * @deprecated As of 6.2.0 4074 */ 4075 public void setPersistence(MBThreadPersistence persistence) { 4076 } 4077 4078 private static MBThreadPersistence _persistence; 4079 }