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