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