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