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.portlet.social.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.service.ServiceContext; 024 025 import com.liferay.portlet.social.model.SocialActivitySet; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the social activity set service. This utility wraps {@link com.liferay.portlet.social.service.persistence.impl.SocialActivitySetPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see SocialActivitySetPersistence 038 * @see com.liferay.portlet.social.service.persistence.impl.SocialActivitySetPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class SocialActivitySetUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(SocialActivitySet socialActivitySet) { 060 getPersistence().clearCache(socialActivitySet); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<SocialActivitySet> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<SocialActivitySet> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<SocialActivitySet> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<SocialActivitySet> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static SocialActivitySet update(SocialActivitySet socialActivitySet) { 101 return getPersistence().update(socialActivitySet); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static SocialActivitySet update( 108 SocialActivitySet socialActivitySet, ServiceContext serviceContext) { 109 return getPersistence().update(socialActivitySet, serviceContext); 110 } 111 112 /** 113 * Returns all the social activity sets where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching social activity sets 117 */ 118 public static List<SocialActivitySet> findByGroupId(long groupId) { 119 return getPersistence().findByGroupId(groupId); 120 } 121 122 /** 123 * Returns a range of all the social activity sets where groupId = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 127 * </p> 128 * 129 * @param groupId the group ID 130 * @param start the lower bound of the range of social activity sets 131 * @param end the upper bound of the range of social activity sets (not inclusive) 132 * @return the range of matching social activity sets 133 */ 134 public static List<SocialActivitySet> findByGroupId(long groupId, 135 int start, int end) { 136 return getPersistence().findByGroupId(groupId, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the social activity sets where groupId = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 144 * </p> 145 * 146 * @param groupId the group ID 147 * @param start the lower bound of the range of social activity sets 148 * @param end the upper bound of the range of social activity sets (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching social activity sets 151 */ 152 public static List<SocialActivitySet> findByGroupId(long groupId, 153 int start, int end, 154 OrderByComparator<SocialActivitySet> orderByComparator) { 155 return getPersistence() 156 .findByGroupId(groupId, start, end, orderByComparator); 157 } 158 159 /** 160 * Returns an ordered range of all the social activity sets where groupId = ?. 161 * 162 * <p> 163 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 164 * </p> 165 * 166 * @param groupId the group ID 167 * @param start the lower bound of the range of social activity sets 168 * @param end the upper bound of the range of social activity sets (not inclusive) 169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 170 * @param retrieveFromCache whether to retrieve from the finder cache 171 * @return the ordered range of matching social activity sets 172 */ 173 public static List<SocialActivitySet> findByGroupId(long groupId, 174 int start, int end, 175 OrderByComparator<SocialActivitySet> orderByComparator, 176 boolean retrieveFromCache) { 177 return getPersistence() 178 .findByGroupId(groupId, start, end, orderByComparator, 179 retrieveFromCache); 180 } 181 182 /** 183 * Returns the first social activity set in the ordered set where groupId = ?. 184 * 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching social activity set 188 * @throws NoSuchActivitySetException if a matching social activity set could not be found 189 */ 190 public static SocialActivitySet findByGroupId_First(long groupId, 191 OrderByComparator<SocialActivitySet> orderByComparator) 192 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 193 return getPersistence().findByGroupId_First(groupId, orderByComparator); 194 } 195 196 /** 197 * Returns the first social activity set in the ordered set where groupId = ?. 198 * 199 * @param groupId the group ID 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 202 */ 203 public static SocialActivitySet fetchByGroupId_First(long groupId, 204 OrderByComparator<SocialActivitySet> orderByComparator) { 205 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 206 } 207 208 /** 209 * Returns the last social activity set in the ordered set where groupId = ?. 210 * 211 * @param groupId the group ID 212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 213 * @return the last matching social activity set 214 * @throws NoSuchActivitySetException if a matching social activity set could not be found 215 */ 216 public static SocialActivitySet findByGroupId_Last(long groupId, 217 OrderByComparator<SocialActivitySet> orderByComparator) 218 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 219 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 220 } 221 222 /** 223 * Returns the last social activity set in the ordered set where groupId = ?. 224 * 225 * @param groupId the group ID 226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 227 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 228 */ 229 public static SocialActivitySet fetchByGroupId_Last(long groupId, 230 OrderByComparator<SocialActivitySet> orderByComparator) { 231 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 232 } 233 234 /** 235 * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = ?. 236 * 237 * @param activitySetId the primary key of the current social activity set 238 * @param groupId the group ID 239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 240 * @return the previous, current, and next social activity set 241 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 242 */ 243 public static SocialActivitySet[] findByGroupId_PrevAndNext( 244 long activitySetId, long groupId, 245 OrderByComparator<SocialActivitySet> orderByComparator) 246 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 247 return getPersistence() 248 .findByGroupId_PrevAndNext(activitySetId, groupId, 249 orderByComparator); 250 } 251 252 /** 253 * Removes all the social activity sets where groupId = ? from the database. 254 * 255 * @param groupId the group ID 256 */ 257 public static void removeByGroupId(long groupId) { 258 getPersistence().removeByGroupId(groupId); 259 } 260 261 /** 262 * Returns the number of social activity sets where groupId = ?. 263 * 264 * @param groupId the group ID 265 * @return the number of matching social activity sets 266 */ 267 public static int countByGroupId(long groupId) { 268 return getPersistence().countByGroupId(groupId); 269 } 270 271 /** 272 * Returns all the social activity sets where userId = ?. 273 * 274 * @param userId the user ID 275 * @return the matching social activity sets 276 */ 277 public static List<SocialActivitySet> findByUserId(long userId) { 278 return getPersistence().findByUserId(userId); 279 } 280 281 /** 282 * Returns a range of all the social activity sets where userId = ?. 283 * 284 * <p> 285 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 286 * </p> 287 * 288 * @param userId the user ID 289 * @param start the lower bound of the range of social activity sets 290 * @param end the upper bound of the range of social activity sets (not inclusive) 291 * @return the range of matching social activity sets 292 */ 293 public static List<SocialActivitySet> findByUserId(long userId, int start, 294 int end) { 295 return getPersistence().findByUserId(userId, start, end); 296 } 297 298 /** 299 * Returns an ordered range of all the social activity sets where userId = ?. 300 * 301 * <p> 302 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 303 * </p> 304 * 305 * @param userId the user ID 306 * @param start the lower bound of the range of social activity sets 307 * @param end the upper bound of the range of social activity sets (not inclusive) 308 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 309 * @return the ordered range of matching social activity sets 310 */ 311 public static List<SocialActivitySet> findByUserId(long userId, int start, 312 int end, OrderByComparator<SocialActivitySet> orderByComparator) { 313 return getPersistence() 314 .findByUserId(userId, start, end, orderByComparator); 315 } 316 317 /** 318 * Returns an ordered range of all the social activity sets where userId = ?. 319 * 320 * <p> 321 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 322 * </p> 323 * 324 * @param userId the user ID 325 * @param start the lower bound of the range of social activity sets 326 * @param end the upper bound of the range of social activity sets (not inclusive) 327 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 328 * @param retrieveFromCache whether to retrieve from the finder cache 329 * @return the ordered range of matching social activity sets 330 */ 331 public static List<SocialActivitySet> findByUserId(long userId, int start, 332 int end, OrderByComparator<SocialActivitySet> orderByComparator, 333 boolean retrieveFromCache) { 334 return getPersistence() 335 .findByUserId(userId, start, end, orderByComparator, 336 retrieveFromCache); 337 } 338 339 /** 340 * Returns the first social activity set in the ordered set where userId = ?. 341 * 342 * @param userId the user ID 343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 344 * @return the first matching social activity set 345 * @throws NoSuchActivitySetException if a matching social activity set could not be found 346 */ 347 public static SocialActivitySet findByUserId_First(long userId, 348 OrderByComparator<SocialActivitySet> orderByComparator) 349 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 350 return getPersistence().findByUserId_First(userId, orderByComparator); 351 } 352 353 /** 354 * Returns the first social activity set in the ordered set where userId = ?. 355 * 356 * @param userId the user ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 359 */ 360 public static SocialActivitySet fetchByUserId_First(long userId, 361 OrderByComparator<SocialActivitySet> orderByComparator) { 362 return getPersistence().fetchByUserId_First(userId, orderByComparator); 363 } 364 365 /** 366 * Returns the last social activity set in the ordered set where userId = ?. 367 * 368 * @param userId the user ID 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the last matching social activity set 371 * @throws NoSuchActivitySetException if a matching social activity set could not be found 372 */ 373 public static SocialActivitySet findByUserId_Last(long userId, 374 OrderByComparator<SocialActivitySet> orderByComparator) 375 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 376 return getPersistence().findByUserId_Last(userId, orderByComparator); 377 } 378 379 /** 380 * Returns the last social activity set in the ordered set where userId = ?. 381 * 382 * @param userId the user ID 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 384 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 385 */ 386 public static SocialActivitySet fetchByUserId_Last(long userId, 387 OrderByComparator<SocialActivitySet> orderByComparator) { 388 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 389 } 390 391 /** 392 * Returns the social activity sets before and after the current social activity set in the ordered set where userId = ?. 393 * 394 * @param activitySetId the primary key of the current social activity set 395 * @param userId the user ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the previous, current, and next social activity set 398 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 399 */ 400 public static SocialActivitySet[] findByUserId_PrevAndNext( 401 long activitySetId, long userId, 402 OrderByComparator<SocialActivitySet> orderByComparator) 403 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 404 return getPersistence() 405 .findByUserId_PrevAndNext(activitySetId, userId, 406 orderByComparator); 407 } 408 409 /** 410 * Removes all the social activity sets where userId = ? from the database. 411 * 412 * @param userId the user ID 413 */ 414 public static void removeByUserId(long userId) { 415 getPersistence().removeByUserId(userId); 416 } 417 418 /** 419 * Returns the number of social activity sets where userId = ?. 420 * 421 * @param userId the user ID 422 * @return the number of matching social activity sets 423 */ 424 public static int countByUserId(long userId) { 425 return getPersistence().countByUserId(userId); 426 } 427 428 /** 429 * Returns all the social activity sets where groupId = ? and userId = ? and type = ?. 430 * 431 * @param groupId the group ID 432 * @param userId the user ID 433 * @param type the type 434 * @return the matching social activity sets 435 */ 436 public static List<SocialActivitySet> findByG_U_T(long groupId, 437 long userId, int type) { 438 return getPersistence().findByG_U_T(groupId, userId, type); 439 } 440 441 /** 442 * Returns a range of all the social activity sets where groupId = ? and userId = ? and type = ?. 443 * 444 * <p> 445 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 446 * </p> 447 * 448 * @param groupId the group ID 449 * @param userId the user ID 450 * @param type the type 451 * @param start the lower bound of the range of social activity sets 452 * @param end the upper bound of the range of social activity sets (not inclusive) 453 * @return the range of matching social activity sets 454 */ 455 public static List<SocialActivitySet> findByG_U_T(long groupId, 456 long userId, int type, int start, int end) { 457 return getPersistence().findByG_U_T(groupId, userId, type, start, end); 458 } 459 460 /** 461 * Returns an ordered range of all the social activity sets where groupId = ? and userId = ? and type = ?. 462 * 463 * <p> 464 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 465 * </p> 466 * 467 * @param groupId the group ID 468 * @param userId the user ID 469 * @param type the type 470 * @param start the lower bound of the range of social activity sets 471 * @param end the upper bound of the range of social activity sets (not inclusive) 472 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 473 * @return the ordered range of matching social activity sets 474 */ 475 public static List<SocialActivitySet> findByG_U_T(long groupId, 476 long userId, int type, int start, int end, 477 OrderByComparator<SocialActivitySet> orderByComparator) { 478 return getPersistence() 479 .findByG_U_T(groupId, userId, type, start, end, 480 orderByComparator); 481 } 482 483 /** 484 * Returns an ordered range of all the social activity sets where groupId = ? and userId = ? and type = ?. 485 * 486 * <p> 487 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 488 * </p> 489 * 490 * @param groupId the group ID 491 * @param userId the user ID 492 * @param type the type 493 * @param start the lower bound of the range of social activity sets 494 * @param end the upper bound of the range of social activity sets (not inclusive) 495 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 496 * @param retrieveFromCache whether to retrieve from the finder cache 497 * @return the ordered range of matching social activity sets 498 */ 499 public static List<SocialActivitySet> findByG_U_T(long groupId, 500 long userId, int type, int start, int end, 501 OrderByComparator<SocialActivitySet> orderByComparator, 502 boolean retrieveFromCache) { 503 return getPersistence() 504 .findByG_U_T(groupId, userId, type, start, end, 505 orderByComparator, retrieveFromCache); 506 } 507 508 /** 509 * Returns the first social activity set in the ordered set where groupId = ? and userId = ? and type = ?. 510 * 511 * @param groupId the group ID 512 * @param userId the user ID 513 * @param type the type 514 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 515 * @return the first matching social activity set 516 * @throws NoSuchActivitySetException if a matching social activity set could not be found 517 */ 518 public static SocialActivitySet findByG_U_T_First(long groupId, 519 long userId, int type, 520 OrderByComparator<SocialActivitySet> orderByComparator) 521 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 522 return getPersistence() 523 .findByG_U_T_First(groupId, userId, type, orderByComparator); 524 } 525 526 /** 527 * Returns the first social activity set in the ordered set where groupId = ? and userId = ? and type = ?. 528 * 529 * @param groupId the group ID 530 * @param userId the user ID 531 * @param type the type 532 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 533 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 534 */ 535 public static SocialActivitySet fetchByG_U_T_First(long groupId, 536 long userId, int type, 537 OrderByComparator<SocialActivitySet> orderByComparator) { 538 return getPersistence() 539 .fetchByG_U_T_First(groupId, userId, type, orderByComparator); 540 } 541 542 /** 543 * Returns the last social activity set in the ordered set where groupId = ? and userId = ? and type = ?. 544 * 545 * @param groupId the group ID 546 * @param userId the user ID 547 * @param type the type 548 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 549 * @return the last matching social activity set 550 * @throws NoSuchActivitySetException if a matching social activity set could not be found 551 */ 552 public static SocialActivitySet findByG_U_T_Last(long groupId, long userId, 553 int type, OrderByComparator<SocialActivitySet> orderByComparator) 554 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 555 return getPersistence() 556 .findByG_U_T_Last(groupId, userId, type, orderByComparator); 557 } 558 559 /** 560 * Returns the last social activity set in the ordered set where groupId = ? and userId = ? and type = ?. 561 * 562 * @param groupId the group ID 563 * @param userId the user ID 564 * @param type the type 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 567 */ 568 public static SocialActivitySet fetchByG_U_T_Last(long groupId, 569 long userId, int type, 570 OrderByComparator<SocialActivitySet> orderByComparator) { 571 return getPersistence() 572 .fetchByG_U_T_Last(groupId, userId, type, orderByComparator); 573 } 574 575 /** 576 * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = ? and userId = ? and type = ?. 577 * 578 * @param activitySetId the primary key of the current social activity set 579 * @param groupId the group ID 580 * @param userId the user ID 581 * @param type the type 582 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 583 * @return the previous, current, and next social activity set 584 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 585 */ 586 public static SocialActivitySet[] findByG_U_T_PrevAndNext( 587 long activitySetId, long groupId, long userId, int type, 588 OrderByComparator<SocialActivitySet> orderByComparator) 589 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 590 return getPersistence() 591 .findByG_U_T_PrevAndNext(activitySetId, groupId, userId, 592 type, orderByComparator); 593 } 594 595 /** 596 * Removes all the social activity sets where groupId = ? and userId = ? and type = ? from the database. 597 * 598 * @param groupId the group ID 599 * @param userId the user ID 600 * @param type the type 601 */ 602 public static void removeByG_U_T(long groupId, long userId, int type) { 603 getPersistence().removeByG_U_T(groupId, userId, type); 604 } 605 606 /** 607 * Returns the number of social activity sets where groupId = ? and userId = ? and type = ?. 608 * 609 * @param groupId the group ID 610 * @param userId the user ID 611 * @param type the type 612 * @return the number of matching social activity sets 613 */ 614 public static int countByG_U_T(long groupId, long userId, int type) { 615 return getPersistence().countByG_U_T(groupId, userId, type); 616 } 617 618 /** 619 * Returns all the social activity sets where classNameId = ? and classPK = ? and type = ?. 620 * 621 * @param classNameId the class name ID 622 * @param classPK the class p k 623 * @param type the type 624 * @return the matching social activity sets 625 */ 626 public static List<SocialActivitySet> findByC_C_T(long classNameId, 627 long classPK, int type) { 628 return getPersistence().findByC_C_T(classNameId, classPK, type); 629 } 630 631 /** 632 * Returns a range of all the social activity sets where classNameId = ? and classPK = ? and type = ?. 633 * 634 * <p> 635 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 636 * </p> 637 * 638 * @param classNameId the class name ID 639 * @param classPK the class p k 640 * @param type the type 641 * @param start the lower bound of the range of social activity sets 642 * @param end the upper bound of the range of social activity sets (not inclusive) 643 * @return the range of matching social activity sets 644 */ 645 public static List<SocialActivitySet> findByC_C_T(long classNameId, 646 long classPK, int type, int start, int end) { 647 return getPersistence() 648 .findByC_C_T(classNameId, classPK, type, start, end); 649 } 650 651 /** 652 * Returns an ordered range of all the social activity sets where classNameId = ? and classPK = ? and type = ?. 653 * 654 * <p> 655 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 656 * </p> 657 * 658 * @param classNameId the class name ID 659 * @param classPK the class p k 660 * @param type the type 661 * @param start the lower bound of the range of social activity sets 662 * @param end the upper bound of the range of social activity sets (not inclusive) 663 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 664 * @return the ordered range of matching social activity sets 665 */ 666 public static List<SocialActivitySet> findByC_C_T(long classNameId, 667 long classPK, int type, int start, int end, 668 OrderByComparator<SocialActivitySet> orderByComparator) { 669 return getPersistence() 670 .findByC_C_T(classNameId, classPK, type, start, end, 671 orderByComparator); 672 } 673 674 /** 675 * Returns an ordered range of all the social activity sets where classNameId = ? and classPK = ? and type = ?. 676 * 677 * <p> 678 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 679 * </p> 680 * 681 * @param classNameId the class name ID 682 * @param classPK the class p k 683 * @param type the type 684 * @param start the lower bound of the range of social activity sets 685 * @param end the upper bound of the range of social activity sets (not inclusive) 686 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 687 * @param retrieveFromCache whether to retrieve from the finder cache 688 * @return the ordered range of matching social activity sets 689 */ 690 public static List<SocialActivitySet> findByC_C_T(long classNameId, 691 long classPK, int type, int start, int end, 692 OrderByComparator<SocialActivitySet> orderByComparator, 693 boolean retrieveFromCache) { 694 return getPersistence() 695 .findByC_C_T(classNameId, classPK, type, start, end, 696 orderByComparator, retrieveFromCache); 697 } 698 699 /** 700 * Returns the first social activity set in the ordered set where classNameId = ? and classPK = ? and type = ?. 701 * 702 * @param classNameId the class name ID 703 * @param classPK the class p k 704 * @param type the type 705 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 706 * @return the first matching social activity set 707 * @throws NoSuchActivitySetException if a matching social activity set could not be found 708 */ 709 public static SocialActivitySet findByC_C_T_First(long classNameId, 710 long classPK, int type, 711 OrderByComparator<SocialActivitySet> orderByComparator) 712 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 713 return getPersistence() 714 .findByC_C_T_First(classNameId, classPK, type, 715 orderByComparator); 716 } 717 718 /** 719 * Returns the first social activity set in the ordered set where classNameId = ? and classPK = ? and type = ?. 720 * 721 * @param classNameId the class name ID 722 * @param classPK the class p k 723 * @param type the type 724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 725 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 726 */ 727 public static SocialActivitySet fetchByC_C_T_First(long classNameId, 728 long classPK, int type, 729 OrderByComparator<SocialActivitySet> orderByComparator) { 730 return getPersistence() 731 .fetchByC_C_T_First(classNameId, classPK, type, 732 orderByComparator); 733 } 734 735 /** 736 * Returns the last social activity set in the ordered set where classNameId = ? and classPK = ? and type = ?. 737 * 738 * @param classNameId the class name ID 739 * @param classPK the class p k 740 * @param type the type 741 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 742 * @return the last matching social activity set 743 * @throws NoSuchActivitySetException if a matching social activity set could not be found 744 */ 745 public static SocialActivitySet findByC_C_T_Last(long classNameId, 746 long classPK, int type, 747 OrderByComparator<SocialActivitySet> orderByComparator) 748 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 749 return getPersistence() 750 .findByC_C_T_Last(classNameId, classPK, type, 751 orderByComparator); 752 } 753 754 /** 755 * Returns the last social activity set in the ordered set where classNameId = ? and classPK = ? and type = ?. 756 * 757 * @param classNameId the class name ID 758 * @param classPK the class p k 759 * @param type the type 760 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 761 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 762 */ 763 public static SocialActivitySet fetchByC_C_T_Last(long classNameId, 764 long classPK, int type, 765 OrderByComparator<SocialActivitySet> orderByComparator) { 766 return getPersistence() 767 .fetchByC_C_T_Last(classNameId, classPK, type, 768 orderByComparator); 769 } 770 771 /** 772 * Returns the social activity sets before and after the current social activity set in the ordered set where classNameId = ? and classPK = ? and type = ?. 773 * 774 * @param activitySetId the primary key of the current social activity set 775 * @param classNameId the class name ID 776 * @param classPK the class p k 777 * @param type the type 778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 779 * @return the previous, current, and next social activity set 780 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 781 */ 782 public static SocialActivitySet[] findByC_C_T_PrevAndNext( 783 long activitySetId, long classNameId, long classPK, int type, 784 OrderByComparator<SocialActivitySet> orderByComparator) 785 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 786 return getPersistence() 787 .findByC_C_T_PrevAndNext(activitySetId, classNameId, 788 classPK, type, orderByComparator); 789 } 790 791 /** 792 * Removes all the social activity sets where classNameId = ? and classPK = ? and type = ? from the database. 793 * 794 * @param classNameId the class name ID 795 * @param classPK the class p k 796 * @param type the type 797 */ 798 public static void removeByC_C_T(long classNameId, long classPK, int type) { 799 getPersistence().removeByC_C_T(classNameId, classPK, type); 800 } 801 802 /** 803 * Returns the number of social activity sets where classNameId = ? and classPK = ? and type = ?. 804 * 805 * @param classNameId the class name ID 806 * @param classPK the class p k 807 * @param type the type 808 * @return the number of matching social activity sets 809 */ 810 public static int countByC_C_T(long classNameId, long classPK, int type) { 811 return getPersistence().countByC_C_T(classNameId, classPK, type); 812 } 813 814 /** 815 * Returns all the social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ?. 816 * 817 * @param groupId the group ID 818 * @param userId the user ID 819 * @param classNameId the class name ID 820 * @param type the type 821 * @return the matching social activity sets 822 */ 823 public static List<SocialActivitySet> findByG_U_C_T(long groupId, 824 long userId, long classNameId, int type) { 825 return getPersistence().findByG_U_C_T(groupId, userId, classNameId, type); 826 } 827 828 /** 829 * Returns a range of all the social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ?. 830 * 831 * <p> 832 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 833 * </p> 834 * 835 * @param groupId the group ID 836 * @param userId the user ID 837 * @param classNameId the class name ID 838 * @param type the type 839 * @param start the lower bound of the range of social activity sets 840 * @param end the upper bound of the range of social activity sets (not inclusive) 841 * @return the range of matching social activity sets 842 */ 843 public static List<SocialActivitySet> findByG_U_C_T(long groupId, 844 long userId, long classNameId, int type, int start, int end) { 845 return getPersistence() 846 .findByG_U_C_T(groupId, userId, classNameId, type, start, end); 847 } 848 849 /** 850 * Returns an ordered range of all the social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ?. 851 * 852 * <p> 853 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 854 * </p> 855 * 856 * @param groupId the group ID 857 * @param userId the user ID 858 * @param classNameId the class name ID 859 * @param type the type 860 * @param start the lower bound of the range of social activity sets 861 * @param end the upper bound of the range of social activity sets (not inclusive) 862 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 863 * @return the ordered range of matching social activity sets 864 */ 865 public static List<SocialActivitySet> findByG_U_C_T(long groupId, 866 long userId, long classNameId, int type, int start, int end, 867 OrderByComparator<SocialActivitySet> orderByComparator) { 868 return getPersistence() 869 .findByG_U_C_T(groupId, userId, classNameId, type, start, 870 end, orderByComparator); 871 } 872 873 /** 874 * Returns an ordered range of all the social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ?. 875 * 876 * <p> 877 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 878 * </p> 879 * 880 * @param groupId the group ID 881 * @param userId the user ID 882 * @param classNameId the class name ID 883 * @param type the type 884 * @param start the lower bound of the range of social activity sets 885 * @param end the upper bound of the range of social activity sets (not inclusive) 886 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 887 * @param retrieveFromCache whether to retrieve from the finder cache 888 * @return the ordered range of matching social activity sets 889 */ 890 public static List<SocialActivitySet> findByG_U_C_T(long groupId, 891 long userId, long classNameId, int type, int start, int end, 892 OrderByComparator<SocialActivitySet> orderByComparator, 893 boolean retrieveFromCache) { 894 return getPersistence() 895 .findByG_U_C_T(groupId, userId, classNameId, type, start, 896 end, orderByComparator, retrieveFromCache); 897 } 898 899 /** 900 * Returns the first social activity set in the ordered set where groupId = ? and userId = ? and classNameId = ? and type = ?. 901 * 902 * @param groupId the group ID 903 * @param userId the user ID 904 * @param classNameId the class name ID 905 * @param type the type 906 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 907 * @return the first matching social activity set 908 * @throws NoSuchActivitySetException if a matching social activity set could not be found 909 */ 910 public static SocialActivitySet findByG_U_C_T_First(long groupId, 911 long userId, long classNameId, int type, 912 OrderByComparator<SocialActivitySet> orderByComparator) 913 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 914 return getPersistence() 915 .findByG_U_C_T_First(groupId, userId, classNameId, type, 916 orderByComparator); 917 } 918 919 /** 920 * Returns the first social activity set in the ordered set where groupId = ? and userId = ? and classNameId = ? and type = ?. 921 * 922 * @param groupId the group ID 923 * @param userId the user ID 924 * @param classNameId the class name ID 925 * @param type the type 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 928 */ 929 public static SocialActivitySet fetchByG_U_C_T_First(long groupId, 930 long userId, long classNameId, int type, 931 OrderByComparator<SocialActivitySet> orderByComparator) { 932 return getPersistence() 933 .fetchByG_U_C_T_First(groupId, userId, classNameId, type, 934 orderByComparator); 935 } 936 937 /** 938 * Returns the last social activity set in the ordered set where groupId = ? and userId = ? and classNameId = ? and type = ?. 939 * 940 * @param groupId the group ID 941 * @param userId the user ID 942 * @param classNameId the class name ID 943 * @param type the type 944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 945 * @return the last matching social activity set 946 * @throws NoSuchActivitySetException if a matching social activity set could not be found 947 */ 948 public static SocialActivitySet findByG_U_C_T_Last(long groupId, 949 long userId, long classNameId, int type, 950 OrderByComparator<SocialActivitySet> orderByComparator) 951 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 952 return getPersistence() 953 .findByG_U_C_T_Last(groupId, userId, classNameId, type, 954 orderByComparator); 955 } 956 957 /** 958 * Returns the last social activity set in the ordered set where groupId = ? and userId = ? and classNameId = ? and type = ?. 959 * 960 * @param groupId the group ID 961 * @param userId the user ID 962 * @param classNameId the class name ID 963 * @param type the type 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 966 */ 967 public static SocialActivitySet fetchByG_U_C_T_Last(long groupId, 968 long userId, long classNameId, int type, 969 OrderByComparator<SocialActivitySet> orderByComparator) { 970 return getPersistence() 971 .fetchByG_U_C_T_Last(groupId, userId, classNameId, type, 972 orderByComparator); 973 } 974 975 /** 976 * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = ? and userId = ? and classNameId = ? and type = ?. 977 * 978 * @param activitySetId the primary key of the current social activity set 979 * @param groupId the group ID 980 * @param userId the user ID 981 * @param classNameId the class name ID 982 * @param type the type 983 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 984 * @return the previous, current, and next social activity set 985 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 986 */ 987 public static SocialActivitySet[] findByG_U_C_T_PrevAndNext( 988 long activitySetId, long groupId, long userId, long classNameId, 989 int type, OrderByComparator<SocialActivitySet> orderByComparator) 990 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 991 return getPersistence() 992 .findByG_U_C_T_PrevAndNext(activitySetId, groupId, userId, 993 classNameId, type, orderByComparator); 994 } 995 996 /** 997 * Removes all the social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ? from the database. 998 * 999 * @param groupId the group ID 1000 * @param userId the user ID 1001 * @param classNameId the class name ID 1002 * @param type the type 1003 */ 1004 public static void removeByG_U_C_T(long groupId, long userId, 1005 long classNameId, int type) { 1006 getPersistence().removeByG_U_C_T(groupId, userId, classNameId, type); 1007 } 1008 1009 /** 1010 * Returns the number of social activity sets where groupId = ? and userId = ? and classNameId = ? and type = ?. 1011 * 1012 * @param groupId the group ID 1013 * @param userId the user ID 1014 * @param classNameId the class name ID 1015 * @param type the type 1016 * @return the number of matching social activity sets 1017 */ 1018 public static int countByG_U_C_T(long groupId, long userId, 1019 long classNameId, int type) { 1020 return getPersistence() 1021 .countByG_U_C_T(groupId, userId, classNameId, type); 1022 } 1023 1024 /** 1025 * Returns all the social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ?. 1026 * 1027 * @param userId the user ID 1028 * @param classNameId the class name ID 1029 * @param classPK the class p k 1030 * @param type the type 1031 * @return the matching social activity sets 1032 */ 1033 public static List<SocialActivitySet> findByU_C_C_T(long userId, 1034 long classNameId, long classPK, int type) { 1035 return getPersistence().findByU_C_C_T(userId, classNameId, classPK, type); 1036 } 1037 1038 /** 1039 * Returns a range of all the social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ?. 1040 * 1041 * <p> 1042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1043 * </p> 1044 * 1045 * @param userId the user ID 1046 * @param classNameId the class name ID 1047 * @param classPK the class p k 1048 * @param type the type 1049 * @param start the lower bound of the range of social activity sets 1050 * @param end the upper bound of the range of social activity sets (not inclusive) 1051 * @return the range of matching social activity sets 1052 */ 1053 public static List<SocialActivitySet> findByU_C_C_T(long userId, 1054 long classNameId, long classPK, int type, int start, int end) { 1055 return getPersistence() 1056 .findByU_C_C_T(userId, classNameId, classPK, type, start, end); 1057 } 1058 1059 /** 1060 * Returns an ordered range of all the social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ?. 1061 * 1062 * <p> 1063 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1064 * </p> 1065 * 1066 * @param userId the user ID 1067 * @param classNameId the class name ID 1068 * @param classPK the class p k 1069 * @param type the type 1070 * @param start the lower bound of the range of social activity sets 1071 * @param end the upper bound of the range of social activity sets (not inclusive) 1072 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1073 * @return the ordered range of matching social activity sets 1074 */ 1075 public static List<SocialActivitySet> findByU_C_C_T(long userId, 1076 long classNameId, long classPK, int type, int start, int end, 1077 OrderByComparator<SocialActivitySet> orderByComparator) { 1078 return getPersistence() 1079 .findByU_C_C_T(userId, classNameId, classPK, type, start, 1080 end, orderByComparator); 1081 } 1082 1083 /** 1084 * Returns an ordered range of all the social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ?. 1085 * 1086 * <p> 1087 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1088 * </p> 1089 * 1090 * @param userId the user ID 1091 * @param classNameId the class name ID 1092 * @param classPK the class p k 1093 * @param type the type 1094 * @param start the lower bound of the range of social activity sets 1095 * @param end the upper bound of the range of social activity sets (not inclusive) 1096 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1097 * @param retrieveFromCache whether to retrieve from the finder cache 1098 * @return the ordered range of matching social activity sets 1099 */ 1100 public static List<SocialActivitySet> findByU_C_C_T(long userId, 1101 long classNameId, long classPK, int type, int start, int end, 1102 OrderByComparator<SocialActivitySet> orderByComparator, 1103 boolean retrieveFromCache) { 1104 return getPersistence() 1105 .findByU_C_C_T(userId, classNameId, classPK, type, start, 1106 end, orderByComparator, retrieveFromCache); 1107 } 1108 1109 /** 1110 * Returns the first social activity set in the ordered set where userId = ? and classNameId = ? and classPK = ? and type = ?. 1111 * 1112 * @param userId the user ID 1113 * @param classNameId the class name ID 1114 * @param classPK the class p k 1115 * @param type the type 1116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1117 * @return the first matching social activity set 1118 * @throws NoSuchActivitySetException if a matching social activity set could not be found 1119 */ 1120 public static SocialActivitySet findByU_C_C_T_First(long userId, 1121 long classNameId, long classPK, int type, 1122 OrderByComparator<SocialActivitySet> orderByComparator) 1123 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 1124 return getPersistence() 1125 .findByU_C_C_T_First(userId, classNameId, classPK, type, 1126 orderByComparator); 1127 } 1128 1129 /** 1130 * Returns the first social activity set in the ordered set where userId = ? and classNameId = ? and classPK = ? and type = ?. 1131 * 1132 * @param userId the user ID 1133 * @param classNameId the class name ID 1134 * @param classPK the class p k 1135 * @param type the type 1136 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1137 * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found 1138 */ 1139 public static SocialActivitySet fetchByU_C_C_T_First(long userId, 1140 long classNameId, long classPK, int type, 1141 OrderByComparator<SocialActivitySet> orderByComparator) { 1142 return getPersistence() 1143 .fetchByU_C_C_T_First(userId, classNameId, classPK, type, 1144 orderByComparator); 1145 } 1146 1147 /** 1148 * Returns the last social activity set in the ordered set where userId = ? and classNameId = ? and classPK = ? and type = ?. 1149 * 1150 * @param userId the user ID 1151 * @param classNameId the class name ID 1152 * @param classPK the class p k 1153 * @param type the type 1154 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1155 * @return the last matching social activity set 1156 * @throws NoSuchActivitySetException if a matching social activity set could not be found 1157 */ 1158 public static SocialActivitySet findByU_C_C_T_Last(long userId, 1159 long classNameId, long classPK, int type, 1160 OrderByComparator<SocialActivitySet> orderByComparator) 1161 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 1162 return getPersistence() 1163 .findByU_C_C_T_Last(userId, classNameId, classPK, type, 1164 orderByComparator); 1165 } 1166 1167 /** 1168 * Returns the last social activity set in the ordered set where userId = ? and classNameId = ? and classPK = ? and type = ?. 1169 * 1170 * @param userId the user ID 1171 * @param classNameId the class name ID 1172 * @param classPK the class p k 1173 * @param type the type 1174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1175 * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found 1176 */ 1177 public static SocialActivitySet fetchByU_C_C_T_Last(long userId, 1178 long classNameId, long classPK, int type, 1179 OrderByComparator<SocialActivitySet> orderByComparator) { 1180 return getPersistence() 1181 .fetchByU_C_C_T_Last(userId, classNameId, classPK, type, 1182 orderByComparator); 1183 } 1184 1185 /** 1186 * Returns the social activity sets before and after the current social activity set in the ordered set where userId = ? and classNameId = ? and classPK = ? and type = ?. 1187 * 1188 * @param activitySetId the primary key of the current social activity set 1189 * @param userId the user ID 1190 * @param classNameId the class name ID 1191 * @param classPK the class p k 1192 * @param type the type 1193 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1194 * @return the previous, current, and next social activity set 1195 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 1196 */ 1197 public static SocialActivitySet[] findByU_C_C_T_PrevAndNext( 1198 long activitySetId, long userId, long classNameId, long classPK, 1199 int type, OrderByComparator<SocialActivitySet> orderByComparator) 1200 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 1201 return getPersistence() 1202 .findByU_C_C_T_PrevAndNext(activitySetId, userId, 1203 classNameId, classPK, type, orderByComparator); 1204 } 1205 1206 /** 1207 * Removes all the social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ? from the database. 1208 * 1209 * @param userId the user ID 1210 * @param classNameId the class name ID 1211 * @param classPK the class p k 1212 * @param type the type 1213 */ 1214 public static void removeByU_C_C_T(long userId, long classNameId, 1215 long classPK, int type) { 1216 getPersistence().removeByU_C_C_T(userId, classNameId, classPK, type); 1217 } 1218 1219 /** 1220 * Returns the number of social activity sets where userId = ? and classNameId = ? and classPK = ? and type = ?. 1221 * 1222 * @param userId the user ID 1223 * @param classNameId the class name ID 1224 * @param classPK the class p k 1225 * @param type the type 1226 * @return the number of matching social activity sets 1227 */ 1228 public static int countByU_C_C_T(long userId, long classNameId, 1229 long classPK, int type) { 1230 return getPersistence() 1231 .countByU_C_C_T(userId, classNameId, classPK, type); 1232 } 1233 1234 /** 1235 * Caches the social activity set in the entity cache if it is enabled. 1236 * 1237 * @param socialActivitySet the social activity set 1238 */ 1239 public static void cacheResult(SocialActivitySet socialActivitySet) { 1240 getPersistence().cacheResult(socialActivitySet); 1241 } 1242 1243 /** 1244 * Caches the social activity sets in the entity cache if it is enabled. 1245 * 1246 * @param socialActivitySets the social activity sets 1247 */ 1248 public static void cacheResult(List<SocialActivitySet> socialActivitySets) { 1249 getPersistence().cacheResult(socialActivitySets); 1250 } 1251 1252 /** 1253 * Creates a new social activity set with the primary key. Does not add the social activity set to the database. 1254 * 1255 * @param activitySetId the primary key for the new social activity set 1256 * @return the new social activity set 1257 */ 1258 public static SocialActivitySet create(long activitySetId) { 1259 return getPersistence().create(activitySetId); 1260 } 1261 1262 /** 1263 * Removes the social activity set with the primary key from the database. Also notifies the appropriate model listeners. 1264 * 1265 * @param activitySetId the primary key of the social activity set 1266 * @return the social activity set that was removed 1267 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 1268 */ 1269 public static SocialActivitySet remove(long activitySetId) 1270 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 1271 return getPersistence().remove(activitySetId); 1272 } 1273 1274 public static SocialActivitySet updateImpl( 1275 SocialActivitySet socialActivitySet) { 1276 return getPersistence().updateImpl(socialActivitySet); 1277 } 1278 1279 /** 1280 * Returns the social activity set with the primary key or throws a {@link NoSuchActivitySetException} if it could not be found. 1281 * 1282 * @param activitySetId the primary key of the social activity set 1283 * @return the social activity set 1284 * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found 1285 */ 1286 public static SocialActivitySet findByPrimaryKey(long activitySetId) 1287 throws com.liferay.portlet.social.exception.NoSuchActivitySetException { 1288 return getPersistence().findByPrimaryKey(activitySetId); 1289 } 1290 1291 /** 1292 * Returns the social activity set with the primary key or returns <code>null</code> if it could not be found. 1293 * 1294 * @param activitySetId the primary key of the social activity set 1295 * @return the social activity set, or <code>null</code> if a social activity set with the primary key could not be found 1296 */ 1297 public static SocialActivitySet fetchByPrimaryKey(long activitySetId) { 1298 return getPersistence().fetchByPrimaryKey(activitySetId); 1299 } 1300 1301 public static java.util.Map<java.io.Serializable, SocialActivitySet> fetchByPrimaryKeys( 1302 java.util.Set<java.io.Serializable> primaryKeys) { 1303 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1304 } 1305 1306 /** 1307 * Returns all the social activity sets. 1308 * 1309 * @return the social activity sets 1310 */ 1311 public static List<SocialActivitySet> findAll() { 1312 return getPersistence().findAll(); 1313 } 1314 1315 /** 1316 * Returns a range of all the social activity sets. 1317 * 1318 * <p> 1319 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1320 * </p> 1321 * 1322 * @param start the lower bound of the range of social activity sets 1323 * @param end the upper bound of the range of social activity sets (not inclusive) 1324 * @return the range of social activity sets 1325 */ 1326 public static List<SocialActivitySet> findAll(int start, int end) { 1327 return getPersistence().findAll(start, end); 1328 } 1329 1330 /** 1331 * Returns an ordered range of all the social activity sets. 1332 * 1333 * <p> 1334 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1335 * </p> 1336 * 1337 * @param start the lower bound of the range of social activity sets 1338 * @param end the upper bound of the range of social activity sets (not inclusive) 1339 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1340 * @return the ordered range of social activity sets 1341 */ 1342 public static List<SocialActivitySet> findAll(int start, int end, 1343 OrderByComparator<SocialActivitySet> orderByComparator) { 1344 return getPersistence().findAll(start, end, orderByComparator); 1345 } 1346 1347 /** 1348 * Returns an ordered range of all the social activity sets. 1349 * 1350 * <p> 1351 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivitySetModelImpl}. 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. 1352 * </p> 1353 * 1354 * @param start the lower bound of the range of social activity sets 1355 * @param end the upper bound of the range of social activity sets (not inclusive) 1356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1357 * @param retrieveFromCache whether to retrieve from the finder cache 1358 * @return the ordered range of social activity sets 1359 */ 1360 public static List<SocialActivitySet> findAll(int start, int end, 1361 OrderByComparator<SocialActivitySet> orderByComparator, 1362 boolean retrieveFromCache) { 1363 return getPersistence() 1364 .findAll(start, end, orderByComparator, retrieveFromCache); 1365 } 1366 1367 /** 1368 * Removes all the social activity sets from the database. 1369 */ 1370 public static void removeAll() { 1371 getPersistence().removeAll(); 1372 } 1373 1374 /** 1375 * Returns the number of social activity sets. 1376 * 1377 * @return the number of social activity sets 1378 */ 1379 public static int countAll() { 1380 return getPersistence().countAll(); 1381 } 1382 1383 public static java.util.Set<java.lang.String> getBadColumnNames() { 1384 return getPersistence().getBadColumnNames(); 1385 } 1386 1387 public static SocialActivitySetPersistence getPersistence() { 1388 if (_persistence == null) { 1389 _persistence = (SocialActivitySetPersistence)PortalBeanLocatorUtil.locate(SocialActivitySetPersistence.class.getName()); 1390 1391 ReferenceRegistry.registerReference(SocialActivitySetUtil.class, 1392 "_persistence"); 1393 } 1394 1395 return _persistence; 1396 } 1397 1398 private static SocialActivitySetPersistence _persistence; 1399 }