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