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 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 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 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 * Returns 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 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 * Returns 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 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 * Returns all the message boards categories where uuid = ?. 204 * 205 * @param uuid the uuid 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 * Returns 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 223 * @param start the lower bound of the range of message boards categories 224 * @param end the upper bound of the range of message boards categories (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 * Returns 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 242 * @param start the lower bound of the range of message boards categories 243 * @param end the upper bound of the range of message boards categories (not inclusive) 244 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 263 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 306 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 324 * @param groupId the group ID 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 * Returns 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 340 * @param groupId the group ID 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 * 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. 352 * 353 * @param uuid the uuid 354 * @param groupId the group ID 355 * @param retrieveFromCache whether to use the finder cache 356 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 357 * @throws SystemException if a system exception occurred 358 */ 359 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 360 java.lang.String uuid, long groupId, boolean retrieveFromCache) 361 throws com.liferay.portal.kernel.exception.SystemException { 362 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 363 } 364 365 /** 366 * Returns all the message boards categories where groupId = ?. 367 * 368 * @param groupId the group ID 369 * @return the matching message boards categories 370 * @throws SystemException if a system exception occurred 371 */ 372 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 373 long groupId) 374 throws com.liferay.portal.kernel.exception.SystemException { 375 return getPersistence().findByGroupId(groupId); 376 } 377 378 /** 379 * Returns a range of all the message boards categories where groupId = ?. 380 * 381 * <p> 382 * 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. 383 * </p> 384 * 385 * @param groupId the group ID 386 * @param start the lower bound of the range of message boards categories 387 * @param end the upper bound of the range of message boards categories (not inclusive) 388 * @return the range of matching message boards categories 389 * @throws SystemException if a system exception occurred 390 */ 391 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 392 long groupId, int start, int end) 393 throws com.liferay.portal.kernel.exception.SystemException { 394 return getPersistence().findByGroupId(groupId, start, end); 395 } 396 397 /** 398 * Returns an ordered range of all the message boards categories where groupId = ?. 399 * 400 * <p> 401 * 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. 402 * </p> 403 * 404 * @param groupId the group ID 405 * @param start the lower bound of the range of message boards categories 406 * @param end the upper bound of the range of message boards categories (not inclusive) 407 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 408 * @return the ordered range of matching message boards categories 409 * @throws SystemException if a system exception occurred 410 */ 411 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 412 long groupId, int start, int end, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException { 415 return getPersistence() 416 .findByGroupId(groupId, start, end, orderByComparator); 417 } 418 419 /** 420 * Returns the first message boards category in the ordered set where groupId = ?. 421 * 422 * <p> 423 * 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. 424 * </p> 425 * 426 * @param groupId the group ID 427 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 428 * @return the first matching message boards category 429 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 430 * @throws SystemException if a system exception occurred 431 */ 432 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_First( 433 long groupId, 434 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 435 throws com.liferay.portal.kernel.exception.SystemException, 436 com.liferay.portlet.messageboards.NoSuchCategoryException { 437 return getPersistence().findByGroupId_First(groupId, orderByComparator); 438 } 439 440 /** 441 * Returns the last message boards category in the ordered set where groupId = ?. 442 * 443 * <p> 444 * 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. 445 * </p> 446 * 447 * @param groupId the group ID 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the last matching message boards category 450 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 451 * @throws SystemException if a system exception occurred 452 */ 453 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_Last( 454 long groupId, 455 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 456 throws com.liferay.portal.kernel.exception.SystemException, 457 com.liferay.portlet.messageboards.NoSuchCategoryException { 458 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 459 } 460 461 /** 462 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ?. 463 * 464 * <p> 465 * 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. 466 * </p> 467 * 468 * @param categoryId the primary key of the current message boards category 469 * @param groupId the group ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the previous, current, and next message boards category 472 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 473 * @throws SystemException if a system exception occurred 474 */ 475 public static com.liferay.portlet.messageboards.model.MBCategory[] findByGroupId_PrevAndNext( 476 long categoryId, long groupId, 477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 478 throws com.liferay.portal.kernel.exception.SystemException, 479 com.liferay.portlet.messageboards.NoSuchCategoryException { 480 return getPersistence() 481 .findByGroupId_PrevAndNext(categoryId, groupId, 482 orderByComparator); 483 } 484 485 /** 486 * Returns all the message boards categories that the user has permission to view where groupId = ?. 487 * 488 * @param groupId the group ID 489 * @return the matching message boards categories that the user has permission to view 490 * @throws SystemException if a system exception occurred 491 */ 492 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 493 long groupId) 494 throws com.liferay.portal.kernel.exception.SystemException { 495 return getPersistence().filterFindByGroupId(groupId); 496 } 497 498 /** 499 * Returns a range of all the message boards categories that the user has permission to view where groupId = ?. 500 * 501 * <p> 502 * 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. 503 * </p> 504 * 505 * @param groupId the group ID 506 * @param start the lower bound of the range of message boards categories 507 * @param end the upper bound of the range of message boards categories (not inclusive) 508 * @return the range of matching message boards categories that the user has permission to view 509 * @throws SystemException if a system exception occurred 510 */ 511 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 512 long groupId, int start, int end) 513 throws com.liferay.portal.kernel.exception.SystemException { 514 return getPersistence().filterFindByGroupId(groupId, start, end); 515 } 516 517 /** 518 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ?. 519 * 520 * <p> 521 * 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. 522 * </p> 523 * 524 * @param groupId the group ID 525 * @param start the lower bound of the range of message boards categories 526 * @param end the upper bound of the range of message boards categories (not inclusive) 527 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 528 * @return the ordered range of matching message boards categories that the user has permission to view 529 * @throws SystemException if a system exception occurred 530 */ 531 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 532 long groupId, int start, int end, 533 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 534 throws com.liferay.portal.kernel.exception.SystemException { 535 return getPersistence() 536 .filterFindByGroupId(groupId, start, end, orderByComparator); 537 } 538 539 /** 540 * 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 = ?. 541 * 542 * @param categoryId the primary key of the current message boards category 543 * @param groupId the group ID 544 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 545 * @return the previous, current, and next message boards category 546 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 547 * @throws SystemException if a system exception occurred 548 */ 549 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByGroupId_PrevAndNext( 550 long categoryId, long groupId, 551 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 552 throws com.liferay.portal.kernel.exception.SystemException, 553 com.liferay.portlet.messageboards.NoSuchCategoryException { 554 return getPersistence() 555 .filterFindByGroupId_PrevAndNext(categoryId, groupId, 556 orderByComparator); 557 } 558 559 /** 560 * Returns all the message boards categories where companyId = ?. 561 * 562 * @param companyId the company ID 563 * @return the matching message boards categories 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 567 long companyId) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence().findByCompanyId(companyId); 570 } 571 572 /** 573 * Returns a range of all the message boards categories where companyId = ?. 574 * 575 * <p> 576 * 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. 577 * </p> 578 * 579 * @param companyId the company ID 580 * @param start the lower bound of the range of message boards categories 581 * @param end the upper bound of the range of message boards categories (not inclusive) 582 * @return the range of matching message boards categories 583 * @throws SystemException if a system exception occurred 584 */ 585 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 586 long companyId, int start, int end) 587 throws com.liferay.portal.kernel.exception.SystemException { 588 return getPersistence().findByCompanyId(companyId, start, end); 589 } 590 591 /** 592 * Returns an ordered range of all the message boards categories where companyId = ?. 593 * 594 * <p> 595 * 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. 596 * </p> 597 * 598 * @param companyId the company ID 599 * @param start the lower bound of the range of message boards categories 600 * @param end the upper bound of the range of message boards categories (not inclusive) 601 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 602 * @return the ordered range of matching message boards categories 603 * @throws SystemException if a system exception occurred 604 */ 605 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 606 long companyId, int start, int end, 607 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 608 throws com.liferay.portal.kernel.exception.SystemException { 609 return getPersistence() 610 .findByCompanyId(companyId, start, end, orderByComparator); 611 } 612 613 /** 614 * Returns the first message boards category in the ordered set where companyId = ?. 615 * 616 * <p> 617 * 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. 618 * </p> 619 * 620 * @param companyId the company ID 621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 622 * @return the first matching message boards category 623 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 624 * @throws SystemException if a system exception occurred 625 */ 626 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First( 627 long companyId, 628 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 629 throws com.liferay.portal.kernel.exception.SystemException, 630 com.liferay.portlet.messageboards.NoSuchCategoryException { 631 return getPersistence() 632 .findByCompanyId_First(companyId, orderByComparator); 633 } 634 635 /** 636 * Returns the last message boards category in the ordered set where companyId = ?. 637 * 638 * <p> 639 * 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. 640 * </p> 641 * 642 * @param companyId the company ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the last matching message boards category 645 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last( 649 long companyId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.messageboards.NoSuchCategoryException { 653 return getPersistence() 654 .findByCompanyId_Last(companyId, orderByComparator); 655 } 656 657 /** 658 * Returns the message boards categories before and after the current message boards category in the ordered set where companyId = ?. 659 * 660 * <p> 661 * 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. 662 * </p> 663 * 664 * @param categoryId the primary key of the current message boards category 665 * @param companyId the company ID 666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 667 * @return the previous, current, and next message boards category 668 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 669 * @throws SystemException if a system exception occurred 670 */ 671 public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext( 672 long categoryId, long companyId, 673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 674 throws com.liferay.portal.kernel.exception.SystemException, 675 com.liferay.portlet.messageboards.NoSuchCategoryException { 676 return getPersistence() 677 .findByCompanyId_PrevAndNext(categoryId, companyId, 678 orderByComparator); 679 } 680 681 /** 682 * Returns all the message boards categories where groupId = ? and parentCategoryId = ?. 683 * 684 * @param groupId the group ID 685 * @param parentCategoryId the parent category ID 686 * @return the matching message boards categories 687 * @throws SystemException if a system exception occurred 688 */ 689 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 690 long groupId, long parentCategoryId) 691 throws com.liferay.portal.kernel.exception.SystemException { 692 return getPersistence().findByG_P(groupId, parentCategoryId); 693 } 694 695 /** 696 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 697 * 698 * <p> 699 * 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. 700 * </p> 701 * 702 * @param groupId the group ID 703 * @param parentCategoryId the parent category ID 704 * @param start the lower bound of the range of message boards categories 705 * @param end the upper bound of the range of message boards categories (not inclusive) 706 * @return the range of matching message boards categories 707 * @throws SystemException if a system exception occurred 708 */ 709 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 710 long groupId, long parentCategoryId, int start, int end) 711 throws com.liferay.portal.kernel.exception.SystemException { 712 return getPersistence().findByG_P(groupId, parentCategoryId, start, end); 713 } 714 715 /** 716 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 717 * 718 * <p> 719 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 720 * </p> 721 * 722 * @param groupId the group ID 723 * @param parentCategoryId the parent category ID 724 * @param start the lower bound of the range of message boards categories 725 * @param end the upper bound of the range of message boards categories (not inclusive) 726 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 727 * @return the ordered range of matching message boards categories 728 * @throws SystemException if a system exception occurred 729 */ 730 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 731 long groupId, long parentCategoryId, int start, int end, 732 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 733 throws com.liferay.portal.kernel.exception.SystemException { 734 return getPersistence() 735 .findByG_P(groupId, parentCategoryId, start, end, 736 orderByComparator); 737 } 738 739 /** 740 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 741 * 742 * <p> 743 * 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. 744 * </p> 745 * 746 * @param groupId the group ID 747 * @param parentCategoryId the parent category ID 748 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 749 * @return the first matching message boards category 750 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 751 * @throws SystemException if a system exception occurred 752 */ 753 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First( 754 long groupId, long parentCategoryId, 755 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 756 throws com.liferay.portal.kernel.exception.SystemException, 757 com.liferay.portlet.messageboards.NoSuchCategoryException { 758 return getPersistence() 759 .findByG_P_First(groupId, parentCategoryId, orderByComparator); 760 } 761 762 /** 763 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 764 * 765 * <p> 766 * 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. 767 * </p> 768 * 769 * @param groupId the group ID 770 * @param parentCategoryId the parent category ID 771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 772 * @return the last matching message boards category 773 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 774 * @throws SystemException if a system exception occurred 775 */ 776 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last( 777 long groupId, long parentCategoryId, 778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 779 throws com.liferay.portal.kernel.exception.SystemException, 780 com.liferay.portlet.messageboards.NoSuchCategoryException { 781 return getPersistence() 782 .findByG_P_Last(groupId, parentCategoryId, orderByComparator); 783 } 784 785 /** 786 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 787 * 788 * <p> 789 * 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. 790 * </p> 791 * 792 * @param categoryId the primary key of the current message boards category 793 * @param groupId the group ID 794 * @param parentCategoryId the parent category ID 795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 796 * @return the previous, current, and next message boards category 797 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 798 * @throws SystemException if a system exception occurred 799 */ 800 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext( 801 long categoryId, long groupId, long parentCategoryId, 802 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 803 throws com.liferay.portal.kernel.exception.SystemException, 804 com.liferay.portlet.messageboards.NoSuchCategoryException { 805 return getPersistence() 806 .findByG_P_PrevAndNext(categoryId, groupId, 807 parentCategoryId, orderByComparator); 808 } 809 810 /** 811 * Returns all the message boards categories where groupId = ? and parentCategoryId = any ?. 812 * 813 * <p> 814 * 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. 815 * </p> 816 * 817 * @param groupId the group ID 818 * @param parentCategoryIds the parent category IDs 819 * @return the matching message boards categories 820 * @throws SystemException if a system exception occurred 821 */ 822 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 823 long groupId, long[] parentCategoryIds) 824 throws com.liferay.portal.kernel.exception.SystemException { 825 return getPersistence().findByG_P(groupId, parentCategoryIds); 826 } 827 828 /** 829 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 830 * 831 * <p> 832 * 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. 833 * </p> 834 * 835 * @param groupId the group ID 836 * @param parentCategoryIds the parent category IDs 837 * @param start the lower bound of the range of message boards categories 838 * @param end the upper bound of the range of message boards categories (not inclusive) 839 * @return the range of matching message boards categories 840 * @throws SystemException if a system exception occurred 841 */ 842 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 843 long groupId, long[] parentCategoryIds, int start, int end) 844 throws com.liferay.portal.kernel.exception.SystemException { 845 return getPersistence().findByG_P(groupId, parentCategoryIds, start, end); 846 } 847 848 /** 849 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 850 * 851 * <p> 852 * 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. 853 * </p> 854 * 855 * @param groupId the group ID 856 * @param parentCategoryIds the parent category IDs 857 * @param start the lower bound of the range of message boards categories 858 * @param end the upper bound of the range of message boards categories (not inclusive) 859 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 860 * @return the ordered range of matching message boards categories 861 * @throws SystemException if a system exception occurred 862 */ 863 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 864 long groupId, long[] parentCategoryIds, int start, int end, 865 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 866 throws com.liferay.portal.kernel.exception.SystemException { 867 return getPersistence() 868 .findByG_P(groupId, parentCategoryIds, start, end, 869 orderByComparator); 870 } 871 872 /** 873 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 874 * 875 * @param groupId the group ID 876 * @param parentCategoryId the parent category ID 877 * @return the matching message boards categories that the user has permission to view 878 * @throws SystemException if a system exception occurred 879 */ 880 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 881 long groupId, long parentCategoryId) 882 throws com.liferay.portal.kernel.exception.SystemException { 883 return getPersistence().filterFindByG_P(groupId, parentCategoryId); 884 } 885 886 /** 887 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 888 * 889 * <p> 890 * 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. 891 * </p> 892 * 893 * @param groupId the group ID 894 * @param parentCategoryId the parent category ID 895 * @param start the lower bound of the range of message boards categories 896 * @param end the upper bound of the range of message boards categories (not inclusive) 897 * @return the range of matching message boards categories that the user has permission to view 898 * @throws SystemException if a system exception occurred 899 */ 900 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 901 long groupId, long parentCategoryId, int start, int end) 902 throws com.liferay.portal.kernel.exception.SystemException { 903 return getPersistence() 904 .filterFindByG_P(groupId, parentCategoryId, start, end); 905 } 906 907 /** 908 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ? and parentCategoryId = ?. 909 * 910 * <p> 911 * 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. 912 * </p> 913 * 914 * @param groupId the group ID 915 * @param parentCategoryId the parent category ID 916 * @param start the lower bound of the range of message boards categories 917 * @param end the upper bound of the range of message boards categories (not inclusive) 918 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 919 * @return the ordered range of matching message boards categories that the user has permission to view 920 * @throws SystemException if a system exception occurred 921 */ 922 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 923 long groupId, long parentCategoryId, int start, int end, 924 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 925 throws com.liferay.portal.kernel.exception.SystemException { 926 return getPersistence() 927 .filterFindByG_P(groupId, parentCategoryId, start, end, 928 orderByComparator); 929 } 930 931 /** 932 * 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 = ?. 933 * 934 * @param categoryId the primary key of the current message boards category 935 * @param groupId the group ID 936 * @param parentCategoryId the parent category ID 937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 938 * @return the previous, current, and next message boards category 939 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 940 * @throws SystemException if a system exception occurred 941 */ 942 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByG_P_PrevAndNext( 943 long categoryId, long groupId, long parentCategoryId, 944 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 945 throws com.liferay.portal.kernel.exception.SystemException, 946 com.liferay.portlet.messageboards.NoSuchCategoryException { 947 return getPersistence() 948 .filterFindByG_P_PrevAndNext(categoryId, groupId, 949 parentCategoryId, orderByComparator); 950 } 951 952 /** 953 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 954 * 955 * @param groupId the group ID 956 * @param parentCategoryIds the parent category IDs 957 * @return the matching message boards categories that the user has permission to view 958 * @throws SystemException if a system exception occurred 959 */ 960 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 961 long groupId, long[] parentCategoryIds) 962 throws com.liferay.portal.kernel.exception.SystemException { 963 return getPersistence().filterFindByG_P(groupId, parentCategoryIds); 964 } 965 966 /** 967 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 968 * 969 * <p> 970 * 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. 971 * </p> 972 * 973 * @param groupId the group ID 974 * @param parentCategoryIds the parent category IDs 975 * @param start the lower bound of the range of message boards categories 976 * @param end the upper bound of the range of message boards categories (not inclusive) 977 * @return the range of matching message boards categories that the user has permission to view 978 * @throws SystemException if a system exception occurred 979 */ 980 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 981 long groupId, long[] parentCategoryIds, int start, int end) 982 throws com.liferay.portal.kernel.exception.SystemException { 983 return getPersistence() 984 .filterFindByG_P(groupId, parentCategoryIds, start, end); 985 } 986 987 /** 988 * Returns an ordered range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 989 * 990 * <p> 991 * 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. 992 * </p> 993 * 994 * @param groupId the group ID 995 * @param parentCategoryIds the parent category IDs 996 * @param start the lower bound of the range of message boards categories 997 * @param end the upper bound of the range of message boards categories (not inclusive) 998 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 999 * @return the ordered range of matching message boards categories that the user has permission to view 1000 * @throws SystemException if a system exception occurred 1001 */ 1002 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1003 long groupId, long[] parentCategoryIds, int start, int end, 1004 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1005 throws com.liferay.portal.kernel.exception.SystemException { 1006 return getPersistence() 1007 .filterFindByG_P(groupId, parentCategoryIds, start, end, 1008 orderByComparator); 1009 } 1010 1011 /** 1012 * Returns all the message boards categories. 1013 * 1014 * @return the message boards categories 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll() 1018 throws com.liferay.portal.kernel.exception.SystemException { 1019 return getPersistence().findAll(); 1020 } 1021 1022 /** 1023 * Returns a range of all the message boards categories. 1024 * 1025 * <p> 1026 * 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. 1027 * </p> 1028 * 1029 * @param start the lower bound of the range of message boards categories 1030 * @param end the upper bound of the range of message boards categories (not inclusive) 1031 * @return the range of message boards categories 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 1035 int start, int end) 1036 throws com.liferay.portal.kernel.exception.SystemException { 1037 return getPersistence().findAll(start, end); 1038 } 1039 1040 /** 1041 * Returns an ordered range of all the message boards categories. 1042 * 1043 * <p> 1044 * 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. 1045 * </p> 1046 * 1047 * @param start the lower bound of the range of message boards categories 1048 * @param end the upper bound of the range of message boards categories (not inclusive) 1049 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1050 * @return the ordered range of message boards categories 1051 * @throws SystemException if a system exception occurred 1052 */ 1053 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 1054 int start, int end, 1055 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1056 throws com.liferay.portal.kernel.exception.SystemException { 1057 return getPersistence().findAll(start, end, orderByComparator); 1058 } 1059 1060 /** 1061 * Removes all the message boards categories where uuid = ? from the database. 1062 * 1063 * @param uuid the uuid 1064 * @throws SystemException if a system exception occurred 1065 */ 1066 public static void removeByUuid(java.lang.String uuid) 1067 throws com.liferay.portal.kernel.exception.SystemException { 1068 getPersistence().removeByUuid(uuid); 1069 } 1070 1071 /** 1072 * Removes the message boards category where uuid = ? and groupId = ? from the database. 1073 * 1074 * @param uuid the uuid 1075 * @param groupId the group ID 1076 * @throws SystemException if a system exception occurred 1077 */ 1078 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1079 throws com.liferay.portal.kernel.exception.SystemException, 1080 com.liferay.portlet.messageboards.NoSuchCategoryException { 1081 getPersistence().removeByUUID_G(uuid, groupId); 1082 } 1083 1084 /** 1085 * Removes all the message boards categories where groupId = ? from the database. 1086 * 1087 * @param groupId the group ID 1088 * @throws SystemException if a system exception occurred 1089 */ 1090 public static void removeByGroupId(long groupId) 1091 throws com.liferay.portal.kernel.exception.SystemException { 1092 getPersistence().removeByGroupId(groupId); 1093 } 1094 1095 /** 1096 * Removes all the message boards categories where companyId = ? from the database. 1097 * 1098 * @param companyId the company ID 1099 * @throws SystemException if a system exception occurred 1100 */ 1101 public static void removeByCompanyId(long companyId) 1102 throws com.liferay.portal.kernel.exception.SystemException { 1103 getPersistence().removeByCompanyId(companyId); 1104 } 1105 1106 /** 1107 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? from the database. 1108 * 1109 * @param groupId the group ID 1110 * @param parentCategoryId the parent category ID 1111 * @throws SystemException if a system exception occurred 1112 */ 1113 public static void removeByG_P(long groupId, long parentCategoryId) 1114 throws com.liferay.portal.kernel.exception.SystemException { 1115 getPersistence().removeByG_P(groupId, parentCategoryId); 1116 } 1117 1118 /** 1119 * Removes all the message boards categories from the database. 1120 * 1121 * @throws SystemException if a system exception occurred 1122 */ 1123 public static void removeAll() 1124 throws com.liferay.portal.kernel.exception.SystemException { 1125 getPersistence().removeAll(); 1126 } 1127 1128 /** 1129 * Returns the number of message boards categories where uuid = ?. 1130 * 1131 * @param uuid the uuid 1132 * @return the number of matching message boards categories 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static int countByUuid(java.lang.String uuid) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 return getPersistence().countByUuid(uuid); 1138 } 1139 1140 /** 1141 * Returns the number of message boards categories where uuid = ? and groupId = ?. 1142 * 1143 * @param uuid the uuid 1144 * @param groupId the group ID 1145 * @return the number of matching message boards categories 1146 * @throws SystemException if a system exception occurred 1147 */ 1148 public static int countByUUID_G(java.lang.String uuid, long groupId) 1149 throws com.liferay.portal.kernel.exception.SystemException { 1150 return getPersistence().countByUUID_G(uuid, groupId); 1151 } 1152 1153 /** 1154 * Returns the number of message boards categories where groupId = ?. 1155 * 1156 * @param groupId the group ID 1157 * @return the number of matching message boards categories 1158 * @throws SystemException if a system exception occurred 1159 */ 1160 public static int countByGroupId(long groupId) 1161 throws com.liferay.portal.kernel.exception.SystemException { 1162 return getPersistence().countByGroupId(groupId); 1163 } 1164 1165 /** 1166 * Returns the number of message boards categories that the user has permission to view where groupId = ?. 1167 * 1168 * @param groupId the group ID 1169 * @return the number of matching message boards categories that the user has permission to view 1170 * @throws SystemException if a system exception occurred 1171 */ 1172 public static int filterCountByGroupId(long groupId) 1173 throws com.liferay.portal.kernel.exception.SystemException { 1174 return getPersistence().filterCountByGroupId(groupId); 1175 } 1176 1177 /** 1178 * Returns the number of message boards categories where companyId = ?. 1179 * 1180 * @param companyId the company ID 1181 * @return the number of matching message boards categories 1182 * @throws SystemException if a system exception occurred 1183 */ 1184 public static int countByCompanyId(long companyId) 1185 throws com.liferay.portal.kernel.exception.SystemException { 1186 return getPersistence().countByCompanyId(companyId); 1187 } 1188 1189 /** 1190 * Returns the number of message boards categories where groupId = ? and parentCategoryId = ?. 1191 * 1192 * @param groupId the group ID 1193 * @param parentCategoryId the parent category ID 1194 * @return the number of matching message boards categories 1195 * @throws SystemException if a system exception occurred 1196 */ 1197 public static int countByG_P(long groupId, long parentCategoryId) 1198 throws com.liferay.portal.kernel.exception.SystemException { 1199 return getPersistence().countByG_P(groupId, parentCategoryId); 1200 } 1201 1202 /** 1203 * Returns the number of message boards categories where groupId = ? and parentCategoryId = any ?. 1204 * 1205 * @param groupId the group ID 1206 * @param parentCategoryIds the parent category IDs 1207 * @return the number of matching message boards categories 1208 * @throws SystemException if a system exception occurred 1209 */ 1210 public static int countByG_P(long groupId, long[] parentCategoryIds) 1211 throws com.liferay.portal.kernel.exception.SystemException { 1212 return getPersistence().countByG_P(groupId, parentCategoryIds); 1213 } 1214 1215 /** 1216 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1217 * 1218 * @param groupId the group ID 1219 * @param parentCategoryId the parent category ID 1220 * @return the number of matching message boards categories that the user has permission to view 1221 * @throws SystemException if a system exception occurred 1222 */ 1223 public static int filterCountByG_P(long groupId, long parentCategoryId) 1224 throws com.liferay.portal.kernel.exception.SystemException { 1225 return getPersistence().filterCountByG_P(groupId, parentCategoryId); 1226 } 1227 1228 /** 1229 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1230 * 1231 * @param groupId the group ID 1232 * @param parentCategoryIds the parent category IDs 1233 * @return the number of matching message boards categories that the user has permission to view 1234 * @throws SystemException if a system exception occurred 1235 */ 1236 public static int filterCountByG_P(long groupId, long[] parentCategoryIds) 1237 throws com.liferay.portal.kernel.exception.SystemException { 1238 return getPersistence().filterCountByG_P(groupId, parentCategoryIds); 1239 } 1240 1241 /** 1242 * Returns the number of message boards categories. 1243 * 1244 * @return the number of message boards categories 1245 * @throws SystemException if a system exception occurred 1246 */ 1247 public static int countAll() 1248 throws com.liferay.portal.kernel.exception.SystemException { 1249 return getPersistence().countAll(); 1250 } 1251 1252 public static MBCategoryPersistence getPersistence() { 1253 if (_persistence == null) { 1254 _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName()); 1255 1256 ReferenceRegistry.registerReference(MBCategoryUtil.class, 1257 "_persistence"); 1258 } 1259 1260 return _persistence; 1261 } 1262 1263 public void setPersistence(MBCategoryPersistence persistence) { 1264 _persistence = persistence; 1265 1266 ReferenceRegistry.registerReference(MBCategoryUtil.class, "_persistence"); 1267 } 1268 1269 private static MBCategoryPersistence _persistence; 1270 }