001 /** 002 * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.service.ServiceContext; 022 023 import com.liferay.portlet.messageboards.model.MBCategory; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the message boards category service. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see MBCategoryPersistence 036 * @see MBCategoryPersistenceImpl 037 * @generated 038 */ 039 public class MBCategoryUtil { 040 /** 041 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 042 */ 043 public static void clearCache() { 044 getPersistence().clearCache(); 045 } 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 049 */ 050 public static void clearCache(MBCategory mbCategory) { 051 getPersistence().clearCache(mbCategory); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 056 */ 057 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 058 throws SystemException { 059 return getPersistence().countWithDynamicQuery(dynamicQuery); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 064 */ 065 public static List<MBCategory> findWithDynamicQuery( 066 DynamicQuery dynamicQuery) throws SystemException { 067 return getPersistence().findWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 072 */ 073 public static List<MBCategory> findWithDynamicQuery( 074 DynamicQuery dynamicQuery, int start, int end) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 081 */ 082 public static List<MBCategory> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end, 084 OrderByComparator orderByComparator) throws SystemException { 085 return getPersistence() 086 .findWithDynamicQuery(dynamicQuery, start, end, 087 orderByComparator); 088 } 089 090 /** 091 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 092 */ 093 public static MBCategory remove(MBCategory mbCategory) 094 throws SystemException { 095 return getPersistence().remove(mbCategory); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 100 */ 101 public static MBCategory update(MBCategory mbCategory, boolean merge) 102 throws SystemException { 103 return getPersistence().update(mbCategory, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static MBCategory update(MBCategory mbCategory, boolean merge, 110 ServiceContext serviceContext) throws SystemException { 111 return getPersistence().update(mbCategory, merge, serviceContext); 112 } 113 114 /** 115 * Caches the message boards category in the entity cache if it is enabled. 116 * 117 * @param mbCategory the message boards category to cache 118 */ 119 public static void cacheResult( 120 com.liferay.portlet.messageboards.model.MBCategory mbCategory) { 121 getPersistence().cacheResult(mbCategory); 122 } 123 124 /** 125 * Caches the message boards categories in the entity cache if it is enabled. 126 * 127 * @param mbCategories the message boards categories to cache 128 */ 129 public static void cacheResult( 130 java.util.List<com.liferay.portlet.messageboards.model.MBCategory> mbCategories) { 131 getPersistence().cacheResult(mbCategories); 132 } 133 134 /** 135 * Creates a new message boards category with the primary key. 136 * 137 * @param categoryId the primary key for the new message boards category 138 * @return the new message boards category 139 */ 140 public static com.liferay.portlet.messageboards.model.MBCategory create( 141 long categoryId) { 142 return getPersistence().create(categoryId); 143 } 144 145 /** 146 * Removes the message boards category with the primary key from the database. Also notifies the appropriate model listeners. 147 * 148 * @param categoryId the primary key of the message boards category to remove 149 * @return the message boards category that was removed 150 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public static com.liferay.portlet.messageboards.model.MBCategory remove( 154 long categoryId) 155 throws com.liferay.portal.kernel.exception.SystemException, 156 com.liferay.portlet.messageboards.NoSuchCategoryException { 157 return getPersistence().remove(categoryId); 158 } 159 160 public static com.liferay.portlet.messageboards.model.MBCategory updateImpl( 161 com.liferay.portlet.messageboards.model.MBCategory mbCategory, 162 boolean merge) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence().updateImpl(mbCategory, merge); 165 } 166 167 /** 168 * Finds the message boards category with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 169 * 170 * @param categoryId the primary key of the message boards category to find 171 * @return the message boards category 172 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.messageboards.model.MBCategory findByPrimaryKey( 176 long categoryId) 177 throws com.liferay.portal.kernel.exception.SystemException, 178 com.liferay.portlet.messageboards.NoSuchCategoryException { 179 return getPersistence().findByPrimaryKey(categoryId); 180 } 181 182 /** 183 * Finds the message boards category with the primary key or returns <code>null</code> if it could not be found. 184 * 185 * @param categoryId the primary key of the message boards category to find 186 * @return the message boards category, or <code>null</code> if a message boards category with the primary key could not be found 187 * @throws SystemException if a system exception occurred 188 */ 189 public static com.liferay.portlet.messageboards.model.MBCategory fetchByPrimaryKey( 190 long categoryId) 191 throws com.liferay.portal.kernel.exception.SystemException { 192 return getPersistence().fetchByPrimaryKey(categoryId); 193 } 194 195 /** 196 * Finds all the message boards categories where uuid = ?. 197 * 198 * @param uuid the uuid to search with 199 * @return the matching message boards categories 200 * @throws SystemException if a system exception occurred 201 */ 202 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 203 java.lang.String uuid) 204 throws com.liferay.portal.kernel.exception.SystemException { 205 return getPersistence().findByUuid(uuid); 206 } 207 208 /** 209 * Finds a range of all the message boards categories where uuid = ?. 210 * 211 * <p> 212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 213 * </p> 214 * 215 * @param uuid the uuid to search with 216 * @param start the lower bound of the range of message boards categories to return 217 * @param end the upper bound of the range of message boards categories to return (not inclusive) 218 * @return the range of matching message boards categories 219 * @throws SystemException if a system exception occurred 220 */ 221 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 222 java.lang.String uuid, int start, int end) 223 throws com.liferay.portal.kernel.exception.SystemException { 224 return getPersistence().findByUuid(uuid, start, end); 225 } 226 227 /** 228 * Finds an ordered range of all the message boards categories where uuid = ?. 229 * 230 * <p> 231 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 232 * </p> 233 * 234 * @param uuid the uuid to search with 235 * @param start the lower bound of the range of message boards categories to return 236 * @param end the upper bound of the range of message boards categories to return (not inclusive) 237 * @param orderByComparator the comparator to order the results by 238 * @return the ordered range of matching message boards categories 239 * @throws SystemException if a system exception occurred 240 */ 241 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 242 java.lang.String uuid, int start, int end, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 246 } 247 248 /** 249 * Finds the first message boards category in the ordered set where uuid = ?. 250 * 251 * <p> 252 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 253 * </p> 254 * 255 * @param uuid the uuid to search with 256 * @param orderByComparator the comparator to order the set by 257 * @return the first matching message boards category 258 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 259 * @throws SystemException if a system exception occurred 260 */ 261 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_First( 262 java.lang.String uuid, 263 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 264 throws com.liferay.portal.kernel.exception.SystemException, 265 com.liferay.portlet.messageboards.NoSuchCategoryException { 266 return getPersistence().findByUuid_First(uuid, orderByComparator); 267 } 268 269 /** 270 * Finds the last message boards category in the ordered set where uuid = ?. 271 * 272 * <p> 273 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 274 * </p> 275 * 276 * @param uuid the uuid to search with 277 * @param orderByComparator the comparator to order the set by 278 * @return the last matching message boards category 279 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 280 * @throws SystemException if a system exception occurred 281 */ 282 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_Last( 283 java.lang.String uuid, 284 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 285 throws com.liferay.portal.kernel.exception.SystemException, 286 com.liferay.portlet.messageboards.NoSuchCategoryException { 287 return getPersistence().findByUuid_Last(uuid, orderByComparator); 288 } 289 290 /** 291 * Finds the message boards categories before and after the current message boards category in the ordered set where uuid = ?. 292 * 293 * <p> 294 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 295 * </p> 296 * 297 * @param categoryId the primary key of the current message boards category 298 * @param uuid the uuid to search with 299 * @param orderByComparator the comparator to order the set by 300 * @return the previous, current, and next message boards category 301 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 302 * @throws SystemException if a system exception occurred 303 */ 304 public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_PrevAndNext( 305 long categoryId, java.lang.String uuid, 306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 307 throws com.liferay.portal.kernel.exception.SystemException, 308 com.liferay.portlet.messageboards.NoSuchCategoryException { 309 return getPersistence() 310 .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator); 311 } 312 313 /** 314 * Finds the message boards category where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 315 * 316 * @param uuid the uuid to search with 317 * @param groupId the group id to search with 318 * @return the matching message boards category 319 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 320 * @throws SystemException if a system exception occurred 321 */ 322 public static com.liferay.portlet.messageboards.model.MBCategory findByUUID_G( 323 java.lang.String uuid, long groupId) 324 throws com.liferay.portal.kernel.exception.SystemException, 325 com.liferay.portlet.messageboards.NoSuchCategoryException { 326 return getPersistence().findByUUID_G(uuid, groupId); 327 } 328 329 /** 330 * Finds the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 331 * 332 * @param uuid the uuid to search with 333 * @param groupId the group id to search with 334 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 335 * @throws SystemException if a system exception occurred 336 */ 337 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 338 java.lang.String uuid, long groupId) 339 throws com.liferay.portal.kernel.exception.SystemException { 340 return getPersistence().fetchByUUID_G(uuid, groupId); 341 } 342 343 /** 344 * Finds the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 345 * 346 * @param uuid the uuid to search with 347 * @param groupId the group id to search with 348 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 349 * @throws SystemException if a system exception occurred 350 */ 351 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 352 java.lang.String uuid, long groupId, boolean retrieveFromCache) 353 throws com.liferay.portal.kernel.exception.SystemException { 354 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 355 } 356 357 /** 358 * Finds all the message boards categories where groupId = ?. 359 * 360 * @param groupId the group id to search with 361 * @return the matching message boards categories 362 * @throws SystemException if a system exception occurred 363 */ 364 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 365 long groupId) 366 throws com.liferay.portal.kernel.exception.SystemException { 367 return getPersistence().findByGroupId(groupId); 368 } 369 370 /** 371 * Finds a range of all the message boards categories where groupId = ?. 372 * 373 * <p> 374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 375 * </p> 376 * 377 * @param groupId the group id to search with 378 * @param start the lower bound of the range of message boards categories to return 379 * @param end the upper bound of the range of message boards categories to return (not inclusive) 380 * @return the range of matching message boards categories 381 * @throws SystemException if a system exception occurred 382 */ 383 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 384 long groupId, int start, int end) 385 throws com.liferay.portal.kernel.exception.SystemException { 386 return getPersistence().findByGroupId(groupId, start, end); 387 } 388 389 /** 390 * Finds an ordered range of all the message boards categories where groupId = ?. 391 * 392 * <p> 393 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 394 * </p> 395 * 396 * @param groupId the group id to search with 397 * @param start the lower bound of the range of message boards categories to return 398 * @param end the upper bound of the range of message boards categories to return (not inclusive) 399 * @param orderByComparator the comparator to order the results by 400 * @return the ordered range of matching message boards categories 401 * @throws SystemException if a system exception occurred 402 */ 403 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 404 long groupId, int start, int end, 405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 406 throws com.liferay.portal.kernel.exception.SystemException { 407 return getPersistence() 408 .findByGroupId(groupId, start, end, orderByComparator); 409 } 410 411 /** 412 * Finds the first message boards category in the ordered set where groupId = ?. 413 * 414 * <p> 415 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 416 * </p> 417 * 418 * @param groupId the group id to search with 419 * @param orderByComparator the comparator to order the set by 420 * @return the first matching message boards category 421 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 422 * @throws SystemException if a system exception occurred 423 */ 424 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_First( 425 long groupId, 426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 427 throws com.liferay.portal.kernel.exception.SystemException, 428 com.liferay.portlet.messageboards.NoSuchCategoryException { 429 return getPersistence().findByGroupId_First(groupId, orderByComparator); 430 } 431 432 /** 433 * Finds the last message boards category in the ordered set where groupId = ?. 434 * 435 * <p> 436 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 437 * </p> 438 * 439 * @param groupId the group id to search with 440 * @param orderByComparator the comparator to order the set by 441 * @return the last matching message boards category 442 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 443 * @throws SystemException if a system exception occurred 444 */ 445 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_Last( 446 long groupId, 447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 448 throws com.liferay.portal.kernel.exception.SystemException, 449 com.liferay.portlet.messageboards.NoSuchCategoryException { 450 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 451 } 452 453 /** 454 * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = ?. 455 * 456 * <p> 457 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 458 * </p> 459 * 460 * @param categoryId the primary key of the current message boards category 461 * @param groupId the group id to search with 462 * @param orderByComparator the comparator to order the set by 463 * @return the previous, current, and next message boards category 464 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.messageboards.model.MBCategory[] findByGroupId_PrevAndNext( 468 long categoryId, long groupId, 469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 470 throws com.liferay.portal.kernel.exception.SystemException, 471 com.liferay.portlet.messageboards.NoSuchCategoryException { 472 return getPersistence() 473 .findByGroupId_PrevAndNext(categoryId, groupId, 474 orderByComparator); 475 } 476 477 /** 478 * Filters by the user's permissions and finds all the message boards categories where groupId = ?. 479 * 480 * @param groupId the group id to search with 481 * @return the matching message boards categories that the user has permission to view 482 * @throws SystemException if a system exception occurred 483 */ 484 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 485 long groupId) 486 throws com.liferay.portal.kernel.exception.SystemException { 487 return getPersistence().filterFindByGroupId(groupId); 488 } 489 490 /** 491 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ?. 492 * 493 * <p> 494 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 495 * </p> 496 * 497 * @param groupId the group id to search with 498 * @param start the lower bound of the range of message boards categories to return 499 * @param end the upper bound of the range of message boards categories to return (not inclusive) 500 * @return the range of matching message boards categories that the user has permission to view 501 * @throws SystemException if a system exception occurred 502 */ 503 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 504 long groupId, int start, int end) 505 throws com.liferay.portal.kernel.exception.SystemException { 506 return getPersistence().filterFindByGroupId(groupId, start, end); 507 } 508 509 /** 510 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ?. 511 * 512 * <p> 513 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 514 * </p> 515 * 516 * @param groupId the group id to search with 517 * @param start the lower bound of the range of message boards categories to return 518 * @param end the upper bound of the range of message boards categories to return (not inclusive) 519 * @param orderByComparator the comparator to order the results by 520 * @return the ordered range of matching message boards categories that the user has permission to view 521 * @throws SystemException if a system exception occurred 522 */ 523 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 524 long groupId, int start, int end, 525 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence() 528 .filterFindByGroupId(groupId, start, end, orderByComparator); 529 } 530 531 /** 532 * Finds all the message boards categories where companyId = ?. 533 * 534 * @param companyId the company id to search with 535 * @return the matching message boards categories 536 * @throws SystemException if a system exception occurred 537 */ 538 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 539 long companyId) 540 throws com.liferay.portal.kernel.exception.SystemException { 541 return getPersistence().findByCompanyId(companyId); 542 } 543 544 /** 545 * Finds a range of all the message boards categories where companyId = ?. 546 * 547 * <p> 548 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 549 * </p> 550 * 551 * @param companyId the company id to search with 552 * @param start the lower bound of the range of message boards categories to return 553 * @param end the upper bound of the range of message boards categories to return (not inclusive) 554 * @return the range of matching message boards categories 555 * @throws SystemException if a system exception occurred 556 */ 557 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 558 long companyId, int start, int end) 559 throws com.liferay.portal.kernel.exception.SystemException { 560 return getPersistence().findByCompanyId(companyId, start, end); 561 } 562 563 /** 564 * Finds an ordered range of all the message boards categories where companyId = ?. 565 * 566 * <p> 567 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 568 * </p> 569 * 570 * @param companyId the company id to search with 571 * @param start the lower bound of the range of message boards categories to return 572 * @param end the upper bound of the range of message boards categories to return (not inclusive) 573 * @param orderByComparator the comparator to order the results by 574 * @return the ordered range of matching message boards categories 575 * @throws SystemException if a system exception occurred 576 */ 577 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 578 long companyId, int start, int end, 579 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 580 throws com.liferay.portal.kernel.exception.SystemException { 581 return getPersistence() 582 .findByCompanyId(companyId, start, end, orderByComparator); 583 } 584 585 /** 586 * Finds the first message boards category in the ordered set where companyId = ?. 587 * 588 * <p> 589 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 590 * </p> 591 * 592 * @param companyId the company id to search with 593 * @param orderByComparator the comparator to order the set by 594 * @return the first matching message boards category 595 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 596 * @throws SystemException if a system exception occurred 597 */ 598 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First( 599 long companyId, 600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 601 throws com.liferay.portal.kernel.exception.SystemException, 602 com.liferay.portlet.messageboards.NoSuchCategoryException { 603 return getPersistence() 604 .findByCompanyId_First(companyId, orderByComparator); 605 } 606 607 /** 608 * Finds the last message boards category in the ordered set where companyId = ?. 609 * 610 * <p> 611 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 612 * </p> 613 * 614 * @param companyId the company id to search with 615 * @param orderByComparator the comparator to order the set by 616 * @return the last matching message boards category 617 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 618 * @throws SystemException if a system exception occurred 619 */ 620 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last( 621 long companyId, 622 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 623 throws com.liferay.portal.kernel.exception.SystemException, 624 com.liferay.portlet.messageboards.NoSuchCategoryException { 625 return getPersistence() 626 .findByCompanyId_Last(companyId, orderByComparator); 627 } 628 629 /** 630 * Finds the message boards categories before and after the current message boards category in the ordered set where companyId = ?. 631 * 632 * <p> 633 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 634 * </p> 635 * 636 * @param categoryId the primary key of the current message boards category 637 * @param companyId the company id to search with 638 * @param orderByComparator the comparator to order the set by 639 * @return the previous, current, and next message boards category 640 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 641 * @throws SystemException if a system exception occurred 642 */ 643 public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext( 644 long categoryId, long companyId, 645 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 646 throws com.liferay.portal.kernel.exception.SystemException, 647 com.liferay.portlet.messageboards.NoSuchCategoryException { 648 return getPersistence() 649 .findByCompanyId_PrevAndNext(categoryId, companyId, 650 orderByComparator); 651 } 652 653 /** 654 * Finds all the message boards categories where groupId = ? and parentCategoryId = ?. 655 * 656 * @param groupId the group id to search with 657 * @param parentCategoryId the parent category id to search with 658 * @return the matching message boards categories 659 * @throws SystemException if a system exception occurred 660 */ 661 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 662 long groupId, long parentCategoryId) 663 throws com.liferay.portal.kernel.exception.SystemException { 664 return getPersistence().findByG_P(groupId, parentCategoryId); 665 } 666 667 /** 668 * Finds a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 669 * 670 * <p> 671 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 672 * </p> 673 * 674 * @param groupId the group id to search with 675 * @param parentCategoryId the parent category id to search with 676 * @param start the lower bound of the range of message boards categories to return 677 * @param end the upper bound of the range of message boards categories to return (not inclusive) 678 * @return the range of matching message boards categories 679 * @throws SystemException if a system exception occurred 680 */ 681 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 682 long groupId, long parentCategoryId, int start, int end) 683 throws com.liferay.portal.kernel.exception.SystemException { 684 return getPersistence().findByG_P(groupId, parentCategoryId, start, end); 685 } 686 687 /** 688 * Finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 689 * 690 * <p> 691 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 692 * </p> 693 * 694 * @param groupId the group id to search with 695 * @param parentCategoryId the parent category id to search with 696 * @param start the lower bound of the range of message boards categories to return 697 * @param end the upper bound of the range of message boards categories to return (not inclusive) 698 * @param orderByComparator the comparator to order the results by 699 * @return the ordered range of matching message boards categories 700 * @throws SystemException if a system exception occurred 701 */ 702 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 703 long groupId, long parentCategoryId, int start, int end, 704 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 705 throws com.liferay.portal.kernel.exception.SystemException { 706 return getPersistence() 707 .findByG_P(groupId, parentCategoryId, start, end, 708 orderByComparator); 709 } 710 711 /** 712 * Finds the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 713 * 714 * <p> 715 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 716 * </p> 717 * 718 * @param groupId the group id to search with 719 * @param parentCategoryId the parent category id to search with 720 * @param orderByComparator the comparator to order the set by 721 * @return the first matching message boards category 722 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 723 * @throws SystemException if a system exception occurred 724 */ 725 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First( 726 long groupId, long parentCategoryId, 727 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 728 throws com.liferay.portal.kernel.exception.SystemException, 729 com.liferay.portlet.messageboards.NoSuchCategoryException { 730 return getPersistence() 731 .findByG_P_First(groupId, parentCategoryId, orderByComparator); 732 } 733 734 /** 735 * Finds the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 736 * 737 * <p> 738 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 739 * </p> 740 * 741 * @param groupId the group id to search with 742 * @param parentCategoryId the parent category id to search with 743 * @param orderByComparator the comparator to order the set by 744 * @return the last matching message boards category 745 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 746 * @throws SystemException if a system exception occurred 747 */ 748 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last( 749 long groupId, long parentCategoryId, 750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 751 throws com.liferay.portal.kernel.exception.SystemException, 752 com.liferay.portlet.messageboards.NoSuchCategoryException { 753 return getPersistence() 754 .findByG_P_Last(groupId, parentCategoryId, orderByComparator); 755 } 756 757 /** 758 * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 759 * 760 * <p> 761 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 762 * </p> 763 * 764 * @param categoryId the primary key of the current message boards category 765 * @param groupId the group id to search with 766 * @param parentCategoryId the parent category id to search with 767 * @param orderByComparator the comparator to order the set by 768 * @return the previous, current, and next message boards category 769 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 770 * @throws SystemException if a system exception occurred 771 */ 772 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext( 773 long categoryId, long groupId, long parentCategoryId, 774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 775 throws com.liferay.portal.kernel.exception.SystemException, 776 com.liferay.portlet.messageboards.NoSuchCategoryException { 777 return getPersistence() 778 .findByG_P_PrevAndNext(categoryId, groupId, 779 parentCategoryId, orderByComparator); 780 } 781 782 /** 783 * Finds all the message boards categories where groupId = ? and parentCategoryId = any ?. 784 * 785 * <p> 786 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 787 * </p> 788 * 789 * @param groupId the group id to search with 790 * @param parentCategoryIds the parent category ids to search with 791 * @return the matching message boards categories 792 * @throws SystemException if a system exception occurred 793 */ 794 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 795 long groupId, long[] parentCategoryIds) 796 throws com.liferay.portal.kernel.exception.SystemException { 797 return getPersistence().findByG_P(groupId, parentCategoryIds); 798 } 799 800 /** 801 * Finds a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 802 * 803 * <p> 804 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 805 * </p> 806 * 807 * @param groupId the group id to search with 808 * @param parentCategoryIds the parent category ids to search with 809 * @param start the lower bound of the range of message boards categories to return 810 * @param end the upper bound of the range of message boards categories to return (not inclusive) 811 * @return the range of matching message boards categories 812 * @throws SystemException if a system exception occurred 813 */ 814 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 815 long groupId, long[] parentCategoryIds, int start, int end) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence().findByG_P(groupId, parentCategoryIds, start, end); 818 } 819 820 /** 821 * Finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 822 * 823 * <p> 824 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 825 * </p> 826 * 827 * @param groupId the group id to search with 828 * @param parentCategoryIds the parent category ids to search with 829 * @param start the lower bound of the range of message boards categories to return 830 * @param end the upper bound of the range of message boards categories to return (not inclusive) 831 * @param orderByComparator the comparator to order the results by 832 * @return the ordered range of matching message boards categories 833 * @throws SystemException if a system exception occurred 834 */ 835 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 836 long groupId, long[] parentCategoryIds, int start, int end, 837 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence() 840 .findByG_P(groupId, parentCategoryIds, start, end, 841 orderByComparator); 842 } 843 844 /** 845 * Filters by the user's permissions and finds all the message boards categories where groupId = ? and parentCategoryId = ?. 846 * 847 * @param groupId the group id to search with 848 * @param parentCategoryId the parent category id to search with 849 * @return the matching message boards categories that the user has permission to view 850 * @throws SystemException if a system exception occurred 851 */ 852 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 853 long groupId, long parentCategoryId) 854 throws com.liferay.portal.kernel.exception.SystemException { 855 return getPersistence().filterFindByG_P(groupId, parentCategoryId); 856 } 857 858 /** 859 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 860 * 861 * <p> 862 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 863 * </p> 864 * 865 * @param groupId the group id to search with 866 * @param parentCategoryId the parent category id to search with 867 * @param start the lower bound of the range of message boards categories to return 868 * @param end the upper bound of the range of message boards categories to return (not inclusive) 869 * @return the range of matching message boards categories that the user has permission to view 870 * @throws SystemException if a system exception occurred 871 */ 872 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 873 long groupId, long parentCategoryId, int start, int end) 874 throws com.liferay.portal.kernel.exception.SystemException { 875 return getPersistence() 876 .filterFindByG_P(groupId, parentCategoryId, start, end); 877 } 878 879 /** 880 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 881 * 882 * <p> 883 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 884 * </p> 885 * 886 * @param groupId the group id to search with 887 * @param parentCategoryId the parent category id to search with 888 * @param start the lower bound of the range of message boards categories to return 889 * @param end the upper bound of the range of message boards categories to return (not inclusive) 890 * @param orderByComparator the comparator to order the results by 891 * @return the ordered range of matching message boards categories that the user has permission to view 892 * @throws SystemException if a system exception occurred 893 */ 894 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 895 long groupId, long parentCategoryId, int start, int end, 896 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 897 throws com.liferay.portal.kernel.exception.SystemException { 898 return getPersistence() 899 .filterFindByG_P(groupId, parentCategoryId, start, end, 900 orderByComparator); 901 } 902 903 /** 904 * Filters by the user's permissions and finds all the message boards categories where groupId = ? and parentCategoryId = any ?. 905 * 906 * <p> 907 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 908 * </p> 909 * 910 * @param groupId the group id to search with 911 * @param parentCategoryIds the parent category ids to search with 912 * @return the matching message boards categories that the user has permission to view 913 * @throws SystemException if a system exception occurred 914 */ 915 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 916 long groupId, long[] parentCategoryIds) 917 throws com.liferay.portal.kernel.exception.SystemException { 918 return getPersistence().filterFindByG_P(groupId, parentCategoryIds); 919 } 920 921 /** 922 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 923 * 924 * <p> 925 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 926 * </p> 927 * 928 * @param groupId the group id to search with 929 * @param parentCategoryIds the parent category ids to search with 930 * @param start the lower bound of the range of message boards categories to return 931 * @param end the upper bound of the range of message boards categories to return (not inclusive) 932 * @return the range of matching message boards categories that the user has permission to view 933 * @throws SystemException if a system exception occurred 934 */ 935 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 936 long groupId, long[] parentCategoryIds, int start, int end) 937 throws com.liferay.portal.kernel.exception.SystemException { 938 return getPersistence() 939 .filterFindByG_P(groupId, parentCategoryIds, start, end); 940 } 941 942 /** 943 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 947 * </p> 948 * 949 * @param groupId the group id to search with 950 * @param parentCategoryIds the parent category ids to search with 951 * @param start the lower bound of the range of message boards categories to return 952 * @param end the upper bound of the range of message boards categories to return (not inclusive) 953 * @param orderByComparator the comparator to order the results by 954 * @return the ordered range of matching message boards categories that the user has permission to view 955 * @throws SystemException if a system exception occurred 956 */ 957 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 958 long groupId, long[] parentCategoryIds, int start, int end, 959 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 960 throws com.liferay.portal.kernel.exception.SystemException { 961 return getPersistence() 962 .filterFindByG_P(groupId, parentCategoryIds, start, end, 963 orderByComparator); 964 } 965 966 /** 967 * Finds all the message boards categories. 968 * 969 * @return the message boards categories 970 * @throws SystemException if a system exception occurred 971 */ 972 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll() 973 throws com.liferay.portal.kernel.exception.SystemException { 974 return getPersistence().findAll(); 975 } 976 977 /** 978 * Finds a range of all the message boards categories. 979 * 980 * <p> 981 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 982 * </p> 983 * 984 * @param start the lower bound of the range of message boards categories to return 985 * @param end the upper bound of the range of message boards categories to return (not inclusive) 986 * @return the range of message boards categories 987 * @throws SystemException if a system exception occurred 988 */ 989 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 990 int start, int end) 991 throws com.liferay.portal.kernel.exception.SystemException { 992 return getPersistence().findAll(start, end); 993 } 994 995 /** 996 * Finds an ordered range of all the message boards categories. 997 * 998 * <p> 999 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1000 * </p> 1001 * 1002 * @param start the lower bound of the range of message boards categories to return 1003 * @param end the upper bound of the range of message boards categories to return (not inclusive) 1004 * @param orderByComparator the comparator to order the results by 1005 * @return the ordered range of message boards categories 1006 * @throws SystemException if a system exception occurred 1007 */ 1008 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 1009 int start, int end, 1010 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1011 throws com.liferay.portal.kernel.exception.SystemException { 1012 return getPersistence().findAll(start, end, orderByComparator); 1013 } 1014 1015 /** 1016 * Removes all the message boards categories where uuid = ? from the database. 1017 * 1018 * @param uuid the uuid to search with 1019 * @throws SystemException if a system exception occurred 1020 */ 1021 public static void removeByUuid(java.lang.String uuid) 1022 throws com.liferay.portal.kernel.exception.SystemException { 1023 getPersistence().removeByUuid(uuid); 1024 } 1025 1026 /** 1027 * Removes the message boards category where uuid = ? and groupId = ? from the database. 1028 * 1029 * @param uuid the uuid to search with 1030 * @param groupId the group id to search with 1031 * @throws SystemException if a system exception occurred 1032 */ 1033 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1034 throws com.liferay.portal.kernel.exception.SystemException, 1035 com.liferay.portlet.messageboards.NoSuchCategoryException { 1036 getPersistence().removeByUUID_G(uuid, groupId); 1037 } 1038 1039 /** 1040 * Removes all the message boards categories where groupId = ? from the database. 1041 * 1042 * @param groupId the group id to search with 1043 * @throws SystemException if a system exception occurred 1044 */ 1045 public static void removeByGroupId(long groupId) 1046 throws com.liferay.portal.kernel.exception.SystemException { 1047 getPersistence().removeByGroupId(groupId); 1048 } 1049 1050 /** 1051 * Removes all the message boards categories where companyId = ? from the database. 1052 * 1053 * @param companyId the company id to search with 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static void removeByCompanyId(long companyId) 1057 throws com.liferay.portal.kernel.exception.SystemException { 1058 getPersistence().removeByCompanyId(companyId); 1059 } 1060 1061 /** 1062 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? from the database. 1063 * 1064 * @param groupId the group id to search with 1065 * @param parentCategoryId the parent category id to search with 1066 * @throws SystemException if a system exception occurred 1067 */ 1068 public static void removeByG_P(long groupId, long parentCategoryId) 1069 throws com.liferay.portal.kernel.exception.SystemException { 1070 getPersistence().removeByG_P(groupId, parentCategoryId); 1071 } 1072 1073 /** 1074 * Removes all the message boards categories from the database. 1075 * 1076 * @throws SystemException if a system exception occurred 1077 */ 1078 public static void removeAll() 1079 throws com.liferay.portal.kernel.exception.SystemException { 1080 getPersistence().removeAll(); 1081 } 1082 1083 /** 1084 * Counts all the message boards categories where uuid = ?. 1085 * 1086 * @param uuid the uuid to search with 1087 * @return the number of matching message boards categories 1088 * @throws SystemException if a system exception occurred 1089 */ 1090 public static int countByUuid(java.lang.String uuid) 1091 throws com.liferay.portal.kernel.exception.SystemException { 1092 return getPersistence().countByUuid(uuid); 1093 } 1094 1095 /** 1096 * Counts all the message boards categories where uuid = ? and groupId = ?. 1097 * 1098 * @param uuid the uuid to search with 1099 * @param groupId the group id to search with 1100 * @return the number of matching message boards categories 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static int countByUUID_G(java.lang.String uuid, long groupId) 1104 throws com.liferay.portal.kernel.exception.SystemException { 1105 return getPersistence().countByUUID_G(uuid, groupId); 1106 } 1107 1108 /** 1109 * Counts all the message boards categories where groupId = ?. 1110 * 1111 * @param groupId the group id to search with 1112 * @return the number of matching message boards categories 1113 * @throws SystemException if a system exception occurred 1114 */ 1115 public static int countByGroupId(long groupId) 1116 throws com.liferay.portal.kernel.exception.SystemException { 1117 return getPersistence().countByGroupId(groupId); 1118 } 1119 1120 /** 1121 * Filters by the user's permissions and counts all the message boards categories where groupId = ?. 1122 * 1123 * @param groupId the group id to search with 1124 * @return the number of matching message boards categories that the user has permission to view 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static int filterCountByGroupId(long groupId) 1128 throws com.liferay.portal.kernel.exception.SystemException { 1129 return getPersistence().filterCountByGroupId(groupId); 1130 } 1131 1132 /** 1133 * Counts all the message boards categories where companyId = ?. 1134 * 1135 * @param companyId the company id to search with 1136 * @return the number of matching message boards categories 1137 * @throws SystemException if a system exception occurred 1138 */ 1139 public static int countByCompanyId(long companyId) 1140 throws com.liferay.portal.kernel.exception.SystemException { 1141 return getPersistence().countByCompanyId(companyId); 1142 } 1143 1144 /** 1145 * Counts all the message boards categories where groupId = ? and parentCategoryId = ?. 1146 * 1147 * @param groupId the group id to search with 1148 * @param parentCategoryId the parent category id to search with 1149 * @return the number of matching message boards categories 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public static int countByG_P(long groupId, long parentCategoryId) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence().countByG_P(groupId, parentCategoryId); 1155 } 1156 1157 /** 1158 * Counts all the message boards categories where groupId = ? and parentCategoryId = any ?. 1159 * 1160 * @param groupId the group id to search with 1161 * @param parentCategoryIds the parent category ids to search with 1162 * @return the number of matching message boards categories 1163 * @throws SystemException if a system exception occurred 1164 */ 1165 public static int countByG_P(long groupId, long[] parentCategoryIds) 1166 throws com.liferay.portal.kernel.exception.SystemException { 1167 return getPersistence().countByG_P(groupId, parentCategoryIds); 1168 } 1169 1170 /** 1171 * Filters by the user's permissions and counts all the message boards categories where groupId = ? and parentCategoryId = ?. 1172 * 1173 * @param groupId the group id to search with 1174 * @param parentCategoryId the parent category id to search with 1175 * @return the number of matching message boards categories that the user has permission to view 1176 * @throws SystemException if a system exception occurred 1177 */ 1178 public static int filterCountByG_P(long groupId, long parentCategoryId) 1179 throws com.liferay.portal.kernel.exception.SystemException { 1180 return getPersistence().filterCountByG_P(groupId, parentCategoryId); 1181 } 1182 1183 /** 1184 * Filters by the user's permissions and counts all the message boards categories where groupId = ? and parentCategoryId = any ?. 1185 * 1186 * @param groupId the group id to search with 1187 * @param parentCategoryIds the parent category ids to search with 1188 * @return the number of matching message boards categories that the user has permission to view 1189 * @throws SystemException if a system exception occurred 1190 */ 1191 public static int filterCountByG_P(long groupId, long[] parentCategoryIds) 1192 throws com.liferay.portal.kernel.exception.SystemException { 1193 return getPersistence().filterCountByG_P(groupId, parentCategoryIds); 1194 } 1195 1196 /** 1197 * Counts all the message boards categories. 1198 * 1199 * @return the number of message boards categories 1200 * @throws SystemException if a system exception occurred 1201 */ 1202 public static int countAll() 1203 throws com.liferay.portal.kernel.exception.SystemException { 1204 return getPersistence().countAll(); 1205 } 1206 1207 public static MBCategoryPersistence getPersistence() { 1208 if (_persistence == null) { 1209 _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName()); 1210 } 1211 1212 return _persistence; 1213 } 1214 1215 public void setPersistence(MBCategoryPersistence persistence) { 1216 _persistence = persistence; 1217 } 1218 1219 private static MBCategoryPersistence _persistence; 1220 }