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