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