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