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