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