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