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