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