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.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.Group; 024 import com.liferay.portal.service.ServiceContext; 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.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(Group group) { 059 getPersistence().clearCache(group); 060 } 061 062 /** 063 * @see com.liferay.portal.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.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.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.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.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 096 */ 097 public static Group update(Group group) { 098 return getPersistence().update(group); 099 } 100 101 /** 102 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 type = ? and active = ?. 1349 * 1350 * @param type the type 1351 * @param active the active 1352 * @return the matching groups 1353 */ 1354 public static List<Group> findByT_A(int type, boolean active) { 1355 return getPersistence().findByT_A(type, active); 1356 } 1357 1358 /** 1359 * Returns a range of all the groups where type = ? 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 type the type 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> findByT_A(int type, boolean active, int start, 1372 int end) { 1373 return getPersistence().findByT_A(type, active, start, end); 1374 } 1375 1376 /** 1377 * Returns an ordered range of all the groups where type = ? 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 type the type 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> findByT_A(int type, boolean active, int start, 1391 int end, OrderByComparator<Group> orderByComparator) { 1392 return getPersistence() 1393 .findByT_A(type, active, start, end, orderByComparator); 1394 } 1395 1396 /** 1397 * Returns an ordered range of all the groups where type = ? 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 type the type 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> findByT_A(int type, boolean active, int start, 1412 int end, OrderByComparator<Group> orderByComparator, 1413 boolean retrieveFromCache) { 1414 return getPersistence() 1415 .findByT_A(type, active, start, end, orderByComparator, 1416 retrieveFromCache); 1417 } 1418 1419 /** 1420 * Returns the first group in the ordered set where type = ? and active = ?. 1421 * 1422 * @param type the type 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 findByT_A_First(int type, boolean active, 1429 OrderByComparator<Group> orderByComparator) 1430 throws com.liferay.portal.NoSuchGroupException { 1431 return getPersistence().findByT_A_First(type, active, orderByComparator); 1432 } 1433 1434 /** 1435 * Returns the first group in the ordered set where type = ? and active = ?. 1436 * 1437 * @param type the type 1438 * @param active the active 1439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1440 * @return the first matching group, or <code>null</code> if a matching group could not be found 1441 */ 1442 public static Group fetchByT_A_First(int type, boolean active, 1443 OrderByComparator<Group> orderByComparator) { 1444 return getPersistence().fetchByT_A_First(type, active, orderByComparator); 1445 } 1446 1447 /** 1448 * Returns the last group in the ordered set where type = ? and active = ?. 1449 * 1450 * @param type the type 1451 * @param active the active 1452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1453 * @return the last matching group 1454 * @throws NoSuchGroupException if a matching group could not be found 1455 */ 1456 public static Group findByT_A_Last(int type, boolean active, 1457 OrderByComparator<Group> orderByComparator) 1458 throws com.liferay.portal.NoSuchGroupException { 1459 return getPersistence().findByT_A_Last(type, active, orderByComparator); 1460 } 1461 1462 /** 1463 * Returns the last group in the ordered set where type = ? and active = ?. 1464 * 1465 * @param type the type 1466 * @param active the active 1467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1468 * @return the last matching group, or <code>null</code> if a matching group could not be found 1469 */ 1470 public static Group fetchByT_A_Last(int type, boolean active, 1471 OrderByComparator<Group> orderByComparator) { 1472 return getPersistence().fetchByT_A_Last(type, active, orderByComparator); 1473 } 1474 1475 /** 1476 * Returns the groups before and after the current group in the ordered set where type = ? and active = ?. 1477 * 1478 * @param groupId the primary key of the current group 1479 * @param type the type 1480 * @param active the active 1481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1482 * @return the previous, current, and next group 1483 * @throws NoSuchGroupException if a group with the primary key could not be found 1484 */ 1485 public static Group[] findByT_A_PrevAndNext(long groupId, int type, 1486 boolean active, OrderByComparator<Group> orderByComparator) 1487 throws com.liferay.portal.NoSuchGroupException { 1488 return getPersistence() 1489 .findByT_A_PrevAndNext(groupId, type, active, 1490 orderByComparator); 1491 } 1492 1493 /** 1494 * Removes all the groups where type = ? and active = ? from the database. 1495 * 1496 * @param type the type 1497 * @param active the active 1498 */ 1499 public static void removeByT_A(int type, boolean active) { 1500 getPersistence().removeByT_A(type, active); 1501 } 1502 1503 /** 1504 * Returns the number of groups where type = ? and active = ?. 1505 * 1506 * @param type the type 1507 * @param active the active 1508 * @return the number of matching groups 1509 */ 1510 public static int countByT_A(int type, boolean active) { 1511 return getPersistence().countByT_A(type, active); 1512 } 1513 1514 /** 1515 * Returns all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1516 * 1517 * @param groupId the group ID 1518 * @param companyId the company ID 1519 * @param parentGroupId the parent group ID 1520 * @return the matching groups 1521 */ 1522 public static List<Group> findByG_C_P(long groupId, long companyId, 1523 long parentGroupId) { 1524 return getPersistence().findByG_C_P(groupId, companyId, parentGroupId); 1525 } 1526 1527 /** 1528 * Returns a range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1529 * 1530 * <p> 1531 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1532 * </p> 1533 * 1534 * @param groupId the group ID 1535 * @param companyId the company ID 1536 * @param parentGroupId the parent group ID 1537 * @param start the lower bound of the range of groups 1538 * @param end the upper bound of the range of groups (not inclusive) 1539 * @return the range of matching groups 1540 */ 1541 public static List<Group> findByG_C_P(long groupId, long companyId, 1542 long parentGroupId, int start, int end) { 1543 return getPersistence() 1544 .findByG_C_P(groupId, companyId, parentGroupId, start, end); 1545 } 1546 1547 /** 1548 * Returns an ordered range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1549 * 1550 * <p> 1551 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1552 * </p> 1553 * 1554 * @param groupId the group ID 1555 * @param companyId the company ID 1556 * @param parentGroupId the parent group ID 1557 * @param start the lower bound of the range of groups 1558 * @param end the upper bound of the range of groups (not inclusive) 1559 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1560 * @return the ordered range of matching groups 1561 */ 1562 public static List<Group> findByG_C_P(long groupId, long companyId, 1563 long parentGroupId, int start, int end, 1564 OrderByComparator<Group> orderByComparator) { 1565 return getPersistence() 1566 .findByG_C_P(groupId, companyId, parentGroupId, start, end, 1567 orderByComparator); 1568 } 1569 1570 /** 1571 * Returns an ordered range of all the groups where groupId > ? and companyId = ? and parentGroupId = ?. 1572 * 1573 * <p> 1574 * 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. 1575 * </p> 1576 * 1577 * @param groupId the group ID 1578 * @param companyId the company ID 1579 * @param parentGroupId the parent group ID 1580 * @param start the lower bound of the range of groups 1581 * @param end the upper bound of the range of groups (not inclusive) 1582 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1583 * @param retrieveFromCache whether to retrieve from the finder cache 1584 * @return the ordered range of matching groups 1585 */ 1586 public static List<Group> findByG_C_P(long groupId, long companyId, 1587 long parentGroupId, int start, int end, 1588 OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) { 1589 return getPersistence() 1590 .findByG_C_P(groupId, companyId, parentGroupId, start, end, 1591 orderByComparator, retrieveFromCache); 1592 } 1593 1594 /** 1595 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1596 * 1597 * @param groupId the group ID 1598 * @param companyId the company ID 1599 * @param parentGroupId the parent group ID 1600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1601 * @return the first matching group 1602 * @throws NoSuchGroupException if a matching group could not be found 1603 */ 1604 public static Group findByG_C_P_First(long groupId, long companyId, 1605 long parentGroupId, OrderByComparator<Group> orderByComparator) 1606 throws com.liferay.portal.NoSuchGroupException { 1607 return getPersistence() 1608 .findByG_C_P_First(groupId, companyId, parentGroupId, 1609 orderByComparator); 1610 } 1611 1612 /** 1613 * Returns the first group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1614 * 1615 * @param groupId the group ID 1616 * @param companyId the company ID 1617 * @param parentGroupId the parent group ID 1618 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1619 * @return the first matching group, or <code>null</code> if a matching group could not be found 1620 */ 1621 public static Group fetchByG_C_P_First(long groupId, long companyId, 1622 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1623 return getPersistence() 1624 .fetchByG_C_P_First(groupId, companyId, parentGroupId, 1625 orderByComparator); 1626 } 1627 1628 /** 1629 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1630 * 1631 * @param groupId the group ID 1632 * @param companyId the company ID 1633 * @param parentGroupId the parent group ID 1634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1635 * @return the last matching group 1636 * @throws NoSuchGroupException if a matching group could not be found 1637 */ 1638 public static Group findByG_C_P_Last(long groupId, long companyId, 1639 long parentGroupId, OrderByComparator<Group> orderByComparator) 1640 throws com.liferay.portal.NoSuchGroupException { 1641 return getPersistence() 1642 .findByG_C_P_Last(groupId, companyId, parentGroupId, 1643 orderByComparator); 1644 } 1645 1646 /** 1647 * Returns the last group in the ordered set where groupId > ? and companyId = ? and parentGroupId = ?. 1648 * 1649 * @param groupId the group ID 1650 * @param companyId the company ID 1651 * @param parentGroupId the parent group ID 1652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1653 * @return the last matching group, or <code>null</code> if a matching group could not be found 1654 */ 1655 public static Group fetchByG_C_P_Last(long groupId, long companyId, 1656 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1657 return getPersistence() 1658 .fetchByG_C_P_Last(groupId, companyId, parentGroupId, 1659 orderByComparator); 1660 } 1661 1662 /** 1663 * Removes all the groups where groupId > ? and companyId = ? and parentGroupId = ? from the database. 1664 * 1665 * @param groupId the group ID 1666 * @param companyId the company ID 1667 * @param parentGroupId the parent group ID 1668 */ 1669 public static void removeByG_C_P(long groupId, long companyId, 1670 long parentGroupId) { 1671 getPersistence().removeByG_C_P(groupId, companyId, parentGroupId); 1672 } 1673 1674 /** 1675 * Returns the number of groups where groupId > ? and companyId = ? and parentGroupId = ?. 1676 * 1677 * @param groupId the group ID 1678 * @param companyId the company ID 1679 * @param parentGroupId the parent group ID 1680 * @return the number of matching groups 1681 */ 1682 public static int countByG_C_P(long groupId, long companyId, 1683 long parentGroupId) { 1684 return getPersistence().countByG_C_P(groupId, companyId, parentGroupId); 1685 } 1686 1687 /** 1688 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or throws a {@link NoSuchGroupException} if it could not be found. 1689 * 1690 * @param companyId the company ID 1691 * @param classNameId the class name ID 1692 * @param classPK the class p k 1693 * @return the matching group 1694 * @throws NoSuchGroupException if a matching group could not be found 1695 */ 1696 public static Group findByC_C_C(long companyId, long classNameId, 1697 long classPK) throws com.liferay.portal.NoSuchGroupException { 1698 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 1699 } 1700 1701 /** 1702 * Returns the group where companyId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1703 * 1704 * @param companyId the company ID 1705 * @param classNameId the class name ID 1706 * @param classPK the class p k 1707 * @return the matching group, or <code>null</code> if a matching group could not be found 1708 */ 1709 public static Group fetchByC_C_C(long companyId, long classNameId, 1710 long classPK) { 1711 return getPersistence().fetchByC_C_C(companyId, classNameId, classPK); 1712 } 1713 1714 /** 1715 * 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. 1716 * 1717 * @param companyId the company ID 1718 * @param classNameId the class name ID 1719 * @param classPK the class p k 1720 * @param retrieveFromCache whether to retrieve from the finder cache 1721 * @return the matching group, or <code>null</code> if a matching group could not be found 1722 */ 1723 public static Group fetchByC_C_C(long companyId, long classNameId, 1724 long classPK, boolean retrieveFromCache) { 1725 return getPersistence() 1726 .fetchByC_C_C(companyId, classNameId, classPK, 1727 retrieveFromCache); 1728 } 1729 1730 /** 1731 * Removes the group where companyId = ? and classNameId = ? and classPK = ? from the database. 1732 * 1733 * @param companyId the company ID 1734 * @param classNameId the class name ID 1735 * @param classPK the class p k 1736 * @return the group that was removed 1737 */ 1738 public static Group removeByC_C_C(long companyId, long classNameId, 1739 long classPK) throws com.liferay.portal.NoSuchGroupException { 1740 return getPersistence().removeByC_C_C(companyId, classNameId, classPK); 1741 } 1742 1743 /** 1744 * Returns the number of groups where companyId = ? and classNameId = ? and classPK = ?. 1745 * 1746 * @param companyId the company ID 1747 * @param classNameId the class name ID 1748 * @param classPK the class p k 1749 * @return the number of matching groups 1750 */ 1751 public static int countByC_C_C(long companyId, long classNameId, 1752 long classPK) { 1753 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 1754 } 1755 1756 /** 1757 * Returns all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1758 * 1759 * @param companyId the company ID 1760 * @param classNameId the class name ID 1761 * @param parentGroupId the parent group ID 1762 * @return the matching groups 1763 */ 1764 public static List<Group> findByC_C_P(long companyId, long classNameId, 1765 long parentGroupId) { 1766 return getPersistence() 1767 .findByC_C_P(companyId, classNameId, parentGroupId); 1768 } 1769 1770 /** 1771 * Returns a range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1772 * 1773 * <p> 1774 * 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. 1775 * </p> 1776 * 1777 * @param companyId the company ID 1778 * @param classNameId the class name ID 1779 * @param parentGroupId the parent group ID 1780 * @param start the lower bound of the range of groups 1781 * @param end the upper bound of the range of groups (not inclusive) 1782 * @return the range of matching groups 1783 */ 1784 public static List<Group> findByC_C_P(long companyId, long classNameId, 1785 long parentGroupId, int start, int end) { 1786 return getPersistence() 1787 .findByC_C_P(companyId, classNameId, parentGroupId, start, 1788 end); 1789 } 1790 1791 /** 1792 * Returns an ordered range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1793 * 1794 * <p> 1795 * 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. 1796 * </p> 1797 * 1798 * @param companyId the company ID 1799 * @param classNameId the class name ID 1800 * @param parentGroupId the parent group ID 1801 * @param start the lower bound of the range of groups 1802 * @param end the upper bound of the range of groups (not inclusive) 1803 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1804 * @return the ordered range of matching groups 1805 */ 1806 public static List<Group> findByC_C_P(long companyId, long classNameId, 1807 long parentGroupId, int start, int end, 1808 OrderByComparator<Group> orderByComparator) { 1809 return getPersistence() 1810 .findByC_C_P(companyId, classNameId, parentGroupId, start, 1811 end, orderByComparator); 1812 } 1813 1814 /** 1815 * Returns an ordered range of all the groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1816 * 1817 * <p> 1818 * 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. 1819 * </p> 1820 * 1821 * @param companyId the company ID 1822 * @param classNameId the class name ID 1823 * @param parentGroupId the parent group ID 1824 * @param start the lower bound of the range of groups 1825 * @param end the upper bound of the range of groups (not inclusive) 1826 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1827 * @param retrieveFromCache whether to retrieve from the finder cache 1828 * @return the ordered range of matching groups 1829 */ 1830 public static List<Group> findByC_C_P(long companyId, long classNameId, 1831 long parentGroupId, int start, int end, 1832 OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) { 1833 return getPersistence() 1834 .findByC_C_P(companyId, classNameId, parentGroupId, start, 1835 end, orderByComparator, retrieveFromCache); 1836 } 1837 1838 /** 1839 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1840 * 1841 * @param companyId the company ID 1842 * @param classNameId the class name ID 1843 * @param parentGroupId the parent group ID 1844 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1845 * @return the first matching group 1846 * @throws NoSuchGroupException if a matching group could not be found 1847 */ 1848 public static Group findByC_C_P_First(long companyId, long classNameId, 1849 long parentGroupId, OrderByComparator<Group> orderByComparator) 1850 throws com.liferay.portal.NoSuchGroupException { 1851 return getPersistence() 1852 .findByC_C_P_First(companyId, classNameId, parentGroupId, 1853 orderByComparator); 1854 } 1855 1856 /** 1857 * Returns the first group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1858 * 1859 * @param companyId the company ID 1860 * @param classNameId the class name ID 1861 * @param parentGroupId the parent group ID 1862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1863 * @return the first matching group, or <code>null</code> if a matching group could not be found 1864 */ 1865 public static Group fetchByC_C_P_First(long companyId, long classNameId, 1866 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1867 return getPersistence() 1868 .fetchByC_C_P_First(companyId, classNameId, parentGroupId, 1869 orderByComparator); 1870 } 1871 1872 /** 1873 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1874 * 1875 * @param companyId the company ID 1876 * @param classNameId the class name ID 1877 * @param parentGroupId the parent group ID 1878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1879 * @return the last matching group 1880 * @throws NoSuchGroupException if a matching group could not be found 1881 */ 1882 public static Group findByC_C_P_Last(long companyId, long classNameId, 1883 long parentGroupId, OrderByComparator<Group> orderByComparator) 1884 throws com.liferay.portal.NoSuchGroupException { 1885 return getPersistence() 1886 .findByC_C_P_Last(companyId, classNameId, parentGroupId, 1887 orderByComparator); 1888 } 1889 1890 /** 1891 * Returns the last group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1892 * 1893 * @param companyId the company ID 1894 * @param classNameId the class name ID 1895 * @param parentGroupId the parent group ID 1896 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1897 * @return the last matching group, or <code>null</code> if a matching group could not be found 1898 */ 1899 public static Group fetchByC_C_P_Last(long companyId, long classNameId, 1900 long parentGroupId, OrderByComparator<Group> orderByComparator) { 1901 return getPersistence() 1902 .fetchByC_C_P_Last(companyId, classNameId, parentGroupId, 1903 orderByComparator); 1904 } 1905 1906 /** 1907 * Returns the groups before and after the current group in the ordered set where companyId = ? and classNameId = ? and parentGroupId = ?. 1908 * 1909 * @param groupId the primary key of the current group 1910 * @param companyId the company ID 1911 * @param classNameId the class name ID 1912 * @param parentGroupId the parent group ID 1913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1914 * @return the previous, current, and next group 1915 * @throws NoSuchGroupException if a group with the primary key could not be found 1916 */ 1917 public static Group[] findByC_C_P_PrevAndNext(long groupId, long companyId, 1918 long classNameId, long parentGroupId, 1919 OrderByComparator<Group> orderByComparator) 1920 throws com.liferay.portal.NoSuchGroupException { 1921 return getPersistence() 1922 .findByC_C_P_PrevAndNext(groupId, companyId, classNameId, 1923 parentGroupId, orderByComparator); 1924 } 1925 1926 /** 1927 * Removes all the groups where companyId = ? and classNameId = ? and parentGroupId = ? from the database. 1928 * 1929 * @param companyId the company ID 1930 * @param classNameId the class name ID 1931 * @param parentGroupId the parent group ID 1932 */ 1933 public static void removeByC_C_P(long companyId, long classNameId, 1934 long parentGroupId) { 1935 getPersistence().removeByC_C_P(companyId, classNameId, parentGroupId); 1936 } 1937 1938 /** 1939 * Returns the number of groups where companyId = ? and classNameId = ? and parentGroupId = ?. 1940 * 1941 * @param companyId the company ID 1942 * @param classNameId the class name ID 1943 * @param parentGroupId the parent group ID 1944 * @return the number of matching groups 1945 */ 1946 public static int countByC_C_P(long companyId, long classNameId, 1947 long parentGroupId) { 1948 return getPersistence() 1949 .countByC_C_P(companyId, classNameId, parentGroupId); 1950 } 1951 1952 /** 1953 * Returns all the groups where companyId = ? and parentGroupId = ? and site = ?. 1954 * 1955 * @param companyId the company ID 1956 * @param parentGroupId the parent group ID 1957 * @param site the site 1958 * @return the matching groups 1959 */ 1960 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 1961 boolean site) { 1962 return getPersistence().findByC_P_S(companyId, parentGroupId, site); 1963 } 1964 1965 /** 1966 * Returns a range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 1967 * 1968 * <p> 1969 * 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. 1970 * </p> 1971 * 1972 * @param companyId the company ID 1973 * @param parentGroupId the parent group ID 1974 * @param site the site 1975 * @param start the lower bound of the range of groups 1976 * @param end the upper bound of the range of groups (not inclusive) 1977 * @return the range of matching groups 1978 */ 1979 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 1980 boolean site, int start, int end) { 1981 return getPersistence() 1982 .findByC_P_S(companyId, parentGroupId, site, start, end); 1983 } 1984 1985 /** 1986 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 1987 * 1988 * <p> 1989 * 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. 1990 * </p> 1991 * 1992 * @param companyId the company ID 1993 * @param parentGroupId the parent group ID 1994 * @param site the site 1995 * @param start the lower bound of the range of groups 1996 * @param end the upper bound of the range of groups (not inclusive) 1997 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1998 * @return the ordered range of matching groups 1999 */ 2000 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 2001 boolean site, int start, int end, 2002 OrderByComparator<Group> orderByComparator) { 2003 return getPersistence() 2004 .findByC_P_S(companyId, parentGroupId, site, start, end, 2005 orderByComparator); 2006 } 2007 2008 /** 2009 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ?. 2010 * 2011 * <p> 2012 * 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. 2013 * </p> 2014 * 2015 * @param companyId the company ID 2016 * @param parentGroupId the parent group ID 2017 * @param site the site 2018 * @param start the lower bound of the range of groups 2019 * @param end the upper bound of the range of groups (not inclusive) 2020 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2021 * @param retrieveFromCache whether to retrieve from the finder cache 2022 * @return the ordered range of matching groups 2023 */ 2024 public static List<Group> findByC_P_S(long companyId, long parentGroupId, 2025 boolean site, int start, int end, 2026 OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) { 2027 return getPersistence() 2028 .findByC_P_S(companyId, parentGroupId, site, start, end, 2029 orderByComparator, retrieveFromCache); 2030 } 2031 2032 /** 2033 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2034 * 2035 * @param companyId the company ID 2036 * @param parentGroupId the parent group ID 2037 * @param site the site 2038 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2039 * @return the first matching group 2040 * @throws NoSuchGroupException if a matching group could not be found 2041 */ 2042 public static Group findByC_P_S_First(long companyId, long parentGroupId, 2043 boolean site, OrderByComparator<Group> orderByComparator) 2044 throws com.liferay.portal.NoSuchGroupException { 2045 return getPersistence() 2046 .findByC_P_S_First(companyId, parentGroupId, site, 2047 orderByComparator); 2048 } 2049 2050 /** 2051 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2052 * 2053 * @param companyId the company ID 2054 * @param parentGroupId the parent group ID 2055 * @param site the site 2056 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2057 * @return the first matching group, or <code>null</code> if a matching group could not be found 2058 */ 2059 public static Group fetchByC_P_S_First(long companyId, long parentGroupId, 2060 boolean site, OrderByComparator<Group> orderByComparator) { 2061 return getPersistence() 2062 .fetchByC_P_S_First(companyId, parentGroupId, site, 2063 orderByComparator); 2064 } 2065 2066 /** 2067 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2068 * 2069 * @param companyId the company ID 2070 * @param parentGroupId the parent group ID 2071 * @param site the site 2072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2073 * @return the last matching group 2074 * @throws NoSuchGroupException if a matching group could not be found 2075 */ 2076 public static Group findByC_P_S_Last(long companyId, long parentGroupId, 2077 boolean site, OrderByComparator<Group> orderByComparator) 2078 throws com.liferay.portal.NoSuchGroupException { 2079 return getPersistence() 2080 .findByC_P_S_Last(companyId, parentGroupId, site, 2081 orderByComparator); 2082 } 2083 2084 /** 2085 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2086 * 2087 * @param companyId the company ID 2088 * @param parentGroupId the parent group ID 2089 * @param site the site 2090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2091 * @return the last matching group, or <code>null</code> if a matching group could not be found 2092 */ 2093 public static Group fetchByC_P_S_Last(long companyId, long parentGroupId, 2094 boolean site, OrderByComparator<Group> orderByComparator) { 2095 return getPersistence() 2096 .fetchByC_P_S_Last(companyId, parentGroupId, site, 2097 orderByComparator); 2098 } 2099 2100 /** 2101 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ? and site = ?. 2102 * 2103 * @param groupId the primary key of the current group 2104 * @param companyId the company ID 2105 * @param parentGroupId the parent group ID 2106 * @param site the site 2107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2108 * @return the previous, current, and next group 2109 * @throws NoSuchGroupException if a group with the primary key could not be found 2110 */ 2111 public static Group[] findByC_P_S_PrevAndNext(long groupId, long companyId, 2112 long parentGroupId, boolean site, 2113 OrderByComparator<Group> orderByComparator) 2114 throws com.liferay.portal.NoSuchGroupException { 2115 return getPersistence() 2116 .findByC_P_S_PrevAndNext(groupId, companyId, parentGroupId, 2117 site, orderByComparator); 2118 } 2119 2120 /** 2121 * Removes all the groups where companyId = ? and parentGroupId = ? and site = ? from the database. 2122 * 2123 * @param companyId the company ID 2124 * @param parentGroupId the parent group ID 2125 * @param site the site 2126 */ 2127 public static void removeByC_P_S(long companyId, long parentGroupId, 2128 boolean site) { 2129 getPersistence().removeByC_P_S(companyId, parentGroupId, site); 2130 } 2131 2132 /** 2133 * Returns the number of groups where companyId = ? and parentGroupId = ? and site = ?. 2134 * 2135 * @param companyId the company ID 2136 * @param parentGroupId the parent group ID 2137 * @param site the site 2138 * @return the number of matching groups 2139 */ 2140 public static int countByC_P_S(long companyId, long parentGroupId, 2141 boolean site) { 2142 return getPersistence().countByC_P_S(companyId, parentGroupId, site); 2143 } 2144 2145 /** 2146 * Returns the group where companyId = ? and liveGroupId = ? and groupKey = ? or throws a {@link NoSuchGroupException} if it could not be found. 2147 * 2148 * @param companyId the company ID 2149 * @param liveGroupId the live group ID 2150 * @param groupKey the group key 2151 * @return the matching group 2152 * @throws NoSuchGroupException if a matching group could not be found 2153 */ 2154 public static Group findByC_L_GK(long companyId, long liveGroupId, 2155 java.lang.String groupKey) 2156 throws com.liferay.portal.NoSuchGroupException { 2157 return getPersistence().findByC_L_GK(companyId, liveGroupId, groupKey); 2158 } 2159 2160 /** 2161 * Returns the group where companyId = ? and liveGroupId = ? and groupKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2162 * 2163 * @param companyId the company ID 2164 * @param liveGroupId the live group ID 2165 * @param groupKey the group key 2166 * @return the matching group, or <code>null</code> if a matching group could not be found 2167 */ 2168 public static Group fetchByC_L_GK(long companyId, long liveGroupId, 2169 java.lang.String groupKey) { 2170 return getPersistence().fetchByC_L_GK(companyId, liveGroupId, groupKey); 2171 } 2172 2173 /** 2174 * 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. 2175 * 2176 * @param companyId the company ID 2177 * @param liveGroupId the live group ID 2178 * @param groupKey the group key 2179 * @param retrieveFromCache whether to retrieve from the finder cache 2180 * @return the matching group, or <code>null</code> if a matching group could not be found 2181 */ 2182 public static Group fetchByC_L_GK(long companyId, long liveGroupId, 2183 java.lang.String groupKey, boolean retrieveFromCache) { 2184 return getPersistence() 2185 .fetchByC_L_GK(companyId, liveGroupId, groupKey, 2186 retrieveFromCache); 2187 } 2188 2189 /** 2190 * Removes the group where companyId = ? and liveGroupId = ? and groupKey = ? from the database. 2191 * 2192 * @param companyId the company ID 2193 * @param liveGroupId the live group ID 2194 * @param groupKey the group key 2195 * @return the group that was removed 2196 */ 2197 public static Group removeByC_L_GK(long companyId, long liveGroupId, 2198 java.lang.String groupKey) 2199 throws com.liferay.portal.NoSuchGroupException { 2200 return getPersistence().removeByC_L_GK(companyId, liveGroupId, groupKey); 2201 } 2202 2203 /** 2204 * Returns the number of groups where companyId = ? and liveGroupId = ? and groupKey = ?. 2205 * 2206 * @param companyId the company ID 2207 * @param liveGroupId the live group ID 2208 * @param groupKey the group key 2209 * @return the number of matching groups 2210 */ 2211 public static int countByC_L_GK(long companyId, long liveGroupId, 2212 java.lang.String groupKey) { 2213 return getPersistence().countByC_L_GK(companyId, liveGroupId, groupKey); 2214 } 2215 2216 /** 2217 * Returns the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? or throws a {@link NoSuchGroupException} if it could not be found. 2218 * 2219 * @param companyId the company ID 2220 * @param classNameId the class name ID 2221 * @param liveGroupId the live group ID 2222 * @param groupKey the group key 2223 * @return the matching group 2224 * @throws NoSuchGroupException if a matching group could not be found 2225 */ 2226 public static Group findByC_C_L_GK(long companyId, long classNameId, 2227 long liveGroupId, java.lang.String groupKey) 2228 throws com.liferay.portal.NoSuchGroupException { 2229 return getPersistence() 2230 .findByC_C_L_GK(companyId, classNameId, liveGroupId, groupKey); 2231 } 2232 2233 /** 2234 * 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. 2235 * 2236 * @param companyId the company ID 2237 * @param classNameId the class name ID 2238 * @param liveGroupId the live group ID 2239 * @param groupKey the group key 2240 * @return the matching group, or <code>null</code> if a matching group could not be found 2241 */ 2242 public static Group fetchByC_C_L_GK(long companyId, long classNameId, 2243 long liveGroupId, java.lang.String groupKey) { 2244 return getPersistence() 2245 .fetchByC_C_L_GK(companyId, classNameId, liveGroupId, 2246 groupKey); 2247 } 2248 2249 /** 2250 * 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. 2251 * 2252 * @param companyId the company ID 2253 * @param classNameId the class name ID 2254 * @param liveGroupId the live group ID 2255 * @param groupKey the group key 2256 * @param retrieveFromCache whether to retrieve from the finder cache 2257 * @return the matching group, or <code>null</code> if a matching group could not be found 2258 */ 2259 public static Group fetchByC_C_L_GK(long companyId, long classNameId, 2260 long liveGroupId, java.lang.String groupKey, boolean retrieveFromCache) { 2261 return getPersistence() 2262 .fetchByC_C_L_GK(companyId, classNameId, liveGroupId, 2263 groupKey, retrieveFromCache); 2264 } 2265 2266 /** 2267 * Removes the group where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ? from the database. 2268 * 2269 * @param companyId the company ID 2270 * @param classNameId the class name ID 2271 * @param liveGroupId the live group ID 2272 * @param groupKey the group key 2273 * @return the group that was removed 2274 */ 2275 public static Group removeByC_C_L_GK(long companyId, long classNameId, 2276 long liveGroupId, java.lang.String groupKey) 2277 throws com.liferay.portal.NoSuchGroupException { 2278 return getPersistence() 2279 .removeByC_C_L_GK(companyId, classNameId, liveGroupId, 2280 groupKey); 2281 } 2282 2283 /** 2284 * Returns the number of groups where companyId = ? and classNameId = ? and liveGroupId = ? and groupKey = ?. 2285 * 2286 * @param companyId the company ID 2287 * @param classNameId the class name ID 2288 * @param liveGroupId the live group ID 2289 * @param groupKey the group key 2290 * @return the number of matching groups 2291 */ 2292 public static int countByC_C_L_GK(long companyId, long classNameId, 2293 long liveGroupId, java.lang.String groupKey) { 2294 return getPersistence() 2295 .countByC_C_L_GK(companyId, classNameId, liveGroupId, 2296 groupKey); 2297 } 2298 2299 /** 2300 * Returns all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2301 * 2302 * @param companyId the company ID 2303 * @param parentGroupId the parent group ID 2304 * @param site the site 2305 * @param inheritContent the inherit content 2306 * @return the matching groups 2307 */ 2308 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2309 boolean site, boolean inheritContent) { 2310 return getPersistence() 2311 .findByC_P_S_I(companyId, parentGroupId, site, inheritContent); 2312 } 2313 2314 /** 2315 * Returns a range of all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2316 * 2317 * <p> 2318 * 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. 2319 * </p> 2320 * 2321 * @param companyId the company ID 2322 * @param parentGroupId the parent group ID 2323 * @param site the site 2324 * @param inheritContent the inherit content 2325 * @param start the lower bound of the range of groups 2326 * @param end the upper bound of the range of groups (not inclusive) 2327 * @return the range of matching groups 2328 */ 2329 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2330 boolean site, boolean inheritContent, int start, int end) { 2331 return getPersistence() 2332 .findByC_P_S_I(companyId, parentGroupId, site, 2333 inheritContent, start, end); 2334 } 2335 2336 /** 2337 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2338 * 2339 * <p> 2340 * 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. 2341 * </p> 2342 * 2343 * @param companyId the company ID 2344 * @param parentGroupId the parent group ID 2345 * @param site the site 2346 * @param inheritContent the inherit content 2347 * @param start the lower bound of the range of groups 2348 * @param end the upper bound of the range of groups (not inclusive) 2349 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2350 * @return the ordered range of matching groups 2351 */ 2352 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2353 boolean site, boolean inheritContent, int start, int end, 2354 OrderByComparator<Group> orderByComparator) { 2355 return getPersistence() 2356 .findByC_P_S_I(companyId, parentGroupId, site, 2357 inheritContent, start, end, orderByComparator); 2358 } 2359 2360 /** 2361 * Returns an ordered range of all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2362 * 2363 * <p> 2364 * 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. 2365 * </p> 2366 * 2367 * @param companyId the company ID 2368 * @param parentGroupId the parent group ID 2369 * @param site the site 2370 * @param inheritContent the inherit content 2371 * @param start the lower bound of the range of groups 2372 * @param end the upper bound of the range of groups (not inclusive) 2373 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2374 * @param retrieveFromCache whether to retrieve from the finder cache 2375 * @return the ordered range of matching groups 2376 */ 2377 public static List<Group> findByC_P_S_I(long companyId, long parentGroupId, 2378 boolean site, boolean inheritContent, int start, int end, 2379 OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) { 2380 return getPersistence() 2381 .findByC_P_S_I(companyId, parentGroupId, site, 2382 inheritContent, start, end, orderByComparator, retrieveFromCache); 2383 } 2384 2385 /** 2386 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2387 * 2388 * @param companyId the company ID 2389 * @param parentGroupId the parent group ID 2390 * @param site the site 2391 * @param inheritContent the inherit content 2392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2393 * @return the first matching group 2394 * @throws NoSuchGroupException if a matching group could not be found 2395 */ 2396 public static Group findByC_P_S_I_First(long companyId, long parentGroupId, 2397 boolean site, boolean inheritContent, 2398 OrderByComparator<Group> orderByComparator) 2399 throws com.liferay.portal.NoSuchGroupException { 2400 return getPersistence() 2401 .findByC_P_S_I_First(companyId, parentGroupId, site, 2402 inheritContent, orderByComparator); 2403 } 2404 2405 /** 2406 * Returns the first group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2407 * 2408 * @param companyId the company ID 2409 * @param parentGroupId the parent group ID 2410 * @param site the site 2411 * @param inheritContent the inherit content 2412 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2413 * @return the first matching group, or <code>null</code> if a matching group could not be found 2414 */ 2415 public static Group fetchByC_P_S_I_First(long companyId, 2416 long parentGroupId, boolean site, boolean inheritContent, 2417 OrderByComparator<Group> orderByComparator) { 2418 return getPersistence() 2419 .fetchByC_P_S_I_First(companyId, parentGroupId, site, 2420 inheritContent, orderByComparator); 2421 } 2422 2423 /** 2424 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2425 * 2426 * @param companyId the company ID 2427 * @param parentGroupId the parent group ID 2428 * @param site the site 2429 * @param inheritContent the inherit content 2430 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2431 * @return the last matching group 2432 * @throws NoSuchGroupException if a matching group could not be found 2433 */ 2434 public static Group findByC_P_S_I_Last(long companyId, long parentGroupId, 2435 boolean site, boolean inheritContent, 2436 OrderByComparator<Group> orderByComparator) 2437 throws com.liferay.portal.NoSuchGroupException { 2438 return getPersistence() 2439 .findByC_P_S_I_Last(companyId, parentGroupId, site, 2440 inheritContent, orderByComparator); 2441 } 2442 2443 /** 2444 * Returns the last group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2445 * 2446 * @param companyId the company ID 2447 * @param parentGroupId the parent group ID 2448 * @param site the site 2449 * @param inheritContent the inherit content 2450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2451 * @return the last matching group, or <code>null</code> if a matching group could not be found 2452 */ 2453 public static Group fetchByC_P_S_I_Last(long companyId, long parentGroupId, 2454 boolean site, boolean inheritContent, 2455 OrderByComparator<Group> orderByComparator) { 2456 return getPersistence() 2457 .fetchByC_P_S_I_Last(companyId, parentGroupId, site, 2458 inheritContent, orderByComparator); 2459 } 2460 2461 /** 2462 * Returns the groups before and after the current group in the ordered set where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2463 * 2464 * @param groupId the primary key of the current group 2465 * @param companyId the company ID 2466 * @param parentGroupId the parent group ID 2467 * @param site the site 2468 * @param inheritContent the inherit content 2469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2470 * @return the previous, current, and next group 2471 * @throws NoSuchGroupException if a group with the primary key could not be found 2472 */ 2473 public static Group[] findByC_P_S_I_PrevAndNext(long groupId, 2474 long companyId, long parentGroupId, boolean site, 2475 boolean inheritContent, OrderByComparator<Group> orderByComparator) 2476 throws com.liferay.portal.NoSuchGroupException { 2477 return getPersistence() 2478 .findByC_P_S_I_PrevAndNext(groupId, companyId, 2479 parentGroupId, site, inheritContent, orderByComparator); 2480 } 2481 2482 /** 2483 * Removes all the groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ? from the database. 2484 * 2485 * @param companyId the company ID 2486 * @param parentGroupId the parent group ID 2487 * @param site the site 2488 * @param inheritContent the inherit content 2489 */ 2490 public static void removeByC_P_S_I(long companyId, long parentGroupId, 2491 boolean site, boolean inheritContent) { 2492 getPersistence() 2493 .removeByC_P_S_I(companyId, parentGroupId, site, inheritContent); 2494 } 2495 2496 /** 2497 * Returns the number of groups where companyId = ? and parentGroupId = ? and site = ? and inheritContent = ?. 2498 * 2499 * @param companyId the company ID 2500 * @param parentGroupId the parent group ID 2501 * @param site the site 2502 * @param inheritContent the inherit content 2503 * @return the number of matching groups 2504 */ 2505 public static int countByC_P_S_I(long companyId, long parentGroupId, 2506 boolean site, boolean inheritContent) { 2507 return getPersistence() 2508 .countByC_P_S_I(companyId, parentGroupId, site, 2509 inheritContent); 2510 } 2511 2512 /** 2513 * Caches the group in the entity cache if it is enabled. 2514 * 2515 * @param group the group 2516 */ 2517 public static void cacheResult(Group group) { 2518 getPersistence().cacheResult(group); 2519 } 2520 2521 /** 2522 * Caches the groups in the entity cache if it is enabled. 2523 * 2524 * @param groups the groups 2525 */ 2526 public static void cacheResult(List<Group> groups) { 2527 getPersistence().cacheResult(groups); 2528 } 2529 2530 /** 2531 * Creates a new group with the primary key. Does not add the group to the database. 2532 * 2533 * @param groupId the primary key for the new group 2534 * @return the new group 2535 */ 2536 public static Group create(long groupId) { 2537 return getPersistence().create(groupId); 2538 } 2539 2540 /** 2541 * Removes the group with the primary key from the database. Also notifies the appropriate model listeners. 2542 * 2543 * @param groupId the primary key of the group 2544 * @return the group that was removed 2545 * @throws NoSuchGroupException if a group with the primary key could not be found 2546 */ 2547 public static Group remove(long groupId) 2548 throws com.liferay.portal.NoSuchGroupException { 2549 return getPersistence().remove(groupId); 2550 } 2551 2552 public static Group updateImpl(Group group) { 2553 return getPersistence().updateImpl(group); 2554 } 2555 2556 /** 2557 * Returns the group with the primary key or throws a {@link NoSuchGroupException} if it could not be found. 2558 * 2559 * @param groupId the primary key of the group 2560 * @return the group 2561 * @throws NoSuchGroupException if a group with the primary key could not be found 2562 */ 2563 public static Group findByPrimaryKey(long groupId) 2564 throws com.liferay.portal.NoSuchGroupException { 2565 return getPersistence().findByPrimaryKey(groupId); 2566 } 2567 2568 /** 2569 * Returns the group with the primary key or returns <code>null</code> if it could not be found. 2570 * 2571 * @param groupId the primary key of the group 2572 * @return the group, or <code>null</code> if a group with the primary key could not be found 2573 */ 2574 public static Group fetchByPrimaryKey(long groupId) { 2575 return getPersistence().fetchByPrimaryKey(groupId); 2576 } 2577 2578 public static java.util.Map<java.io.Serializable, Group> fetchByPrimaryKeys( 2579 java.util.Set<java.io.Serializable> primaryKeys) { 2580 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2581 } 2582 2583 /** 2584 * Returns all the groups. 2585 * 2586 * @return the groups 2587 */ 2588 public static List<Group> findAll() { 2589 return getPersistence().findAll(); 2590 } 2591 2592 /** 2593 * Returns a range of all the groups. 2594 * 2595 * <p> 2596 * 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. 2597 * </p> 2598 * 2599 * @param start the lower bound of the range of groups 2600 * @param end the upper bound of the range of groups (not inclusive) 2601 * @return the range of groups 2602 */ 2603 public static List<Group> findAll(int start, int end) { 2604 return getPersistence().findAll(start, end); 2605 } 2606 2607 /** 2608 * Returns an ordered range of all the groups. 2609 * 2610 * <p> 2611 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 2612 * </p> 2613 * 2614 * @param start the lower bound of the range of groups 2615 * @param end the upper bound of the range of groups (not inclusive) 2616 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2617 * @return the ordered range of groups 2618 */ 2619 public static List<Group> findAll(int start, int end, 2620 OrderByComparator<Group> orderByComparator) { 2621 return getPersistence().findAll(start, end, orderByComparator); 2622 } 2623 2624 /** 2625 * Returns an ordered range of all the groups. 2626 * 2627 * <p> 2628 * 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. 2629 * </p> 2630 * 2631 * @param start the lower bound of the range of groups 2632 * @param end the upper bound of the range of groups (not inclusive) 2633 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2634 * @param retrieveFromCache whether to retrieve from the finder cache 2635 * @return the ordered range of groups 2636 */ 2637 public static List<Group> findAll(int start, int end, 2638 OrderByComparator<Group> orderByComparator, boolean retrieveFromCache) { 2639 return getPersistence() 2640 .findAll(start, end, orderByComparator, retrieveFromCache); 2641 } 2642 2643 /** 2644 * Removes all the groups from the database. 2645 */ 2646 public static void removeAll() { 2647 getPersistence().removeAll(); 2648 } 2649 2650 /** 2651 * Returns the number of groups. 2652 * 2653 * @return the number of groups 2654 */ 2655 public static int countAll() { 2656 return getPersistence().countAll(); 2657 } 2658 2659 /** 2660 * Returns the primaryKeys of organizations associated with the group. 2661 * 2662 * @param pk the primary key of the group 2663 * @return long[] of the primaryKeys of organizations associated with the group 2664 */ 2665 public static long[] getOrganizationPrimaryKeys(long pk) { 2666 return getPersistence().getOrganizationPrimaryKeys(pk); 2667 } 2668 2669 /** 2670 * Returns all the organizations associated with the group. 2671 * 2672 * @param pk the primary key of the group 2673 * @return the organizations associated with the group 2674 */ 2675 public static List<com.liferay.portal.model.Organization> getOrganizations( 2676 long pk) { 2677 return getPersistence().getOrganizations(pk); 2678 } 2679 2680 /** 2681 * Returns a range of all the organizations associated with the group. 2682 * 2683 * <p> 2684 * 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. 2685 * </p> 2686 * 2687 * @param pk the primary key of the group 2688 * @param start the lower bound of the range of groups 2689 * @param end the upper bound of the range of groups (not inclusive) 2690 * @return the range of organizations associated with the group 2691 */ 2692 public static List<com.liferay.portal.model.Organization> getOrganizations( 2693 long pk, int start, int end) { 2694 return getPersistence().getOrganizations(pk, start, end); 2695 } 2696 2697 /** 2698 * Returns an ordered range of all the organizations associated with the group. 2699 * 2700 * <p> 2701 * 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. 2702 * </p> 2703 * 2704 * @param pk the primary key of the group 2705 * @param start the lower bound of the range of groups 2706 * @param end the upper bound of the range of groups (not inclusive) 2707 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2708 * @return the ordered range of organizations associated with the group 2709 */ 2710 public static List<com.liferay.portal.model.Organization> getOrganizations( 2711 long pk, int start, int end, 2712 OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) { 2713 return getPersistence() 2714 .getOrganizations(pk, start, end, orderByComparator); 2715 } 2716 2717 /** 2718 * Returns the number of organizations associated with the group. 2719 * 2720 * @param pk the primary key of the group 2721 * @return the number of organizations associated with the group 2722 */ 2723 public static int getOrganizationsSize(long pk) { 2724 return getPersistence().getOrganizationsSize(pk); 2725 } 2726 2727 /** 2728 * Returns <code>true</code> if the organization is associated with the group. 2729 * 2730 * @param pk the primary key of the group 2731 * @param organizationPK the primary key of the organization 2732 * @return <code>true</code> if the organization is associated with the group; <code>false</code> otherwise 2733 */ 2734 public static boolean containsOrganization(long pk, long organizationPK) { 2735 return getPersistence().containsOrganization(pk, organizationPK); 2736 } 2737 2738 /** 2739 * Returns <code>true</code> if the group has any organizations associated with it. 2740 * 2741 * @param pk the primary key of the group to check for associations with organizations 2742 * @return <code>true</code> if the group has any organizations associated with it; <code>false</code> otherwise 2743 */ 2744 public static boolean containsOrganizations(long pk) { 2745 return getPersistence().containsOrganizations(pk); 2746 } 2747 2748 /** 2749 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2750 * 2751 * @param pk the primary key of the group 2752 * @param organizationPK the primary key of the organization 2753 */ 2754 public static void addOrganization(long pk, long organizationPK) { 2755 getPersistence().addOrganization(pk, organizationPK); 2756 } 2757 2758 /** 2759 * Adds an association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2760 * 2761 * @param pk the primary key of the group 2762 * @param organization the organization 2763 */ 2764 public static void addOrganization(long pk, 2765 com.liferay.portal.model.Organization organization) { 2766 getPersistence().addOrganization(pk, organization); 2767 } 2768 2769 /** 2770 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2771 * 2772 * @param pk the primary key of the group 2773 * @param organizationPKs the primary keys of the organizations 2774 */ 2775 public static void addOrganizations(long pk, long[] organizationPKs) { 2776 getPersistence().addOrganizations(pk, organizationPKs); 2777 } 2778 2779 /** 2780 * Adds an association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2781 * 2782 * @param pk the primary key of the group 2783 * @param organizations the organizations 2784 */ 2785 public static void addOrganizations(long pk, 2786 List<com.liferay.portal.model.Organization> organizations) { 2787 getPersistence().addOrganizations(pk, organizations); 2788 } 2789 2790 /** 2791 * Clears all associations between the group and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2792 * 2793 * @param pk the primary key of the group to clear the associated organizations from 2794 */ 2795 public static void clearOrganizations(long pk) { 2796 getPersistence().clearOrganizations(pk); 2797 } 2798 2799 /** 2800 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2801 * 2802 * @param pk the primary key of the group 2803 * @param organizationPK the primary key of the organization 2804 */ 2805 public static void removeOrganization(long pk, long organizationPK) { 2806 getPersistence().removeOrganization(pk, organizationPK); 2807 } 2808 2809 /** 2810 * Removes the association between the group and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2811 * 2812 * @param pk the primary key of the group 2813 * @param organization the organization 2814 */ 2815 public static void removeOrganization(long pk, 2816 com.liferay.portal.model.Organization organization) { 2817 getPersistence().removeOrganization(pk, organization); 2818 } 2819 2820 /** 2821 * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2822 * 2823 * @param pk the primary key of the group 2824 * @param organizationPKs the primary keys of the organizations 2825 */ 2826 public static void removeOrganizations(long pk, long[] organizationPKs) { 2827 getPersistence().removeOrganizations(pk, organizationPKs); 2828 } 2829 2830 /** 2831 * Removes the association between the group and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2832 * 2833 * @param pk the primary key of the group 2834 * @param organizations the organizations 2835 */ 2836 public static void removeOrganizations(long pk, 2837 List<com.liferay.portal.model.Organization> organizations) { 2838 getPersistence().removeOrganizations(pk, organizations); 2839 } 2840 2841 /** 2842 * 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. 2843 * 2844 * @param pk the primary key of the group 2845 * @param organizationPKs the primary keys of the organizations to be associated with the group 2846 */ 2847 public static void setOrganizations(long pk, long[] organizationPKs) { 2848 getPersistence().setOrganizations(pk, organizationPKs); 2849 } 2850 2851 /** 2852 * 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. 2853 * 2854 * @param pk the primary key of the group 2855 * @param organizations the organizations to be associated with the group 2856 */ 2857 public static void setOrganizations(long pk, 2858 List<com.liferay.portal.model.Organization> organizations) { 2859 getPersistence().setOrganizations(pk, organizations); 2860 } 2861 2862 /** 2863 * Returns the primaryKeys of roles associated with the group. 2864 * 2865 * @param pk the primary key of the group 2866 * @return long[] of the primaryKeys of roles associated with the group 2867 */ 2868 public static long[] getRolePrimaryKeys(long pk) { 2869 return getPersistence().getRolePrimaryKeys(pk); 2870 } 2871 2872 /** 2873 * Returns all the roles associated with the group. 2874 * 2875 * @param pk the primary key of the group 2876 * @return the roles associated with the group 2877 */ 2878 public static List<com.liferay.portal.model.Role> getRoles(long pk) { 2879 return getPersistence().getRoles(pk); 2880 } 2881 2882 /** 2883 * Returns a range of all the roles associated with the group. 2884 * 2885 * <p> 2886 * 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. 2887 * </p> 2888 * 2889 * @param pk the primary key of the group 2890 * @param start the lower bound of the range of groups 2891 * @param end the upper bound of the range of groups (not inclusive) 2892 * @return the range of roles associated with the group 2893 */ 2894 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2895 int start, int end) { 2896 return getPersistence().getRoles(pk, start, end); 2897 } 2898 2899 /** 2900 * Returns an ordered range of all the roles associated with the group. 2901 * 2902 * <p> 2903 * 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. 2904 * </p> 2905 * 2906 * @param pk the primary key of the group 2907 * @param start the lower bound of the range of groups 2908 * @param end the upper bound of the range of groups (not inclusive) 2909 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2910 * @return the ordered range of roles associated with the group 2911 */ 2912 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2913 int start, int end, 2914 OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 2915 return getPersistence().getRoles(pk, start, end, orderByComparator); 2916 } 2917 2918 /** 2919 * Returns the number of roles associated with the group. 2920 * 2921 * @param pk the primary key of the group 2922 * @return the number of roles associated with the group 2923 */ 2924 public static int getRolesSize(long pk) { 2925 return getPersistence().getRolesSize(pk); 2926 } 2927 2928 /** 2929 * Returns <code>true</code> if the role is associated with the group. 2930 * 2931 * @param pk the primary key of the group 2932 * @param rolePK the primary key of the role 2933 * @return <code>true</code> if the role is associated with the group; <code>false</code> otherwise 2934 */ 2935 public static boolean containsRole(long pk, long rolePK) { 2936 return getPersistence().containsRole(pk, rolePK); 2937 } 2938 2939 /** 2940 * Returns <code>true</code> if the group has any roles associated with it. 2941 * 2942 * @param pk the primary key of the group to check for associations with roles 2943 * @return <code>true</code> if the group has any roles associated with it; <code>false</code> otherwise 2944 */ 2945 public static boolean containsRoles(long pk) { 2946 return getPersistence().containsRoles(pk); 2947 } 2948 2949 /** 2950 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2951 * 2952 * @param pk the primary key of the group 2953 * @param rolePK the primary key of the role 2954 */ 2955 public static void addRole(long pk, long rolePK) { 2956 getPersistence().addRole(pk, rolePK); 2957 } 2958 2959 /** 2960 * Adds an association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2961 * 2962 * @param pk the primary key of the group 2963 * @param role the role 2964 */ 2965 public static void addRole(long pk, com.liferay.portal.model.Role role) { 2966 getPersistence().addRole(pk, role); 2967 } 2968 2969 /** 2970 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2971 * 2972 * @param pk the primary key of the group 2973 * @param rolePKs the primary keys of the roles 2974 */ 2975 public static void addRoles(long pk, long[] rolePKs) { 2976 getPersistence().addRoles(pk, rolePKs); 2977 } 2978 2979 /** 2980 * Adds an association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2981 * 2982 * @param pk the primary key of the group 2983 * @param roles the roles 2984 */ 2985 public static void addRoles(long pk, 2986 List<com.liferay.portal.model.Role> roles) { 2987 getPersistence().addRoles(pk, roles); 2988 } 2989 2990 /** 2991 * Clears all associations between the group and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2992 * 2993 * @param pk the primary key of the group to clear the associated roles from 2994 */ 2995 public static void clearRoles(long pk) { 2996 getPersistence().clearRoles(pk); 2997 } 2998 2999 /** 3000 * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3001 * 3002 * @param pk the primary key of the group 3003 * @param rolePK the primary key of the role 3004 */ 3005 public static void removeRole(long pk, long rolePK) { 3006 getPersistence().removeRole(pk, rolePK); 3007 } 3008 3009 /** 3010 * Removes the association between the group and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3011 * 3012 * @param pk the primary key of the group 3013 * @param role the role 3014 */ 3015 public static void removeRole(long pk, com.liferay.portal.model.Role role) { 3016 getPersistence().removeRole(pk, role); 3017 } 3018 3019 /** 3020 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3021 * 3022 * @param pk the primary key of the group 3023 * @param rolePKs the primary keys of the roles 3024 */ 3025 public static void removeRoles(long pk, long[] rolePKs) { 3026 getPersistence().removeRoles(pk, rolePKs); 3027 } 3028 3029 /** 3030 * Removes the association between the group and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3031 * 3032 * @param pk the primary key of the group 3033 * @param roles the roles 3034 */ 3035 public static void removeRoles(long pk, 3036 List<com.liferay.portal.model.Role> roles) { 3037 getPersistence().removeRoles(pk, roles); 3038 } 3039 3040 /** 3041 * 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. 3042 * 3043 * @param pk the primary key of the group 3044 * @param rolePKs the primary keys of the roles to be associated with the group 3045 */ 3046 public static void setRoles(long pk, long[] rolePKs) { 3047 getPersistence().setRoles(pk, rolePKs); 3048 } 3049 3050 /** 3051 * 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. 3052 * 3053 * @param pk the primary key of the group 3054 * @param roles the roles to be associated with the group 3055 */ 3056 public static void setRoles(long pk, 3057 List<com.liferay.portal.model.Role> roles) { 3058 getPersistence().setRoles(pk, roles); 3059 } 3060 3061 /** 3062 * Returns the primaryKeys of user groups associated with the group. 3063 * 3064 * @param pk the primary key of the group 3065 * @return long[] of the primaryKeys of user groups associated with the group 3066 */ 3067 public static long[] getUserGroupPrimaryKeys(long pk) { 3068 return getPersistence().getUserGroupPrimaryKeys(pk); 3069 } 3070 3071 /** 3072 * Returns all the user groups associated with the group. 3073 * 3074 * @param pk the primary key of the group 3075 * @return the user groups associated with the group 3076 */ 3077 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3078 long pk) { 3079 return getPersistence().getUserGroups(pk); 3080 } 3081 3082 /** 3083 * Returns a range of all the user groups associated with the group. 3084 * 3085 * <p> 3086 * 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. 3087 * </p> 3088 * 3089 * @param pk the primary key of the group 3090 * @param start the lower bound of the range of groups 3091 * @param end the upper bound of the range of groups (not inclusive) 3092 * @return the range of user groups associated with the group 3093 */ 3094 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3095 long pk, int start, int end) { 3096 return getPersistence().getUserGroups(pk, start, end); 3097 } 3098 3099 /** 3100 * Returns an ordered range of all the user groups associated with the group. 3101 * 3102 * <p> 3103 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3104 * </p> 3105 * 3106 * @param pk the primary key of the group 3107 * @param start the lower bound of the range of groups 3108 * @param end the upper bound of the range of groups (not inclusive) 3109 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3110 * @return the ordered range of user groups associated with the group 3111 */ 3112 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3113 long pk, int start, int end, 3114 OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) { 3115 return getPersistence().getUserGroups(pk, start, end, orderByComparator); 3116 } 3117 3118 /** 3119 * Returns the number of user groups associated with the group. 3120 * 3121 * @param pk the primary key of the group 3122 * @return the number of user groups associated with the group 3123 */ 3124 public static int getUserGroupsSize(long pk) { 3125 return getPersistence().getUserGroupsSize(pk); 3126 } 3127 3128 /** 3129 * Returns <code>true</code> if the user group is associated with the group. 3130 * 3131 * @param pk the primary key of the group 3132 * @param userGroupPK the primary key of the user group 3133 * @return <code>true</code> if the user group is associated with the group; <code>false</code> otherwise 3134 */ 3135 public static boolean containsUserGroup(long pk, long userGroupPK) { 3136 return getPersistence().containsUserGroup(pk, userGroupPK); 3137 } 3138 3139 /** 3140 * Returns <code>true</code> if the group has any user groups associated with it. 3141 * 3142 * @param pk the primary key of the group to check for associations with user groups 3143 * @return <code>true</code> if the group has any user groups associated with it; <code>false</code> otherwise 3144 */ 3145 public static boolean containsUserGroups(long pk) { 3146 return getPersistence().containsUserGroups(pk); 3147 } 3148 3149 /** 3150 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3151 * 3152 * @param pk the primary key of the group 3153 * @param userGroupPK the primary key of the user group 3154 */ 3155 public static void addUserGroup(long pk, long userGroupPK) { 3156 getPersistence().addUserGroup(pk, userGroupPK); 3157 } 3158 3159 /** 3160 * Adds an association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3161 * 3162 * @param pk the primary key of the group 3163 * @param userGroup the user group 3164 */ 3165 public static void addUserGroup(long pk, 3166 com.liferay.portal.model.UserGroup userGroup) { 3167 getPersistence().addUserGroup(pk, userGroup); 3168 } 3169 3170 /** 3171 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3172 * 3173 * @param pk the primary key of the group 3174 * @param userGroupPKs the primary keys of the user groups 3175 */ 3176 public static void addUserGroups(long pk, long[] userGroupPKs) { 3177 getPersistence().addUserGroups(pk, userGroupPKs); 3178 } 3179 3180 /** 3181 * Adds an association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3182 * 3183 * @param pk the primary key of the group 3184 * @param userGroups the user groups 3185 */ 3186 public static void addUserGroups(long pk, 3187 List<com.liferay.portal.model.UserGroup> userGroups) { 3188 getPersistence().addUserGroups(pk, userGroups); 3189 } 3190 3191 /** 3192 * Clears all associations between the group and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3193 * 3194 * @param pk the primary key of the group to clear the associated user groups from 3195 */ 3196 public static void clearUserGroups(long pk) { 3197 getPersistence().clearUserGroups(pk); 3198 } 3199 3200 /** 3201 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3202 * 3203 * @param pk the primary key of the group 3204 * @param userGroupPK the primary key of the user group 3205 */ 3206 public static void removeUserGroup(long pk, long userGroupPK) { 3207 getPersistence().removeUserGroup(pk, userGroupPK); 3208 } 3209 3210 /** 3211 * Removes the association between the group and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3212 * 3213 * @param pk the primary key of the group 3214 * @param userGroup the user group 3215 */ 3216 public static void removeUserGroup(long pk, 3217 com.liferay.portal.model.UserGroup userGroup) { 3218 getPersistence().removeUserGroup(pk, userGroup); 3219 } 3220 3221 /** 3222 * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3223 * 3224 * @param pk the primary key of the group 3225 * @param userGroupPKs the primary keys of the user groups 3226 */ 3227 public static void removeUserGroups(long pk, long[] userGroupPKs) { 3228 getPersistence().removeUserGroups(pk, userGroupPKs); 3229 } 3230 3231 /** 3232 * Removes the association between the group and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3233 * 3234 * @param pk the primary key of the group 3235 * @param userGroups the user groups 3236 */ 3237 public static void removeUserGroups(long pk, 3238 List<com.liferay.portal.model.UserGroup> userGroups) { 3239 getPersistence().removeUserGroups(pk, userGroups); 3240 } 3241 3242 /** 3243 * 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. 3244 * 3245 * @param pk the primary key of the group 3246 * @param userGroupPKs the primary keys of the user groups to be associated with the group 3247 */ 3248 public static void setUserGroups(long pk, long[] userGroupPKs) { 3249 getPersistence().setUserGroups(pk, userGroupPKs); 3250 } 3251 3252 /** 3253 * 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. 3254 * 3255 * @param pk the primary key of the group 3256 * @param userGroups the user groups to be associated with the group 3257 */ 3258 public static void setUserGroups(long pk, 3259 List<com.liferay.portal.model.UserGroup> userGroups) { 3260 getPersistence().setUserGroups(pk, userGroups); 3261 } 3262 3263 /** 3264 * Returns the primaryKeys of users associated with the group. 3265 * 3266 * @param pk the primary key of the group 3267 * @return long[] of the primaryKeys of users associated with the group 3268 */ 3269 public static long[] getUserPrimaryKeys(long pk) { 3270 return getPersistence().getUserPrimaryKeys(pk); 3271 } 3272 3273 /** 3274 * Returns all the users associated with the group. 3275 * 3276 * @param pk the primary key of the group 3277 * @return the users associated with the group 3278 */ 3279 public static List<com.liferay.portal.model.User> getUsers(long pk) { 3280 return getPersistence().getUsers(pk); 3281 } 3282 3283 /** 3284 * Returns a range of all the users associated with the group. 3285 * 3286 * <p> 3287 * 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. 3288 * </p> 3289 * 3290 * @param pk the primary key of the group 3291 * @param start the lower bound of the range of groups 3292 * @param end the upper bound of the range of groups (not inclusive) 3293 * @return the range of users associated with the group 3294 */ 3295 public static List<com.liferay.portal.model.User> getUsers(long pk, 3296 int start, int end) { 3297 return getPersistence().getUsers(pk, start, end); 3298 } 3299 3300 /** 3301 * Returns an ordered range of all the users associated with the group. 3302 * 3303 * <p> 3304 * 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. 3305 * </p> 3306 * 3307 * @param pk the primary key of the group 3308 * @param start the lower bound of the range of groups 3309 * @param end the upper bound of the range of groups (not inclusive) 3310 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3311 * @return the ordered range of users associated with the group 3312 */ 3313 public static List<com.liferay.portal.model.User> getUsers(long pk, 3314 int start, int end, 3315 OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 3316 return getPersistence().getUsers(pk, start, end, orderByComparator); 3317 } 3318 3319 /** 3320 * Returns the number of users associated with the group. 3321 * 3322 * @param pk the primary key of the group 3323 * @return the number of users associated with the group 3324 */ 3325 public static int getUsersSize(long pk) { 3326 return getPersistence().getUsersSize(pk); 3327 } 3328 3329 /** 3330 * Returns <code>true</code> if the user is associated with the group. 3331 * 3332 * @param pk the primary key of the group 3333 * @param userPK the primary key of the user 3334 * @return <code>true</code> if the user is associated with the group; <code>false</code> otherwise 3335 */ 3336 public static boolean containsUser(long pk, long userPK) { 3337 return getPersistence().containsUser(pk, userPK); 3338 } 3339 3340 /** 3341 * Returns <code>true</code> if the group has any users associated with it. 3342 * 3343 * @param pk the primary key of the group to check for associations with users 3344 * @return <code>true</code> if the group has any users associated with it; <code>false</code> otherwise 3345 */ 3346 public static boolean containsUsers(long pk) { 3347 return getPersistence().containsUsers(pk); 3348 } 3349 3350 /** 3351 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3352 * 3353 * @param pk the primary key of the group 3354 * @param userPK the primary key of the user 3355 */ 3356 public static void addUser(long pk, long userPK) { 3357 getPersistence().addUser(pk, userPK); 3358 } 3359 3360 /** 3361 * Adds an association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3362 * 3363 * @param pk the primary key of the group 3364 * @param user the user 3365 */ 3366 public static void addUser(long pk, com.liferay.portal.model.User user) { 3367 getPersistence().addUser(pk, user); 3368 } 3369 3370 /** 3371 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3372 * 3373 * @param pk the primary key of the group 3374 * @param userPKs the primary keys of the users 3375 */ 3376 public static void addUsers(long pk, long[] userPKs) { 3377 getPersistence().addUsers(pk, userPKs); 3378 } 3379 3380 /** 3381 * Adds an association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3382 * 3383 * @param pk the primary key of the group 3384 * @param users the users 3385 */ 3386 public static void addUsers(long pk, 3387 List<com.liferay.portal.model.User> users) { 3388 getPersistence().addUsers(pk, users); 3389 } 3390 3391 /** 3392 * Clears all associations between the group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3393 * 3394 * @param pk the primary key of the group to clear the associated users from 3395 */ 3396 public static void clearUsers(long pk) { 3397 getPersistence().clearUsers(pk); 3398 } 3399 3400 /** 3401 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3402 * 3403 * @param pk the primary key of the group 3404 * @param userPK the primary key of the user 3405 */ 3406 public static void removeUser(long pk, long userPK) { 3407 getPersistence().removeUser(pk, userPK); 3408 } 3409 3410 /** 3411 * Removes the association between the group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3412 * 3413 * @param pk the primary key of the group 3414 * @param user the user 3415 */ 3416 public static void removeUser(long pk, com.liferay.portal.model.User user) { 3417 getPersistence().removeUser(pk, user); 3418 } 3419 3420 /** 3421 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3422 * 3423 * @param pk the primary key of the group 3424 * @param userPKs the primary keys of the users 3425 */ 3426 public static void removeUsers(long pk, long[] userPKs) { 3427 getPersistence().removeUsers(pk, userPKs); 3428 } 3429 3430 /** 3431 * Removes the association between the group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3432 * 3433 * @param pk the primary key of the group 3434 * @param users the users 3435 */ 3436 public static void removeUsers(long pk, 3437 List<com.liferay.portal.model.User> users) { 3438 getPersistence().removeUsers(pk, users); 3439 } 3440 3441 /** 3442 * 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. 3443 * 3444 * @param pk the primary key of the group 3445 * @param userPKs the primary keys of the users to be associated with the group 3446 */ 3447 public static void setUsers(long pk, long[] userPKs) { 3448 getPersistence().setUsers(pk, userPKs); 3449 } 3450 3451 /** 3452 * 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. 3453 * 3454 * @param pk the primary key of the group 3455 * @param users the users to be associated with the group 3456 */ 3457 public static void setUsers(long pk, 3458 List<com.liferay.portal.model.User> users) { 3459 getPersistence().setUsers(pk, users); 3460 } 3461 3462 public static java.util.Set<java.lang.String> getBadColumnNames() { 3463 return getPersistence().getBadColumnNames(); 3464 } 3465 3466 public static GroupPersistence getPersistence() { 3467 if (_persistence == null) { 3468 _persistence = (GroupPersistence)PortalBeanLocatorUtil.locate(GroupPersistence.class.getName()); 3469 3470 ReferenceRegistry.registerReference(GroupUtil.class, "_persistence"); 3471 } 3472 3473 return _persistence; 3474 } 3475 3476 /** 3477 * @deprecated As of 6.2.0 3478 */ 3479 @Deprecated 3480 public void setPersistence(GroupPersistence persistence) { 3481 } 3482 3483 private static GroupPersistence _persistence; 3484 }