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