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