001 /** 002 * Copyright (c) 2000-2012 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.announcements.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.announcements.model.AnnouncementsEntry; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the announcements entry service. This utility wraps {@link AnnouncementsEntryPersistenceImpl} 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 AnnouncementsEntryPersistence 037 * @see AnnouncementsEntryPersistenceImpl 038 * @generated 039 */ 040 public class AnnouncementsEntryUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(AnnouncementsEntry announcementsEntry) { 058 getPersistence().clearCache(announcementsEntry); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<AnnouncementsEntry> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<AnnouncementsEntry> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 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<AnnouncementsEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 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, boolean) 099 */ 100 public static AnnouncementsEntry update( 101 AnnouncementsEntry announcementsEntry, boolean merge) 102 throws SystemException { 103 return getPersistence().update(announcementsEntry, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static AnnouncementsEntry update( 110 AnnouncementsEntry announcementsEntry, boolean merge, 111 ServiceContext serviceContext) throws SystemException { 112 return getPersistence().update(announcementsEntry, merge, serviceContext); 113 } 114 115 /** 116 * Caches the announcements entry in the entity cache if it is enabled. 117 * 118 * @param announcementsEntry the announcements entry 119 */ 120 public static void cacheResult( 121 com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry) { 122 getPersistence().cacheResult(announcementsEntry); 123 } 124 125 /** 126 * Caches the announcements entries in the entity cache if it is enabled. 127 * 128 * @param announcementsEntries the announcements entries 129 */ 130 public static void cacheResult( 131 java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> announcementsEntries) { 132 getPersistence().cacheResult(announcementsEntries); 133 } 134 135 /** 136 * Creates a new announcements entry with the primary key. Does not add the announcements entry to the database. 137 * 138 * @param entryId the primary key for the new announcements entry 139 * @return the new announcements entry 140 */ 141 public static com.liferay.portlet.announcements.model.AnnouncementsEntry create( 142 long entryId) { 143 return getPersistence().create(entryId); 144 } 145 146 /** 147 * Removes the announcements entry with the primary key from the database. Also notifies the appropriate model listeners. 148 * 149 * @param entryId the primary key of the announcements entry 150 * @return the announcements entry that was removed 151 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 152 * @throws SystemException if a system exception occurred 153 */ 154 public static com.liferay.portlet.announcements.model.AnnouncementsEntry remove( 155 long entryId) 156 throws com.liferay.portal.kernel.exception.SystemException, 157 com.liferay.portlet.announcements.NoSuchEntryException { 158 return getPersistence().remove(entryId); 159 } 160 161 public static com.liferay.portlet.announcements.model.AnnouncementsEntry updateImpl( 162 com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry, 163 boolean merge) 164 throws com.liferay.portal.kernel.exception.SystemException { 165 return getPersistence().updateImpl(announcementsEntry, merge); 166 } 167 168 /** 169 * Returns the announcements entry with the primary key or throws a {@link com.liferay.portlet.announcements.NoSuchEntryException} if it could not be found. 170 * 171 * @param entryId the primary key of the announcements entry 172 * @return the announcements entry 173 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 174 * @throws SystemException if a system exception occurred 175 */ 176 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByPrimaryKey( 177 long entryId) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.announcements.NoSuchEntryException { 180 return getPersistence().findByPrimaryKey(entryId); 181 } 182 183 /** 184 * Returns the announcements entry with the primary key or returns <code>null</code> if it could not be found. 185 * 186 * @param entryId the primary key of the announcements entry 187 * @return the announcements entry, or <code>null</code> if a announcements entry with the primary key could not be found 188 * @throws SystemException if a system exception occurred 189 */ 190 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByPrimaryKey( 191 long entryId) 192 throws com.liferay.portal.kernel.exception.SystemException { 193 return getPersistence().fetchByPrimaryKey(entryId); 194 } 195 196 /** 197 * Returns all the announcements entries where uuid = ?. 198 * 199 * @param uuid the uuid 200 * @return the matching announcements entries 201 * @throws SystemException if a system exception occurred 202 */ 203 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 204 java.lang.String uuid) 205 throws com.liferay.portal.kernel.exception.SystemException { 206 return getPersistence().findByUuid(uuid); 207 } 208 209 /** 210 * Returns a range of all the announcements entries where uuid = ?. 211 * 212 * <p> 213 * 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. 214 * </p> 215 * 216 * @param uuid the uuid 217 * @param start the lower bound of the range of announcements entries 218 * @param end the upper bound of the range of announcements entries (not inclusive) 219 * @return the range of matching announcements entries 220 * @throws SystemException if a system exception occurred 221 */ 222 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 223 java.lang.String uuid, int start, int end) 224 throws com.liferay.portal.kernel.exception.SystemException { 225 return getPersistence().findByUuid(uuid, start, end); 226 } 227 228 /** 229 * Returns an ordered range of all the announcements entries where uuid = ?. 230 * 231 * <p> 232 * 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. 233 * </p> 234 * 235 * @param uuid the uuid 236 * @param start the lower bound of the range of announcements entries 237 * @param end the upper bound of the range of announcements entries (not inclusive) 238 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 239 * @return the ordered range of matching announcements entries 240 * @throws SystemException if a system exception occurred 241 */ 242 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 243 java.lang.String uuid, int start, int end, 244 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 245 throws com.liferay.portal.kernel.exception.SystemException { 246 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 247 } 248 249 /** 250 * Returns the first announcements entry in the ordered set where uuid = ?. 251 * 252 * <p> 253 * 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. 254 * </p> 255 * 256 * @param uuid the uuid 257 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 258 * @return the first matching announcements entry 259 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 260 * @throws SystemException if a system exception occurred 261 */ 262 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_First( 263 java.lang.String uuid, 264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 265 throws com.liferay.portal.kernel.exception.SystemException, 266 com.liferay.portlet.announcements.NoSuchEntryException { 267 return getPersistence().findByUuid_First(uuid, orderByComparator); 268 } 269 270 /** 271 * Returns the last announcements entry in the ordered set where uuid = ?. 272 * 273 * <p> 274 * 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. 275 * </p> 276 * 277 * @param uuid the uuid 278 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 279 * @return the last matching announcements entry 280 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 281 * @throws SystemException if a system exception occurred 282 */ 283 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_Last( 284 java.lang.String uuid, 285 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 286 throws com.liferay.portal.kernel.exception.SystemException, 287 com.liferay.portlet.announcements.NoSuchEntryException { 288 return getPersistence().findByUuid_Last(uuid, orderByComparator); 289 } 290 291 /** 292 * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = ?. 293 * 294 * <p> 295 * 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. 296 * </p> 297 * 298 * @param entryId the primary key of the current announcements entry 299 * @param uuid the uuid 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the previous, current, and next announcements entry 302 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 303 * @throws SystemException if a system exception occurred 304 */ 305 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUuid_PrevAndNext( 306 long entryId, java.lang.String uuid, 307 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 308 throws com.liferay.portal.kernel.exception.SystemException, 309 com.liferay.portlet.announcements.NoSuchEntryException { 310 return getPersistence() 311 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 312 } 313 314 /** 315 * Returns all the announcements entries that the user has permission to view where uuid = ?. 316 * 317 * @param uuid the uuid 318 * @return the matching announcements entries that the user has permission to view 319 * @throws SystemException if a system exception occurred 320 */ 321 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 322 java.lang.String uuid) 323 throws com.liferay.portal.kernel.exception.SystemException { 324 return getPersistence().filterFindByUuid(uuid); 325 } 326 327 /** 328 * Returns a range of all the announcements entries that the user has permission to view where uuid = ?. 329 * 330 * <p> 331 * 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. 332 * </p> 333 * 334 * @param uuid the uuid 335 * @param start the lower bound of the range of announcements entries 336 * @param end the upper bound of the range of announcements entries (not inclusive) 337 * @return the range of matching announcements entries that the user has permission to view 338 * @throws SystemException if a system exception occurred 339 */ 340 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 341 java.lang.String uuid, int start, int end) 342 throws com.liferay.portal.kernel.exception.SystemException { 343 return getPersistence().filterFindByUuid(uuid, start, end); 344 } 345 346 /** 347 * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = ?. 348 * 349 * <p> 350 * 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. 351 * </p> 352 * 353 * @param uuid the uuid 354 * @param start the lower bound of the range of announcements entries 355 * @param end the upper bound of the range of announcements entries (not inclusive) 356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 357 * @return the ordered range of matching announcements entries that the user has permission to view 358 * @throws SystemException if a system exception occurred 359 */ 360 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 361 java.lang.String uuid, int start, int end, 362 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 363 throws com.liferay.portal.kernel.exception.SystemException { 364 return getPersistence() 365 .filterFindByUuid(uuid, start, end, orderByComparator); 366 } 367 368 /** 369 * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where uuid = ?. 370 * 371 * @param entryId the primary key of the current announcements entry 372 * @param uuid the uuid 373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 374 * @return the previous, current, and next announcements entry 375 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 376 * @throws SystemException if a system exception occurred 377 */ 378 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_PrevAndNext( 379 long entryId, java.lang.String uuid, 380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 381 throws com.liferay.portal.kernel.exception.SystemException, 382 com.liferay.portlet.announcements.NoSuchEntryException { 383 return getPersistence() 384 .filterFindByUuid_PrevAndNext(entryId, uuid, 385 orderByComparator); 386 } 387 388 /** 389 * Returns all the announcements entries where userId = ?. 390 * 391 * @param userId the user ID 392 * @return the matching announcements entries 393 * @throws SystemException if a system exception occurred 394 */ 395 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 396 long userId) throws com.liferay.portal.kernel.exception.SystemException { 397 return getPersistence().findByUserId(userId); 398 } 399 400 /** 401 * Returns a range of all the announcements entries where userId = ?. 402 * 403 * <p> 404 * 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. 405 * </p> 406 * 407 * @param userId the user ID 408 * @param start the lower bound of the range of announcements entries 409 * @param end the upper bound of the range of announcements entries (not inclusive) 410 * @return the range of matching announcements entries 411 * @throws SystemException if a system exception occurred 412 */ 413 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 414 long userId, int start, int end) 415 throws com.liferay.portal.kernel.exception.SystemException { 416 return getPersistence().findByUserId(userId, start, end); 417 } 418 419 /** 420 * Returns an ordered range of all the announcements entries where userId = ?. 421 * 422 * <p> 423 * 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. 424 * </p> 425 * 426 * @param userId the user ID 427 * @param start the lower bound of the range of announcements entries 428 * @param end the upper bound of the range of announcements entries (not inclusive) 429 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 430 * @return the ordered range of matching announcements entries 431 * @throws SystemException if a system exception occurred 432 */ 433 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 434 long userId, int start, int end, 435 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 436 throws com.liferay.portal.kernel.exception.SystemException { 437 return getPersistence() 438 .findByUserId(userId, start, end, orderByComparator); 439 } 440 441 /** 442 * Returns the first announcements entry in the ordered set where userId = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 446 * </p> 447 * 448 * @param userId the user ID 449 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 450 * @return the first matching announcements entry 451 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 452 * @throws SystemException if a system exception occurred 453 */ 454 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_First( 455 long userId, 456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 457 throws com.liferay.portal.kernel.exception.SystemException, 458 com.liferay.portlet.announcements.NoSuchEntryException { 459 return getPersistence().findByUserId_First(userId, orderByComparator); 460 } 461 462 /** 463 * Returns the last announcements entry in the ordered set where userId = ?. 464 * 465 * <p> 466 * 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. 467 * </p> 468 * 469 * @param userId the user ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the last matching announcements entry 472 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 473 * @throws SystemException if a system exception occurred 474 */ 475 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_Last( 476 long userId, 477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 478 throws com.liferay.portal.kernel.exception.SystemException, 479 com.liferay.portlet.announcements.NoSuchEntryException { 480 return getPersistence().findByUserId_Last(userId, orderByComparator); 481 } 482 483 /** 484 * Returns the announcements entries before and after the current announcements entry in the ordered set where userId = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 488 * </p> 489 * 490 * @param entryId the primary key of the current announcements entry 491 * @param userId the user ID 492 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 493 * @return the previous, current, and next announcements entry 494 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 495 * @throws SystemException if a system exception occurred 496 */ 497 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUserId_PrevAndNext( 498 long entryId, long userId, 499 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 500 throws com.liferay.portal.kernel.exception.SystemException, 501 com.liferay.portlet.announcements.NoSuchEntryException { 502 return getPersistence() 503 .findByUserId_PrevAndNext(entryId, userId, orderByComparator); 504 } 505 506 /** 507 * Returns all the announcements entries that the user has permission to view where userId = ?. 508 * 509 * @param userId the user ID 510 * @return the matching announcements entries that the user has permission to view 511 * @throws SystemException if a system exception occurred 512 */ 513 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 514 long userId) throws com.liferay.portal.kernel.exception.SystemException { 515 return getPersistence().filterFindByUserId(userId); 516 } 517 518 /** 519 * Returns a range of all the announcements entries that the user has permission to view where userId = ?. 520 * 521 * <p> 522 * 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. 523 * </p> 524 * 525 * @param userId the user ID 526 * @param start the lower bound of the range of announcements entries 527 * @param end the upper bound of the range of announcements entries (not inclusive) 528 * @return the range of matching announcements entries that the user has permission to view 529 * @throws SystemException if a system exception occurred 530 */ 531 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 532 long userId, int start, int end) 533 throws com.liferay.portal.kernel.exception.SystemException { 534 return getPersistence().filterFindByUserId(userId, start, end); 535 } 536 537 /** 538 * Returns an ordered range of all the announcements entries that the user has permissions to view where userId = ?. 539 * 540 * <p> 541 * 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. 542 * </p> 543 * 544 * @param userId the user ID 545 * @param start the lower bound of the range of announcements entries 546 * @param end the upper bound of the range of announcements entries (not inclusive) 547 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 548 * @return the ordered range of matching announcements entries that the user has permission to view 549 * @throws SystemException if a system exception occurred 550 */ 551 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 552 long userId, int start, int end, 553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 554 throws com.liferay.portal.kernel.exception.SystemException { 555 return getPersistence() 556 .filterFindByUserId(userId, start, end, orderByComparator); 557 } 558 559 /** 560 * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where userId = ?. 561 * 562 * @param entryId the primary key of the current announcements entry 563 * @param userId the user ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the previous, current, and next announcements entry 566 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 567 * @throws SystemException if a system exception occurred 568 */ 569 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUserId_PrevAndNext( 570 long entryId, long userId, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException, 573 com.liferay.portlet.announcements.NoSuchEntryException { 574 return getPersistence() 575 .filterFindByUserId_PrevAndNext(entryId, userId, 576 orderByComparator); 577 } 578 579 /** 580 * Returns all the announcements entries where classNameId = ? and classPK = ?. 581 * 582 * @param classNameId the class name ID 583 * @param classPK the class p k 584 * @return the matching announcements entries 585 * @throws SystemException if a system exception occurred 586 */ 587 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 588 long classNameId, long classPK) 589 throws com.liferay.portal.kernel.exception.SystemException { 590 return getPersistence().findByC_C(classNameId, classPK); 591 } 592 593 /** 594 * Returns a range of all the announcements entries where classNameId = ? and classPK = ?. 595 * 596 * <p> 597 * 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. 598 * </p> 599 * 600 * @param classNameId the class name ID 601 * @param classPK the class p k 602 * @param start the lower bound of the range of announcements entries 603 * @param end the upper bound of the range of announcements entries (not inclusive) 604 * @return the range of matching announcements entries 605 * @throws SystemException if a system exception occurred 606 */ 607 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 608 long classNameId, long classPK, int start, int end) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence().findByC_C(classNameId, classPK, start, end); 611 } 612 613 /** 614 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ?. 615 * 616 * <p> 617 * 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. 618 * </p> 619 * 620 * @param classNameId the class name ID 621 * @param classPK the class p k 622 * @param start the lower bound of the range of announcements entries 623 * @param end the upper bound of the range of announcements entries (not inclusive) 624 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 625 * @return the ordered range of matching announcements entries 626 * @throws SystemException if a system exception occurred 627 */ 628 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 629 long classNameId, long classPK, int start, int end, 630 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 631 throws com.liferay.portal.kernel.exception.SystemException { 632 return getPersistence() 633 .findByC_C(classNameId, classPK, start, end, 634 orderByComparator); 635 } 636 637 /** 638 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 639 * 640 * <p> 641 * 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. 642 * </p> 643 * 644 * @param classNameId the class name ID 645 * @param classPK the class p k 646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 647 * @return the first matching announcements entry 648 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 649 * @throws SystemException if a system exception occurred 650 */ 651 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_First( 652 long classNameId, long classPK, 653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 654 throws com.liferay.portal.kernel.exception.SystemException, 655 com.liferay.portlet.announcements.NoSuchEntryException { 656 return getPersistence() 657 .findByC_C_First(classNameId, classPK, orderByComparator); 658 } 659 660 /** 661 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 662 * 663 * <p> 664 * 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. 665 * </p> 666 * 667 * @param classNameId the class name ID 668 * @param classPK the class p k 669 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 670 * @return the last matching announcements entry 671 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 672 * @throws SystemException if a system exception occurred 673 */ 674 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_Last( 675 long classNameId, long classPK, 676 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 677 throws com.liferay.portal.kernel.exception.SystemException, 678 com.liferay.portlet.announcements.NoSuchEntryException { 679 return getPersistence() 680 .findByC_C_Last(classNameId, classPK, orderByComparator); 681 } 682 683 /** 684 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ?. 685 * 686 * <p> 687 * 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. 688 * </p> 689 * 690 * @param entryId the primary key of the current announcements entry 691 * @param classNameId the class name ID 692 * @param classPK the class p k 693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 694 * @return the previous, current, and next announcements entry 695 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 696 * @throws SystemException if a system exception occurred 697 */ 698 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_PrevAndNext( 699 long entryId, long classNameId, long classPK, 700 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 701 throws com.liferay.portal.kernel.exception.SystemException, 702 com.liferay.portlet.announcements.NoSuchEntryException { 703 return getPersistence() 704 .findByC_C_PrevAndNext(entryId, classNameId, classPK, 705 orderByComparator); 706 } 707 708 /** 709 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 710 * 711 * @param classNameId the class name ID 712 * @param classPK the class p k 713 * @return the matching announcements entries that the user has permission to view 714 * @throws SystemException if a system exception occurred 715 */ 716 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 717 long classNameId, long classPK) 718 throws com.liferay.portal.kernel.exception.SystemException { 719 return getPersistence().filterFindByC_C(classNameId, classPK); 720 } 721 722 /** 723 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 724 * 725 * <p> 726 * 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. 727 * </p> 728 * 729 * @param classNameId the class name ID 730 * @param classPK the class p k 731 * @param start the lower bound of the range of announcements entries 732 * @param end the upper bound of the range of announcements entries (not inclusive) 733 * @return the range of matching announcements entries that the user has permission to view 734 * @throws SystemException if a system exception occurred 735 */ 736 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 737 long classNameId, long classPK, int start, int end) 738 throws com.liferay.portal.kernel.exception.SystemException { 739 return getPersistence().filterFindByC_C(classNameId, classPK, start, end); 740 } 741 742 /** 743 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ?. 744 * 745 * <p> 746 * 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. 747 * </p> 748 * 749 * @param classNameId the class name ID 750 * @param classPK the class p k 751 * @param start the lower bound of the range of announcements entries 752 * @param end the upper bound of the range of announcements entries (not inclusive) 753 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 754 * @return the ordered range of matching announcements entries that the user has permission to view 755 * @throws SystemException if a system exception occurred 756 */ 757 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 758 long classNameId, long classPK, int start, int end, 759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 760 throws com.liferay.portal.kernel.exception.SystemException { 761 return getPersistence() 762 .filterFindByC_C(classNameId, classPK, start, end, 763 orderByComparator); 764 } 765 766 /** 767 * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 768 * 769 * @param entryId the primary key of the current announcements entry 770 * @param classNameId the class name ID 771 * @param classPK the class p k 772 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 773 * @return the previous, current, and next announcements entry 774 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 775 * @throws SystemException if a system exception occurred 776 */ 777 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_PrevAndNext( 778 long entryId, long classNameId, long classPK, 779 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 780 throws com.liferay.portal.kernel.exception.SystemException, 781 com.liferay.portlet.announcements.NoSuchEntryException { 782 return getPersistence() 783 .filterFindByC_C_PrevAndNext(entryId, classNameId, classPK, 784 orderByComparator); 785 } 786 787 /** 788 * Returns all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 789 * 790 * @param classNameId the class name ID 791 * @param classPK the class p k 792 * @param alert the alert 793 * @return the matching announcements entries 794 * @throws SystemException if a system exception occurred 795 */ 796 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 797 long classNameId, long classPK, boolean alert) 798 throws com.liferay.portal.kernel.exception.SystemException { 799 return getPersistence().findByC_C_A(classNameId, classPK, alert); 800 } 801 802 /** 803 * Returns a range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 804 * 805 * <p> 806 * 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. 807 * </p> 808 * 809 * @param classNameId the class name ID 810 * @param classPK the class p k 811 * @param alert the alert 812 * @param start the lower bound of the range of announcements entries 813 * @param end the upper bound of the range of announcements entries (not inclusive) 814 * @return the range of matching announcements entries 815 * @throws SystemException if a system exception occurred 816 */ 817 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 818 long classNameId, long classPK, boolean alert, int start, int end) 819 throws com.liferay.portal.kernel.exception.SystemException { 820 return getPersistence() 821 .findByC_C_A(classNameId, classPK, alert, start, end); 822 } 823 824 /** 825 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 826 * 827 * <p> 828 * 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. 829 * </p> 830 * 831 * @param classNameId the class name ID 832 * @param classPK the class p k 833 * @param alert the alert 834 * @param start the lower bound of the range of announcements entries 835 * @param end the upper bound of the range of announcements entries (not inclusive) 836 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 837 * @return the ordered range of matching announcements entries 838 * @throws SystemException if a system exception occurred 839 */ 840 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 841 long classNameId, long classPK, boolean alert, int start, int end, 842 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 843 throws com.liferay.portal.kernel.exception.SystemException { 844 return getPersistence() 845 .findByC_C_A(classNameId, classPK, alert, start, end, 846 orderByComparator); 847 } 848 849 /** 850 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 854 * </p> 855 * 856 * @param classNameId the class name ID 857 * @param classPK the class p k 858 * @param alert the alert 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the first matching announcements entry 861 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 862 * @throws SystemException if a system exception occurred 863 */ 864 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_First( 865 long classNameId, long classPK, boolean alert, 866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 867 throws com.liferay.portal.kernel.exception.SystemException, 868 com.liferay.portlet.announcements.NoSuchEntryException { 869 return getPersistence() 870 .findByC_C_A_First(classNameId, classPK, alert, 871 orderByComparator); 872 } 873 874 /** 875 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 876 * 877 * <p> 878 * 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. 879 * </p> 880 * 881 * @param classNameId the class name ID 882 * @param classPK the class p k 883 * @param alert the alert 884 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 885 * @return the last matching announcements entry 886 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 887 * @throws SystemException if a system exception occurred 888 */ 889 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_Last( 890 long classNameId, long classPK, boolean alert, 891 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 892 throws com.liferay.portal.kernel.exception.SystemException, 893 com.liferay.portlet.announcements.NoSuchEntryException { 894 return getPersistence() 895 .findByC_C_A_Last(classNameId, classPK, alert, 896 orderByComparator); 897 } 898 899 /** 900 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 901 * 902 * <p> 903 * 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. 904 * </p> 905 * 906 * @param entryId the primary key of the current announcements entry 907 * @param classNameId the class name ID 908 * @param classPK the class p k 909 * @param alert the alert 910 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 911 * @return the previous, current, and next announcements entry 912 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 913 * @throws SystemException if a system exception occurred 914 */ 915 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_A_PrevAndNext( 916 long entryId, long classNameId, long classPK, boolean alert, 917 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 918 throws com.liferay.portal.kernel.exception.SystemException, 919 com.liferay.portlet.announcements.NoSuchEntryException { 920 return getPersistence() 921 .findByC_C_A_PrevAndNext(entryId, classNameId, classPK, 922 alert, orderByComparator); 923 } 924 925 /** 926 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 927 * 928 * @param classNameId the class name ID 929 * @param classPK the class p k 930 * @param alert the alert 931 * @return the matching announcements entries that the user has permission to view 932 * @throws SystemException if a system exception occurred 933 */ 934 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 935 long classNameId, long classPK, boolean alert) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 return getPersistence().filterFindByC_C_A(classNameId, classPK, alert); 938 } 939 940 /** 941 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 942 * 943 * <p> 944 * 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. 945 * </p> 946 * 947 * @param classNameId the class name ID 948 * @param classPK the class p k 949 * @param alert the alert 950 * @param start the lower bound of the range of announcements entries 951 * @param end the upper bound of the range of announcements entries (not inclusive) 952 * @return the range of matching announcements entries that the user has permission to view 953 * @throws SystemException if a system exception occurred 954 */ 955 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 956 long classNameId, long classPK, boolean alert, int start, int end) 957 throws com.liferay.portal.kernel.exception.SystemException { 958 return getPersistence() 959 .filterFindByC_C_A(classNameId, classPK, alert, start, end); 960 } 961 962 /** 963 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ? and alert = ?. 964 * 965 * <p> 966 * 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. 967 * </p> 968 * 969 * @param classNameId the class name ID 970 * @param classPK the class p k 971 * @param alert the alert 972 * @param start the lower bound of the range of announcements entries 973 * @param end the upper bound of the range of announcements entries (not inclusive) 974 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 975 * @return the ordered range of matching announcements entries that the user has permission to view 976 * @throws SystemException if a system exception occurred 977 */ 978 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 979 long classNameId, long classPK, boolean alert, int start, int end, 980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 981 throws com.liferay.portal.kernel.exception.SystemException { 982 return getPersistence() 983 .filterFindByC_C_A(classNameId, classPK, alert, start, end, 984 orderByComparator); 985 } 986 987 /** 988 * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 989 * 990 * @param entryId the primary key of the current announcements entry 991 * @param classNameId the class name ID 992 * @param classPK the class p k 993 * @param alert the alert 994 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 995 * @return the previous, current, and next announcements entry 996 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 997 * @throws SystemException if a system exception occurred 998 */ 999 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext( 1000 long entryId, long classNameId, long classPK, boolean alert, 1001 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1002 throws com.liferay.portal.kernel.exception.SystemException, 1003 com.liferay.portlet.announcements.NoSuchEntryException { 1004 return getPersistence() 1005 .filterFindByC_C_A_PrevAndNext(entryId, classNameId, 1006 classPK, alert, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns all the announcements entries. 1011 * 1012 * @return the announcements entries 1013 * @throws SystemException if a system exception occurred 1014 */ 1015 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll() 1016 throws com.liferay.portal.kernel.exception.SystemException { 1017 return getPersistence().findAll(); 1018 } 1019 1020 /** 1021 * Returns a range of all the announcements entries. 1022 * 1023 * <p> 1024 * 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. 1025 * </p> 1026 * 1027 * @param start the lower bound of the range of announcements entries 1028 * @param end the upper bound of the range of announcements entries (not inclusive) 1029 * @return the range of announcements entries 1030 * @throws SystemException if a system exception occurred 1031 */ 1032 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1033 int start, int end) 1034 throws com.liferay.portal.kernel.exception.SystemException { 1035 return getPersistence().findAll(start, end); 1036 } 1037 1038 /** 1039 * Returns an ordered range of all the announcements entries. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1043 * </p> 1044 * 1045 * @param start the lower bound of the range of announcements entries 1046 * @param end the upper bound of the range of announcements entries (not inclusive) 1047 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1048 * @return the ordered range of announcements entries 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1052 int start, int end, 1053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1054 throws com.liferay.portal.kernel.exception.SystemException { 1055 return getPersistence().findAll(start, end, orderByComparator); 1056 } 1057 1058 /** 1059 * Removes all the announcements entries where uuid = ? from the database. 1060 * 1061 * @param uuid the uuid 1062 * @throws SystemException if a system exception occurred 1063 */ 1064 public static void removeByUuid(java.lang.String uuid) 1065 throws com.liferay.portal.kernel.exception.SystemException { 1066 getPersistence().removeByUuid(uuid); 1067 } 1068 1069 /** 1070 * Removes all the announcements entries where userId = ? from the database. 1071 * 1072 * @param userId the user ID 1073 * @throws SystemException if a system exception occurred 1074 */ 1075 public static void removeByUserId(long userId) 1076 throws com.liferay.portal.kernel.exception.SystemException { 1077 getPersistence().removeByUserId(userId); 1078 } 1079 1080 /** 1081 * Removes all the announcements entries where classNameId = ? and classPK = ? from the database. 1082 * 1083 * @param classNameId the class name ID 1084 * @param classPK the class p k 1085 * @throws SystemException if a system exception occurred 1086 */ 1087 public static void removeByC_C(long classNameId, long classPK) 1088 throws com.liferay.portal.kernel.exception.SystemException { 1089 getPersistence().removeByC_C(classNameId, classPK); 1090 } 1091 1092 /** 1093 * Removes all the announcements entries where classNameId = ? and classPK = ? and alert = ? from the database. 1094 * 1095 * @param classNameId the class name ID 1096 * @param classPK the class p k 1097 * @param alert the alert 1098 * @throws SystemException if a system exception occurred 1099 */ 1100 public static void removeByC_C_A(long classNameId, long classPK, 1101 boolean alert) 1102 throws com.liferay.portal.kernel.exception.SystemException { 1103 getPersistence().removeByC_C_A(classNameId, classPK, alert); 1104 } 1105 1106 /** 1107 * Removes all the announcements entries from the database. 1108 * 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static void removeAll() 1112 throws com.liferay.portal.kernel.exception.SystemException { 1113 getPersistence().removeAll(); 1114 } 1115 1116 /** 1117 * Returns the number of announcements entries where uuid = ?. 1118 * 1119 * @param uuid the uuid 1120 * @return the number of matching announcements entries 1121 * @throws SystemException if a system exception occurred 1122 */ 1123 public static int countByUuid(java.lang.String uuid) 1124 throws com.liferay.portal.kernel.exception.SystemException { 1125 return getPersistence().countByUuid(uuid); 1126 } 1127 1128 /** 1129 * Returns the number of announcements entries that the user has permission to view where uuid = ?. 1130 * 1131 * @param uuid the uuid 1132 * @return the number of matching announcements entries that the user has permission to view 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static int filterCountByUuid(java.lang.String uuid) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 return getPersistence().filterCountByUuid(uuid); 1138 } 1139 1140 /** 1141 * Returns the number of announcements entries where userId = ?. 1142 * 1143 * @param userId the user ID 1144 * @return the number of matching announcements entries 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static int countByUserId(long userId) 1148 throws com.liferay.portal.kernel.exception.SystemException { 1149 return getPersistence().countByUserId(userId); 1150 } 1151 1152 /** 1153 * Returns the number of announcements entries that the user has permission to view where userId = ?. 1154 * 1155 * @param userId the user ID 1156 * @return the number of matching announcements entries that the user has permission to view 1157 * @throws SystemException if a system exception occurred 1158 */ 1159 public static int filterCountByUserId(long userId) 1160 throws com.liferay.portal.kernel.exception.SystemException { 1161 return getPersistence().filterCountByUserId(userId); 1162 } 1163 1164 /** 1165 * Returns the number of announcements entries where classNameId = ? and classPK = ?. 1166 * 1167 * @param classNameId the class name ID 1168 * @param classPK the class p k 1169 * @return the number of matching announcements entries 1170 * @throws SystemException if a system exception occurred 1171 */ 1172 public static int countByC_C(long classNameId, long classPK) 1173 throws com.liferay.portal.kernel.exception.SystemException { 1174 return getPersistence().countByC_C(classNameId, classPK); 1175 } 1176 1177 /** 1178 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 1179 * 1180 * @param classNameId the class name ID 1181 * @param classPK the class p k 1182 * @return the number of matching announcements entries that the user has permission to view 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public static int filterCountByC_C(long classNameId, long classPK) 1186 throws com.liferay.portal.kernel.exception.SystemException { 1187 return getPersistence().filterCountByC_C(classNameId, classPK); 1188 } 1189 1190 /** 1191 * Returns the number of announcements entries where classNameId = ? and classPK = ? and alert = ?. 1192 * 1193 * @param classNameId the class name ID 1194 * @param classPK the class p k 1195 * @param alert the alert 1196 * @return the number of matching announcements entries 1197 * @throws SystemException if a system exception occurred 1198 */ 1199 public static int countByC_C_A(long classNameId, long classPK, boolean alert) 1200 throws com.liferay.portal.kernel.exception.SystemException { 1201 return getPersistence().countByC_C_A(classNameId, classPK, alert); 1202 } 1203 1204 /** 1205 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 1206 * 1207 * @param classNameId the class name ID 1208 * @param classPK the class p k 1209 * @param alert the alert 1210 * @return the number of matching announcements entries that the user has permission to view 1211 * @throws SystemException if a system exception occurred 1212 */ 1213 public static int filterCountByC_C_A(long classNameId, long classPK, 1214 boolean alert) 1215 throws com.liferay.portal.kernel.exception.SystemException { 1216 return getPersistence().filterCountByC_C_A(classNameId, classPK, alert); 1217 } 1218 1219 /** 1220 * Returns the number of announcements entries. 1221 * 1222 * @return the number of announcements entries 1223 * @throws SystemException if a system exception occurred 1224 */ 1225 public static int countAll() 1226 throws com.liferay.portal.kernel.exception.SystemException { 1227 return getPersistence().countAll(); 1228 } 1229 1230 public static AnnouncementsEntryPersistence getPersistence() { 1231 if (_persistence == null) { 1232 _persistence = (AnnouncementsEntryPersistence)PortalBeanLocatorUtil.locate(AnnouncementsEntryPersistence.class.getName()); 1233 1234 ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class, 1235 "_persistence"); 1236 } 1237 1238 return _persistence; 1239 } 1240 1241 public void setPersistence(AnnouncementsEntryPersistence persistence) { 1242 _persistence = persistence; 1243 1244 ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class, 1245 "_persistence"); 1246 } 1247 1248 private static AnnouncementsEntryPersistence _persistence; 1249 }