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