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