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