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