001 /** 002 * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.messageboards.model.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#update(com.liferay.portal.model.BaseModel, boolean) 099 */ 100 public static MBCategory update(MBCategory mbCategory, boolean merge) 101 throws SystemException { 102 return getPersistence().update(mbCategory, merge); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 107 */ 108 public static MBCategory update(MBCategory mbCategory, boolean merge, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(mbCategory, merge, serviceContext); 111 } 112 113 /** 114 * Caches the message boards category in the entity cache if it is enabled. 115 * 116 * @param mbCategory the message boards category 117 */ 118 public static void cacheResult( 119 com.liferay.portlet.messageboards.model.MBCategory mbCategory) { 120 getPersistence().cacheResult(mbCategory); 121 } 122 123 /** 124 * Caches the message boards categories in the entity cache if it is enabled. 125 * 126 * @param mbCategories the message boards categories 127 */ 128 public static void cacheResult( 129 java.util.List<com.liferay.portlet.messageboards.model.MBCategory> mbCategories) { 130 getPersistence().cacheResult(mbCategories); 131 } 132 133 /** 134 * Creates a new message boards category with the primary key. Does not add the message boards category to the database. 135 * 136 * @param categoryId the primary key for the new message boards category 137 * @return the new message boards category 138 */ 139 public static com.liferay.portlet.messageboards.model.MBCategory create( 140 long categoryId) { 141 return getPersistence().create(categoryId); 142 } 143 144 /** 145 * Removes the message boards category with the primary key from the database. Also notifies the appropriate model listeners. 146 * 147 * @param categoryId the primary key of the message boards category 148 * @return the message boards category that was removed 149 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 150 * @throws SystemException if a system exception occurred 151 */ 152 public static com.liferay.portlet.messageboards.model.MBCategory remove( 153 long categoryId) 154 throws com.liferay.portal.kernel.exception.SystemException, 155 com.liferay.portlet.messageboards.NoSuchCategoryException { 156 return getPersistence().remove(categoryId); 157 } 158 159 public static com.liferay.portlet.messageboards.model.MBCategory updateImpl( 160 com.liferay.portlet.messageboards.model.MBCategory mbCategory, 161 boolean merge) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().updateImpl(mbCategory, merge); 164 } 165 166 /** 167 * Returns the message boards category with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 168 * 169 * @param categoryId the primary key of the message boards category 170 * @return the message boards category 171 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portlet.messageboards.model.MBCategory findByPrimaryKey( 175 long categoryId) 176 throws com.liferay.portal.kernel.exception.SystemException, 177 com.liferay.portlet.messageboards.NoSuchCategoryException { 178 return getPersistence().findByPrimaryKey(categoryId); 179 } 180 181 /** 182 * Returns the message boards category with the primary key or returns <code>null</code> if it could not be found. 183 * 184 * @param categoryId the primary key of the message boards category 185 * @return the message boards category, or <code>null</code> if a message boards category with the primary key could not be found 186 * @throws SystemException if a system exception occurred 187 */ 188 public static com.liferay.portlet.messageboards.model.MBCategory fetchByPrimaryKey( 189 long categoryId) 190 throws com.liferay.portal.kernel.exception.SystemException { 191 return getPersistence().fetchByPrimaryKey(categoryId); 192 } 193 194 /** 195 * Returns all the message boards categories where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @return the matching message boards categories 199 * @throws SystemException if a system exception occurred 200 */ 201 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 202 java.lang.String uuid) 203 throws com.liferay.portal.kernel.exception.SystemException { 204 return getPersistence().findByUuid(uuid); 205 } 206 207 /** 208 * Returns a range of all the message boards categories where uuid = ?. 209 * 210 * <p> 211 * 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. 212 * </p> 213 * 214 * @param uuid the uuid 215 * @param start the lower bound of the range of message boards categories 216 * @param end the upper bound of the range of message boards categories (not inclusive) 217 * @return the range of matching message boards categories 218 * @throws SystemException if a system exception occurred 219 */ 220 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 221 java.lang.String uuid, int start, int end) 222 throws com.liferay.portal.kernel.exception.SystemException { 223 return getPersistence().findByUuid(uuid, start, end); 224 } 225 226 /** 227 * Returns an ordered range of all the message boards categories where uuid = ?. 228 * 229 * <p> 230 * 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. 231 * </p> 232 * 233 * @param uuid the uuid 234 * @param start the lower bound of the range of message boards categories 235 * @param end the upper bound of the range of message boards categories (not inclusive) 236 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 237 * @return the ordered range of matching message boards categories 238 * @throws SystemException if a system exception occurred 239 */ 240 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 241 java.lang.String uuid, int start, int end, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException { 244 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 245 } 246 247 /** 248 * Returns the first message boards category in the ordered set where uuid = ?. 249 * 250 * <p> 251 * 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. 252 * </p> 253 * 254 * @param uuid the uuid 255 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 256 * @return the first matching message boards category 257 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 258 * @throws SystemException if a system exception occurred 259 */ 260 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_First( 261 java.lang.String uuid, 262 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 263 throws com.liferay.portal.kernel.exception.SystemException, 264 com.liferay.portlet.messageboards.NoSuchCategoryException { 265 return getPersistence().findByUuid_First(uuid, orderByComparator); 266 } 267 268 /** 269 * Returns the last message boards category in the ordered set where uuid = ?. 270 * 271 * <p> 272 * 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. 273 * </p> 274 * 275 * @param uuid the uuid 276 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 277 * @return the last matching message boards category 278 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_Last( 282 java.lang.String uuid, 283 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 284 throws com.liferay.portal.kernel.exception.SystemException, 285 com.liferay.portlet.messageboards.NoSuchCategoryException { 286 return getPersistence().findByUuid_Last(uuid, orderByComparator); 287 } 288 289 /** 290 * Returns the message boards categories before and after the current message boards category in the ordered set where uuid = ?. 291 * 292 * <p> 293 * 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. 294 * </p> 295 * 296 * @param categoryId the primary key of the current message boards category 297 * @param uuid the uuid 298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 299 * @return the previous, current, and next message boards category 300 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 301 * @throws SystemException if a system exception occurred 302 */ 303 public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_PrevAndNext( 304 long categoryId, java.lang.String uuid, 305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 306 throws com.liferay.portal.kernel.exception.SystemException, 307 com.liferay.portlet.messageboards.NoSuchCategoryException { 308 return getPersistence() 309 .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator); 310 } 311 312 /** 313 * Returns the message boards category where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 314 * 315 * @param uuid the uuid 316 * @param groupId the group ID 317 * @return the matching message boards category 318 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 319 * @throws SystemException if a system exception occurred 320 */ 321 public static com.liferay.portlet.messageboards.model.MBCategory findByUUID_G( 322 java.lang.String uuid, long groupId) 323 throws com.liferay.portal.kernel.exception.SystemException, 324 com.liferay.portlet.messageboards.NoSuchCategoryException { 325 return getPersistence().findByUUID_G(uuid, groupId); 326 } 327 328 /** 329 * Returns the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 330 * 331 * @param uuid the uuid 332 * @param groupId the group ID 333 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 334 * @throws SystemException if a system exception occurred 335 */ 336 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 337 java.lang.String uuid, long groupId) 338 throws com.liferay.portal.kernel.exception.SystemException { 339 return getPersistence().fetchByUUID_G(uuid, groupId); 340 } 341 342 /** 343 * Returns the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 344 * 345 * @param uuid the uuid 346 * @param groupId the group ID 347 * @param retrieveFromCache whether to use the finder cache 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 * Returns all the message boards categories where groupId = ?. 359 * 360 * @param groupId the group ID 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 * Returns 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 378 * @param start the lower bound of the range of message boards categories 379 * @param end the upper bound of the range of message boards categories (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 * Returns 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 397 * @param start the lower bound of the range of message boards categories 398 * @param end the upper bound of the range of message boards categories (not inclusive) 399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns all the message boards categories that the user has permission to view where groupId = ?. 479 * 480 * @param groupId the group ID 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 * Returns a range of all the message boards categories that the user has permission to view 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 498 * @param start the lower bound of the range of message boards categories 499 * @param end the upper bound of the range of message boards categories (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 * Returns an ordered range of all the message boards categories that the user has permissions to view 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 517 * @param start the lower bound of the range of message boards categories 518 * @param end the upper bound of the range of message boards categories (not inclusive) 519 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ?. 533 * 534 * @param categoryId the primary key of the current message boards category 535 * @param groupId the group ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the previous, current, and next message boards category 538 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 539 * @throws SystemException if a system exception occurred 540 */ 541 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByGroupId_PrevAndNext( 542 long categoryId, long groupId, 543 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 544 throws com.liferay.portal.kernel.exception.SystemException, 545 com.liferay.portlet.messageboards.NoSuchCategoryException { 546 return getPersistence() 547 .filterFindByGroupId_PrevAndNext(categoryId, groupId, 548 orderByComparator); 549 } 550 551 /** 552 * Returns all the message boards categories where companyId = ?. 553 * 554 * @param companyId the company ID 555 * @return the matching message boards categories 556 * @throws SystemException if a system exception occurred 557 */ 558 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 559 long companyId) 560 throws com.liferay.portal.kernel.exception.SystemException { 561 return getPersistence().findByCompanyId(companyId); 562 } 563 564 /** 565 * Returns a range of all the message boards categories where companyId = ?. 566 * 567 * <p> 568 * 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. 569 * </p> 570 * 571 * @param companyId the company ID 572 * @param start the lower bound of the range of message boards categories 573 * @param end the upper bound of the range of message boards categories (not inclusive) 574 * @return the 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 throws com.liferay.portal.kernel.exception.SystemException { 580 return getPersistence().findByCompanyId(companyId, start, end); 581 } 582 583 /** 584 * Returns an ordered range of all the message boards categories where companyId = ?. 585 * 586 * <p> 587 * 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. 588 * </p> 589 * 590 * @param companyId the company ID 591 * @param start the lower bound of the range of message boards categories 592 * @param end the upper bound of the range of message boards categories (not inclusive) 593 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 594 * @return the ordered range of matching message boards categories 595 * @throws SystemException if a system exception occurred 596 */ 597 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 598 long companyId, int start, int end, 599 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 600 throws com.liferay.portal.kernel.exception.SystemException { 601 return getPersistence() 602 .findByCompanyId(companyId, start, end, orderByComparator); 603 } 604 605 /** 606 * Returns the first message boards category in the ordered set where companyId = ?. 607 * 608 * <p> 609 * 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. 610 * </p> 611 * 612 * @param companyId the company ID 613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 614 * @return the first matching message boards category 615 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 616 * @throws SystemException if a system exception occurred 617 */ 618 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First( 619 long companyId, 620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 621 throws com.liferay.portal.kernel.exception.SystemException, 622 com.liferay.portlet.messageboards.NoSuchCategoryException { 623 return getPersistence() 624 .findByCompanyId_First(companyId, orderByComparator); 625 } 626 627 /** 628 * Returns the last message boards category in the ordered set where companyId = ?. 629 * 630 * <p> 631 * 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. 632 * </p> 633 * 634 * @param companyId the company ID 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the last matching message boards category 637 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 638 * @throws SystemException if a system exception occurred 639 */ 640 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last( 641 long companyId, 642 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 643 throws com.liferay.portal.kernel.exception.SystemException, 644 com.liferay.portlet.messageboards.NoSuchCategoryException { 645 return getPersistence() 646 .findByCompanyId_Last(companyId, orderByComparator); 647 } 648 649 /** 650 * Returns the message boards categories before and after the current message boards category in the ordered set where companyId = ?. 651 * 652 * <p> 653 * 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. 654 * </p> 655 * 656 * @param categoryId the primary key of the current message boards category 657 * @param companyId the company ID 658 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 659 * @return the previous, current, and next message boards category 660 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 661 * @throws SystemException if a system exception occurred 662 */ 663 public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext( 664 long categoryId, long companyId, 665 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 666 throws com.liferay.portal.kernel.exception.SystemException, 667 com.liferay.portlet.messageboards.NoSuchCategoryException { 668 return getPersistence() 669 .findByCompanyId_PrevAndNext(categoryId, companyId, 670 orderByComparator); 671 } 672 673 /** 674 * Returns all the message boards categories where groupId = ? and parentCategoryId = ?. 675 * 676 * @param groupId the group ID 677 * @param parentCategoryId the parent category ID 678 * @return the 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) 683 throws com.liferay.portal.kernel.exception.SystemException { 684 return getPersistence().findByG_P(groupId, parentCategoryId); 685 } 686 687 /** 688 * Returns a 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 695 * @param parentCategoryId the parent category ID 696 * @param start the lower bound of the range of message boards categories 697 * @param end the upper bound of the range of message boards categories (not inclusive) 698 * @return the range of matching message boards categories 699 * @throws SystemException if a system exception occurred 700 */ 701 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 702 long groupId, long parentCategoryId, int start, int end) 703 throws com.liferay.portal.kernel.exception.SystemException { 704 return getPersistence().findByG_P(groupId, parentCategoryId, start, end); 705 } 706 707 /** 708 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 709 * 710 * <p> 711 * 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. 712 * </p> 713 * 714 * @param groupId the group ID 715 * @param parentCategoryId the parent category ID 716 * @param start the lower bound of the range of message boards categories 717 * @param end the upper bound of the range of message boards categories (not inclusive) 718 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 719 * @return the ordered range of matching message boards categories 720 * @throws SystemException if a system exception occurred 721 */ 722 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 723 long groupId, long parentCategoryId, int start, int end, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException { 726 return getPersistence() 727 .findByG_P(groupId, parentCategoryId, start, end, 728 orderByComparator); 729 } 730 731 /** 732 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 733 * 734 * <p> 735 * 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. 736 * </p> 737 * 738 * @param groupId the group ID 739 * @param parentCategoryId the parent category ID 740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 741 * @return the first matching message boards category 742 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 743 * @throws SystemException if a system exception occurred 744 */ 745 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First( 746 long groupId, long parentCategoryId, 747 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 748 throws com.liferay.portal.kernel.exception.SystemException, 749 com.liferay.portlet.messageboards.NoSuchCategoryException { 750 return getPersistence() 751 .findByG_P_First(groupId, parentCategoryId, orderByComparator); 752 } 753 754 /** 755 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 756 * 757 * <p> 758 * 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. 759 * </p> 760 * 761 * @param groupId the group ID 762 * @param parentCategoryId the parent category ID 763 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 764 * @return the last matching message boards category 765 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 766 * @throws SystemException if a system exception occurred 767 */ 768 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last( 769 long groupId, long parentCategoryId, 770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 771 throws com.liferay.portal.kernel.exception.SystemException, 772 com.liferay.portlet.messageboards.NoSuchCategoryException { 773 return getPersistence() 774 .findByG_P_Last(groupId, parentCategoryId, orderByComparator); 775 } 776 777 /** 778 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 779 * 780 * <p> 781 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 782 * </p> 783 * 784 * @param categoryId the primary key of the current message boards category 785 * @param groupId the group ID 786 * @param parentCategoryId the parent category ID 787 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 788 * @return the previous, current, and next message boards category 789 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 790 * @throws SystemException if a system exception occurred 791 */ 792 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext( 793 long categoryId, long groupId, long parentCategoryId, 794 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 795 throws com.liferay.portal.kernel.exception.SystemException, 796 com.liferay.portlet.messageboards.NoSuchCategoryException { 797 return getPersistence() 798 .findByG_P_PrevAndNext(categoryId, groupId, 799 parentCategoryId, orderByComparator); 800 } 801 802 /** 803 * Returns all the message boards categories where groupId = ? and parentCategoryId = any ?. 804 * 805 * <p> 806 * 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. 807 * </p> 808 * 809 * @param groupId the group ID 810 * @param parentCategoryIds the parent category IDs 811 * @return the 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) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence().findByG_P(groupId, parentCategoryIds); 818 } 819 820 /** 821 * Returns a 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 828 * @param parentCategoryIds the parent category IDs 829 * @param start the lower bound of the range of message boards categories 830 * @param end the upper bound of the range of message boards categories (not inclusive) 831 * @return the range of matching message boards categories 832 * @throws SystemException if a system exception occurred 833 */ 834 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 835 long groupId, long[] parentCategoryIds, int start, int end) 836 throws com.liferay.portal.kernel.exception.SystemException { 837 return getPersistence().findByG_P(groupId, parentCategoryIds, start, end); 838 } 839 840 /** 841 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 842 * 843 * <p> 844 * 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. 845 * </p> 846 * 847 * @param groupId the group ID 848 * @param parentCategoryIds the parent category IDs 849 * @param start the lower bound of the range of message boards categories 850 * @param end the upper bound of the range of message boards categories (not inclusive) 851 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 852 * @return the ordered range of matching message boards categories 853 * @throws SystemException if a system exception occurred 854 */ 855 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 856 long groupId, long[] parentCategoryIds, int start, int end, 857 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 858 throws com.liferay.portal.kernel.exception.SystemException { 859 return getPersistence() 860 .findByG_P(groupId, parentCategoryIds, start, end, 861 orderByComparator); 862 } 863 864 /** 865 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 866 * 867 * @param groupId the group ID 868 * @param parentCategoryId the parent category ID 869 * @return the 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) 874 throws com.liferay.portal.kernel.exception.SystemException { 875 return getPersistence().filterFindByG_P(groupId, parentCategoryId); 876 } 877 878 /** 879 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 880 * 881 * <p> 882 * 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. 883 * </p> 884 * 885 * @param groupId the group ID 886 * @param parentCategoryId the parent category ID 887 * @param start the lower bound of the range of message boards categories 888 * @param end the upper bound of the range of message boards categories (not inclusive) 889 * @return the range of matching message boards categories that the user has permission to view 890 * @throws SystemException if a system exception occurred 891 */ 892 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 893 long groupId, long parentCategoryId, int start, int end) 894 throws com.liferay.portal.kernel.exception.SystemException { 895 return getPersistence() 896 .filterFindByG_P(groupId, parentCategoryId, start, end); 897 } 898 899 /** 900 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ? and parentCategoryId = ?. 901 * 902 * <p> 903 * 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. 904 * </p> 905 * 906 * @param groupId the group ID 907 * @param parentCategoryId the parent category ID 908 * @param start the lower bound of the range of message boards categories 909 * @param end the upper bound of the range of message boards categories (not inclusive) 910 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 911 * @return the ordered range of matching message boards categories that the user has permission to view 912 * @throws SystemException if a system exception occurred 913 */ 914 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 915 long groupId, long parentCategoryId, int start, int end, 916 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 917 throws com.liferay.portal.kernel.exception.SystemException { 918 return getPersistence() 919 .filterFindByG_P(groupId, parentCategoryId, start, end, 920 orderByComparator); 921 } 922 923 /** 924 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 925 * 926 * @param categoryId the primary key of the current message boards category 927 * @param groupId the group ID 928 * @param parentCategoryId the parent category ID 929 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 930 * @return the previous, current, and next message boards category 931 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 932 * @throws SystemException if a system exception occurred 933 */ 934 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByG_P_PrevAndNext( 935 long categoryId, long groupId, long parentCategoryId, 936 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 937 throws com.liferay.portal.kernel.exception.SystemException, 938 com.liferay.portlet.messageboards.NoSuchCategoryException { 939 return getPersistence() 940 .filterFindByG_P_PrevAndNext(categoryId, groupId, 941 parentCategoryId, orderByComparator); 942 } 943 944 /** 945 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 946 * 947 * @param groupId the group ID 948 * @param parentCategoryIds the parent category IDs 949 * @return the matching message boards categories that the user has permission to view 950 * @throws SystemException if a system exception occurred 951 */ 952 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 953 long groupId, long[] parentCategoryIds) 954 throws com.liferay.portal.kernel.exception.SystemException { 955 return getPersistence().filterFindByG_P(groupId, parentCategoryIds); 956 } 957 958 /** 959 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 960 * 961 * <p> 962 * 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. 963 * </p> 964 * 965 * @param groupId the group ID 966 * @param parentCategoryIds the parent category IDs 967 * @param start the lower bound of the range of message boards categories 968 * @param end the upper bound of the range of message boards categories (not inclusive) 969 * @return the range of matching message boards categories that the user has permission to view 970 * @throws SystemException if a system exception occurred 971 */ 972 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 973 long groupId, long[] parentCategoryIds, int start, int end) 974 throws com.liferay.portal.kernel.exception.SystemException { 975 return getPersistence() 976 .filterFindByG_P(groupId, parentCategoryIds, start, end); 977 } 978 979 /** 980 * Returns an ordered range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 981 * 982 * <p> 983 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 984 * </p> 985 * 986 * @param groupId the group ID 987 * @param parentCategoryIds the parent category IDs 988 * @param start the lower bound of the range of message boards categories 989 * @param end the upper bound of the range of message boards categories (not inclusive) 990 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 991 * @return the ordered range of matching message boards categories that the user has permission to view 992 * @throws SystemException if a system exception occurred 993 */ 994 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 995 long groupId, long[] parentCategoryIds, int start, int end, 996 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 997 throws com.liferay.portal.kernel.exception.SystemException { 998 return getPersistence() 999 .filterFindByG_P(groupId, parentCategoryIds, start, end, 1000 orderByComparator); 1001 } 1002 1003 /** 1004 * Returns all the message boards categories. 1005 * 1006 * @return the message boards categories 1007 * @throws SystemException if a system exception occurred 1008 */ 1009 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll() 1010 throws com.liferay.portal.kernel.exception.SystemException { 1011 return getPersistence().findAll(); 1012 } 1013 1014 /** 1015 * Returns a range of all the message boards categories. 1016 * 1017 * <p> 1018 * 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. 1019 * </p> 1020 * 1021 * @param start the lower bound of the range of message boards categories 1022 * @param end the upper bound of the range of message boards categories (not inclusive) 1023 * @return the range of message boards categories 1024 * @throws SystemException if a system exception occurred 1025 */ 1026 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 1027 int start, int end) 1028 throws com.liferay.portal.kernel.exception.SystemException { 1029 return getPersistence().findAll(start, end); 1030 } 1031 1032 /** 1033 * Returns an ordered range of all the message boards categories. 1034 * 1035 * <p> 1036 * 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. 1037 * </p> 1038 * 1039 * @param start the lower bound of the range of message boards categories 1040 * @param end the upper bound of the range of message boards categories (not inclusive) 1041 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1042 * @return the ordered 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 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1048 throws com.liferay.portal.kernel.exception.SystemException { 1049 return getPersistence().findAll(start, end, orderByComparator); 1050 } 1051 1052 /** 1053 * Removes all the message boards categories where uuid = ? from the database. 1054 * 1055 * @param uuid the uuid 1056 * @throws SystemException if a system exception occurred 1057 */ 1058 public static void removeByUuid(java.lang.String uuid) 1059 throws com.liferay.portal.kernel.exception.SystemException { 1060 getPersistence().removeByUuid(uuid); 1061 } 1062 1063 /** 1064 * Removes the message boards category where uuid = ? and groupId = ? from the database. 1065 * 1066 * @param uuid the uuid 1067 * @param groupId the group ID 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1071 throws com.liferay.portal.kernel.exception.SystemException, 1072 com.liferay.portlet.messageboards.NoSuchCategoryException { 1073 getPersistence().removeByUUID_G(uuid, groupId); 1074 } 1075 1076 /** 1077 * Removes all the message boards categories where groupId = ? from the database. 1078 * 1079 * @param groupId the group ID 1080 * @throws SystemException if a system exception occurred 1081 */ 1082 public static void removeByGroupId(long groupId) 1083 throws com.liferay.portal.kernel.exception.SystemException { 1084 getPersistence().removeByGroupId(groupId); 1085 } 1086 1087 /** 1088 * Removes all the message boards categories where companyId = ? from the database. 1089 * 1090 * @param companyId the company ID 1091 * @throws SystemException if a system exception occurred 1092 */ 1093 public static void removeByCompanyId(long companyId) 1094 throws com.liferay.portal.kernel.exception.SystemException { 1095 getPersistence().removeByCompanyId(companyId); 1096 } 1097 1098 /** 1099 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? from the database. 1100 * 1101 * @param groupId the group ID 1102 * @param parentCategoryId the parent category ID 1103 * @throws SystemException if a system exception occurred 1104 */ 1105 public static void removeByG_P(long groupId, long parentCategoryId) 1106 throws com.liferay.portal.kernel.exception.SystemException { 1107 getPersistence().removeByG_P(groupId, parentCategoryId); 1108 } 1109 1110 /** 1111 * Removes all the message boards categories from the database. 1112 * 1113 * @throws SystemException if a system exception occurred 1114 */ 1115 public static void removeAll() 1116 throws com.liferay.portal.kernel.exception.SystemException { 1117 getPersistence().removeAll(); 1118 } 1119 1120 /** 1121 * Returns the number of message boards categories where uuid = ?. 1122 * 1123 * @param uuid the uuid 1124 * @return the number of matching message boards categories 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static int countByUuid(java.lang.String uuid) 1128 throws com.liferay.portal.kernel.exception.SystemException { 1129 return getPersistence().countByUuid(uuid); 1130 } 1131 1132 /** 1133 * Returns the number of message boards categories where uuid = ? and groupId = ?. 1134 * 1135 * @param uuid the uuid 1136 * @param groupId the group ID 1137 * @return the number of matching message boards categories 1138 * @throws SystemException if a system exception occurred 1139 */ 1140 public static int countByUUID_G(java.lang.String uuid, long groupId) 1141 throws com.liferay.portal.kernel.exception.SystemException { 1142 return getPersistence().countByUUID_G(uuid, groupId); 1143 } 1144 1145 /** 1146 * Returns the number of message boards categories where groupId = ?. 1147 * 1148 * @param groupId the group ID 1149 * @return the number of matching message boards categories 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public static int countByGroupId(long groupId) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence().countByGroupId(groupId); 1155 } 1156 1157 /** 1158 * Returns the number of message boards categories that the user has permission to view where groupId = ?. 1159 * 1160 * @param groupId the group ID 1161 * @return the number of matching message boards categories that the user has permission to view 1162 * @throws SystemException if a system exception occurred 1163 */ 1164 public static int filterCountByGroupId(long groupId) 1165 throws com.liferay.portal.kernel.exception.SystemException { 1166 return getPersistence().filterCountByGroupId(groupId); 1167 } 1168 1169 /** 1170 * Returns the number of message boards categories where companyId = ?. 1171 * 1172 * @param companyId the company ID 1173 * @return the number of matching message boards categories 1174 * @throws SystemException if a system exception occurred 1175 */ 1176 public static int countByCompanyId(long companyId) 1177 throws com.liferay.portal.kernel.exception.SystemException { 1178 return getPersistence().countByCompanyId(companyId); 1179 } 1180 1181 /** 1182 * Returns the number of message boards categories where groupId = ? and parentCategoryId = ?. 1183 * 1184 * @param groupId the group ID 1185 * @param parentCategoryId the parent category ID 1186 * @return the number of matching message boards categories 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public static int countByG_P(long groupId, long parentCategoryId) 1190 throws com.liferay.portal.kernel.exception.SystemException { 1191 return getPersistence().countByG_P(groupId, parentCategoryId); 1192 } 1193 1194 /** 1195 * Returns the number of message boards categories where groupId = ? and parentCategoryId = any ?. 1196 * 1197 * @param groupId the group ID 1198 * @param parentCategoryIds the parent category IDs 1199 * @return the number of matching message boards categories 1200 * @throws SystemException if a system exception occurred 1201 */ 1202 public static int countByG_P(long groupId, long[] parentCategoryIds) 1203 throws com.liferay.portal.kernel.exception.SystemException { 1204 return getPersistence().countByG_P(groupId, parentCategoryIds); 1205 } 1206 1207 /** 1208 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1209 * 1210 * @param groupId the group ID 1211 * @param parentCategoryId the parent category ID 1212 * @return the number of matching message boards categories that the user has permission to view 1213 * @throws SystemException if a system exception occurred 1214 */ 1215 public static int filterCountByG_P(long groupId, long parentCategoryId) 1216 throws com.liferay.portal.kernel.exception.SystemException { 1217 return getPersistence().filterCountByG_P(groupId, parentCategoryId); 1218 } 1219 1220 /** 1221 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1222 * 1223 * @param groupId the group ID 1224 * @param parentCategoryIds the parent category IDs 1225 * @return the number of matching message boards categories that the user has permission to view 1226 * @throws SystemException if a system exception occurred 1227 */ 1228 public static int filterCountByG_P(long groupId, long[] parentCategoryIds) 1229 throws com.liferay.portal.kernel.exception.SystemException { 1230 return getPersistence().filterCountByG_P(groupId, parentCategoryIds); 1231 } 1232 1233 /** 1234 * Returns the number of message boards categories. 1235 * 1236 * @return the number of message boards categories 1237 * @throws SystemException if a system exception occurred 1238 */ 1239 public static int countAll() 1240 throws com.liferay.portal.kernel.exception.SystemException { 1241 return getPersistence().countAll(); 1242 } 1243 1244 public static MBCategoryPersistence getPersistence() { 1245 if (_persistence == null) { 1246 _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName()); 1247 1248 ReferenceRegistry.registerReference(MBCategoryUtil.class, 1249 "_persistence"); 1250 } 1251 1252 return _persistence; 1253 } 1254 1255 public void setPersistence(MBCategoryPersistence persistence) { 1256 _persistence = persistence; 1257 1258 ReferenceRegistry.registerReference(MBCategoryUtil.class, "_persistence"); 1259 } 1260 1261 private static MBCategoryPersistence _persistence; 1262 }