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