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