001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 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 to cache 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 to cache 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 to remove 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 * Finds 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 to find 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 * Finds 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 to find 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 * Finds all the announcements entries where uuid = ?. 206 * 207 * @param uuid the uuid to search with 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 * Finds 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 to search with 225 * @param start the lower bound of the range of announcements entries to return 226 * @param end the upper bound of the range of announcements entries to return (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 * Finds 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 to search with 244 * @param start the lower bound of the range of announcements entries to return 245 * @param end the upper bound of the range of announcements entries to return (not inclusive) 246 * @param orderByComparator the comparator to order the results by 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 * Finds 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 to search with 265 * @param orderByComparator the comparator to order the set by 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 * Finds 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 to search with 286 * @param orderByComparator the comparator to order the set by 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 * Finds 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 to search with 308 * @param orderByComparator the comparator to order the set by 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 * Filters by the user's permissions and finds all the announcements entries where uuid = ?. 324 * 325 * @param uuid the uuid to search with 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 * Filters by the user's permissions and finds a range of all the announcements entries 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 to search with 343 * @param start the lower bound of the range of announcements entries to return 344 * @param end the upper bound of the range of announcements entries to return (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 * Filters by the user's permissions and finds an ordered range of all the announcements entries 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 to search with 362 * @param start the lower bound of the range of announcements entries to return 363 * @param end the upper bound of the range of announcements entries to return (not inclusive) 364 * @param orderByComparator the comparator to order the results by 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 * Filters the announcements entries before and after the current announcements entry in the ordered set where uuid = ?. 378 * 379 * <p> 380 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 381 * </p> 382 * 383 * @param entryId the primary key of the current announcements entry 384 * @param uuid the uuid to search with 385 * @param orderByComparator the comparator to order the set by 386 * @return the previous, current, and next announcements entry 387 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 388 * @throws SystemException if a system exception occurred 389 */ 390 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_PrevAndNext( 391 long entryId, java.lang.String uuid, 392 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 393 throws com.liferay.portal.kernel.exception.SystemException, 394 com.liferay.portlet.announcements.NoSuchEntryException { 395 return getPersistence() 396 .filterFindByUuid_PrevAndNext(entryId, uuid, 397 orderByComparator); 398 } 399 400 /** 401 * Finds all the announcements entries where userId = ?. 402 * 403 * @param userId the user ID to search with 404 * @return the matching announcements entries 405 * @throws SystemException if a system exception occurred 406 */ 407 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 408 long userId) throws com.liferay.portal.kernel.exception.SystemException { 409 return getPersistence().findByUserId(userId); 410 } 411 412 /** 413 * Finds a range of all the announcements entries where userId = ?. 414 * 415 * <p> 416 * 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. 417 * </p> 418 * 419 * @param userId the user ID to search with 420 * @param start the lower bound of the range of announcements entries to return 421 * @param end the upper bound of the range of announcements entries to return (not inclusive) 422 * @return the range of matching announcements entries 423 * @throws SystemException if a system exception occurred 424 */ 425 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 426 long userId, int start, int end) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 return getPersistence().findByUserId(userId, start, end); 429 } 430 431 /** 432 * Finds an ordered range of all the announcements entries where userId = ?. 433 * 434 * <p> 435 * 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. 436 * </p> 437 * 438 * @param userId the user ID to search with 439 * @param start the lower bound of the range of announcements entries to return 440 * @param end the upper bound of the range of announcements entries to return (not inclusive) 441 * @param orderByComparator the comparator to order the results by 442 * @return the ordered range of matching announcements entries 443 * @throws SystemException if a system exception occurred 444 */ 445 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 446 long userId, int start, int end, 447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 448 throws com.liferay.portal.kernel.exception.SystemException { 449 return getPersistence() 450 .findByUserId(userId, start, end, orderByComparator); 451 } 452 453 /** 454 * Finds the first announcements entry in the ordered set where userId = ?. 455 * 456 * <p> 457 * 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. 458 * </p> 459 * 460 * @param userId the user ID to search with 461 * @param orderByComparator the comparator to order the set by 462 * @return the first matching announcements entry 463 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_First( 467 long userId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException, 470 com.liferay.portlet.announcements.NoSuchEntryException { 471 return getPersistence().findByUserId_First(userId, orderByComparator); 472 } 473 474 /** 475 * Finds the last announcements entry in the ordered set where userId = ?. 476 * 477 * <p> 478 * 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. 479 * </p> 480 * 481 * @param userId the user ID to search with 482 * @param orderByComparator the comparator to order the set by 483 * @return the last matching announcements entry 484 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 485 * @throws SystemException if a system exception occurred 486 */ 487 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_Last( 488 long userId, 489 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 490 throws com.liferay.portal.kernel.exception.SystemException, 491 com.liferay.portlet.announcements.NoSuchEntryException { 492 return getPersistence().findByUserId_Last(userId, orderByComparator); 493 } 494 495 /** 496 * Finds the announcements entries before and after the current announcements entry in the ordered set where userId = ?. 497 * 498 * <p> 499 * 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. 500 * </p> 501 * 502 * @param entryId the primary key of the current announcements entry 503 * @param userId the user ID to search with 504 * @param orderByComparator the comparator to order the set by 505 * @return the previous, current, and next announcements entry 506 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 507 * @throws SystemException if a system exception occurred 508 */ 509 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUserId_PrevAndNext( 510 long entryId, long userId, 511 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 512 throws com.liferay.portal.kernel.exception.SystemException, 513 com.liferay.portlet.announcements.NoSuchEntryException { 514 return getPersistence() 515 .findByUserId_PrevAndNext(entryId, userId, orderByComparator); 516 } 517 518 /** 519 * Filters by the user's permissions and finds all the announcements entries where userId = ?. 520 * 521 * @param userId the user ID to search with 522 * @return the matching announcements entries that the user has permission to view 523 * @throws SystemException if a system exception occurred 524 */ 525 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 526 long userId) throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence().filterFindByUserId(userId); 528 } 529 530 /** 531 * Filters by the user's permissions and finds a range of all the announcements entries where userId = ?. 532 * 533 * <p> 534 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 535 * </p> 536 * 537 * @param userId the user ID to search with 538 * @param start the lower bound of the range of announcements entries to return 539 * @param end the upper bound of the range of announcements entries to return (not inclusive) 540 * @return the range of matching announcements entries that the user has permission to view 541 * @throws SystemException if a system exception occurred 542 */ 543 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 544 long userId, int start, int end) 545 throws com.liferay.portal.kernel.exception.SystemException { 546 return getPersistence().filterFindByUserId(userId, start, end); 547 } 548 549 /** 550 * Filters by the user's permissions and finds an ordered range of all the announcements entries where userId = ?. 551 * 552 * <p> 553 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 554 * </p> 555 * 556 * @param userId the user ID to search with 557 * @param start the lower bound of the range of announcements entries to return 558 * @param end the upper bound of the range of announcements entries to return (not inclusive) 559 * @param orderByComparator the comparator to order the results by 560 * @return the ordered range of matching announcements entries that the user has permission to view 561 * @throws SystemException if a system exception occurred 562 */ 563 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 564 long userId, int start, int end, 565 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 566 throws com.liferay.portal.kernel.exception.SystemException { 567 return getPersistence() 568 .filterFindByUserId(userId, start, end, orderByComparator); 569 } 570 571 /** 572 * Filters the announcements entries before and after the current announcements entry in the ordered set where userId = ?. 573 * 574 * <p> 575 * 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. 576 * </p> 577 * 578 * @param entryId the primary key of the current announcements entry 579 * @param userId the user ID to search with 580 * @param orderByComparator the comparator to order the set by 581 * @return the previous, current, and next announcements entry 582 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 583 * @throws SystemException if a system exception occurred 584 */ 585 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUserId_PrevAndNext( 586 long entryId, long userId, 587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 588 throws com.liferay.portal.kernel.exception.SystemException, 589 com.liferay.portlet.announcements.NoSuchEntryException { 590 return getPersistence() 591 .filterFindByUserId_PrevAndNext(entryId, userId, 592 orderByComparator); 593 } 594 595 /** 596 * Finds all the announcements entries where classNameId = ? and classPK = ?. 597 * 598 * @param classNameId the class name ID to search with 599 * @param classPK the class p k to search with 600 * @return the matching announcements entries 601 * @throws SystemException if a system exception occurred 602 */ 603 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 604 long classNameId, long classPK) 605 throws com.liferay.portal.kernel.exception.SystemException { 606 return getPersistence().findByC_C(classNameId, classPK); 607 } 608 609 /** 610 * Finds a range of all the announcements entries where classNameId = ? and classPK = ?. 611 * 612 * <p> 613 * 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. 614 * </p> 615 * 616 * @param classNameId the class name ID to search with 617 * @param classPK the class p k to search with 618 * @param start the lower bound of the range of announcements entries to return 619 * @param end the upper bound of the range of announcements entries to return (not inclusive) 620 * @return the range of matching announcements entries 621 * @throws SystemException if a system exception occurred 622 */ 623 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 624 long classNameId, long classPK, int start, int end) 625 throws com.liferay.portal.kernel.exception.SystemException { 626 return getPersistence().findByC_C(classNameId, classPK, start, end); 627 } 628 629 /** 630 * Finds an ordered range of all the announcements entries where classNameId = ? and classPK = ?. 631 * 632 * <p> 633 * 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. 634 * </p> 635 * 636 * @param classNameId the class name ID to search with 637 * @param classPK the class p k to search with 638 * @param start the lower bound of the range of announcements entries to return 639 * @param end the upper bound of the range of announcements entries to return (not inclusive) 640 * @param orderByComparator the comparator to order the results by 641 * @return the ordered range of matching announcements entries 642 * @throws SystemException if a system exception occurred 643 */ 644 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 645 long classNameId, long classPK, int start, int end, 646 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 647 throws com.liferay.portal.kernel.exception.SystemException { 648 return getPersistence() 649 .findByC_C(classNameId, classPK, start, end, 650 orderByComparator); 651 } 652 653 /** 654 * Finds the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 655 * 656 * <p> 657 * 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. 658 * </p> 659 * 660 * @param classNameId the class name ID to search with 661 * @param classPK the class p k to search with 662 * @param orderByComparator the comparator to order the set by 663 * @return the first matching announcements entry 664 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 665 * @throws SystemException if a system exception occurred 666 */ 667 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_First( 668 long classNameId, long classPK, 669 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 670 throws com.liferay.portal.kernel.exception.SystemException, 671 com.liferay.portlet.announcements.NoSuchEntryException { 672 return getPersistence() 673 .findByC_C_First(classNameId, classPK, orderByComparator); 674 } 675 676 /** 677 * Finds the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 678 * 679 * <p> 680 * 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. 681 * </p> 682 * 683 * @param classNameId the class name ID to search with 684 * @param classPK the class p k to search with 685 * @param orderByComparator the comparator to order the set by 686 * @return the last matching announcements entry 687 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 688 * @throws SystemException if a system exception occurred 689 */ 690 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_Last( 691 long classNameId, long classPK, 692 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 693 throws com.liferay.portal.kernel.exception.SystemException, 694 com.liferay.portlet.announcements.NoSuchEntryException { 695 return getPersistence() 696 .findByC_C_Last(classNameId, classPK, orderByComparator); 697 } 698 699 /** 700 * Finds the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ?. 701 * 702 * <p> 703 * 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. 704 * </p> 705 * 706 * @param entryId the primary key of the current announcements entry 707 * @param classNameId the class name ID to search with 708 * @param classPK the class p k to search with 709 * @param orderByComparator the comparator to order the set by 710 * @return the previous, current, and next announcements entry 711 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 712 * @throws SystemException if a system exception occurred 713 */ 714 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_PrevAndNext( 715 long entryId, long classNameId, long classPK, 716 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 717 throws com.liferay.portal.kernel.exception.SystemException, 718 com.liferay.portlet.announcements.NoSuchEntryException { 719 return getPersistence() 720 .findByC_C_PrevAndNext(entryId, classNameId, classPK, 721 orderByComparator); 722 } 723 724 /** 725 * Filters by the user's permissions and finds all the announcements entries where classNameId = ? and classPK = ?. 726 * 727 * @param classNameId the class name ID to search with 728 * @param classPK the class p k to search with 729 * @return the matching announcements entries that the user has permission to view 730 * @throws SystemException if a system exception occurred 731 */ 732 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 733 long classNameId, long classPK) 734 throws com.liferay.portal.kernel.exception.SystemException { 735 return getPersistence().filterFindByC_C(classNameId, classPK); 736 } 737 738 /** 739 * Filters by the user's permissions and finds a range of all the announcements entries where classNameId = ? and classPK = ?. 740 * 741 * <p> 742 * 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. 743 * </p> 744 * 745 * @param classNameId the class name ID to search with 746 * @param classPK the class p k to search with 747 * @param start the lower bound of the range of announcements entries to return 748 * @param end the upper bound of the range of announcements entries to return (not inclusive) 749 * @return the range of matching announcements entries that the user has permission to view 750 * @throws SystemException if a system exception occurred 751 */ 752 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 753 long classNameId, long classPK, int start, int end) 754 throws com.liferay.portal.kernel.exception.SystemException { 755 return getPersistence().filterFindByC_C(classNameId, classPK, start, end); 756 } 757 758 /** 759 * Filters by the user's permissions and finds an ordered range of all the announcements entries where classNameId = ? and classPK = ?. 760 * 761 * <p> 762 * 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. 763 * </p> 764 * 765 * @param classNameId the class name ID to search with 766 * @param classPK the class p k to search with 767 * @param start the lower bound of the range of announcements entries to return 768 * @param end the upper bound of the range of announcements entries to return (not inclusive) 769 * @param orderByComparator the comparator to order the results by 770 * @return the ordered range of matching announcements entries that the user has permission to view 771 * @throws SystemException if a system exception occurred 772 */ 773 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 774 long classNameId, long classPK, int start, int end, 775 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence() 778 .filterFindByC_C(classNameId, classPK, start, end, 779 orderByComparator); 780 } 781 782 /** 783 * Filters the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ?. 784 * 785 * <p> 786 * 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. 787 * </p> 788 * 789 * @param entryId the primary key of the current announcements entry 790 * @param classNameId the class name ID to search with 791 * @param classPK the class p k to search with 792 * @param orderByComparator the comparator to order the set by 793 * @return the previous, current, and next announcements entry 794 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 795 * @throws SystemException if a system exception occurred 796 */ 797 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_PrevAndNext( 798 long entryId, long classNameId, long classPK, 799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 800 throws com.liferay.portal.kernel.exception.SystemException, 801 com.liferay.portlet.announcements.NoSuchEntryException { 802 return getPersistence() 803 .filterFindByC_C_PrevAndNext(entryId, classNameId, classPK, 804 orderByComparator); 805 } 806 807 /** 808 * Finds all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 809 * 810 * @param classNameId the class name ID to search with 811 * @param classPK the class p k to search with 812 * @param alert the alert to search with 813 * @return the matching announcements entries 814 * @throws SystemException if a system exception occurred 815 */ 816 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 817 long classNameId, long classPK, boolean alert) 818 throws com.liferay.portal.kernel.exception.SystemException { 819 return getPersistence().findByC_C_A(classNameId, classPK, alert); 820 } 821 822 /** 823 * Finds a range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 824 * 825 * <p> 826 * 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. 827 * </p> 828 * 829 * @param classNameId the class name ID to search with 830 * @param classPK the class p k to search with 831 * @param alert the alert to search with 832 * @param start the lower bound of the range of announcements entries to return 833 * @param end the upper bound of the range of announcements entries to return (not inclusive) 834 * @return the range of matching announcements entries 835 * @throws SystemException if a system exception occurred 836 */ 837 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 838 long classNameId, long classPK, boolean alert, int start, int end) 839 throws com.liferay.portal.kernel.exception.SystemException { 840 return getPersistence() 841 .findByC_C_A(classNameId, classPK, alert, start, end); 842 } 843 844 /** 845 * Finds an ordered range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 846 * 847 * <p> 848 * 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. 849 * </p> 850 * 851 * @param classNameId the class name ID to search with 852 * @param classPK the class p k to search with 853 * @param alert the alert to search with 854 * @param start the lower bound of the range of announcements entries to return 855 * @param end the upper bound of the range of announcements entries to return (not inclusive) 856 * @param orderByComparator the comparator to order the results by 857 * @return the ordered range of matching announcements entries 858 * @throws SystemException if a system exception occurred 859 */ 860 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 861 long classNameId, long classPK, boolean alert, int start, int end, 862 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 863 throws com.liferay.portal.kernel.exception.SystemException { 864 return getPersistence() 865 .findByC_C_A(classNameId, classPK, alert, start, end, 866 orderByComparator); 867 } 868 869 /** 870 * Finds the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 871 * 872 * <p> 873 * 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. 874 * </p> 875 * 876 * @param classNameId the class name ID to search with 877 * @param classPK the class p k to search with 878 * @param alert the alert to search with 879 * @param orderByComparator the comparator to order the set by 880 * @return the first matching announcements entry 881 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 882 * @throws SystemException if a system exception occurred 883 */ 884 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_First( 885 long classNameId, long classPK, boolean alert, 886 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 887 throws com.liferay.portal.kernel.exception.SystemException, 888 com.liferay.portlet.announcements.NoSuchEntryException { 889 return getPersistence() 890 .findByC_C_A_First(classNameId, classPK, alert, 891 orderByComparator); 892 } 893 894 /** 895 * Finds the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 896 * 897 * <p> 898 * 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. 899 * </p> 900 * 901 * @param classNameId the class name ID to search with 902 * @param classPK the class p k to search with 903 * @param alert the alert to search with 904 * @param orderByComparator the comparator to order the set by 905 * @return the last matching announcements entry 906 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 907 * @throws SystemException if a system exception occurred 908 */ 909 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_Last( 910 long classNameId, long classPK, boolean alert, 911 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 912 throws com.liferay.portal.kernel.exception.SystemException, 913 com.liferay.portlet.announcements.NoSuchEntryException { 914 return getPersistence() 915 .findByC_C_A_Last(classNameId, classPK, alert, 916 orderByComparator); 917 } 918 919 /** 920 * Finds the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 921 * 922 * <p> 923 * 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. 924 * </p> 925 * 926 * @param entryId the primary key of the current announcements entry 927 * @param classNameId the class name ID to search with 928 * @param classPK the class p k to search with 929 * @param alert the alert to search with 930 * @param orderByComparator the comparator to order the set by 931 * @return the previous, current, and next announcements entry 932 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 933 * @throws SystemException if a system exception occurred 934 */ 935 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_A_PrevAndNext( 936 long entryId, long classNameId, long classPK, boolean alert, 937 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 938 throws com.liferay.portal.kernel.exception.SystemException, 939 com.liferay.portlet.announcements.NoSuchEntryException { 940 return getPersistence() 941 .findByC_C_A_PrevAndNext(entryId, classNameId, classPK, 942 alert, orderByComparator); 943 } 944 945 /** 946 * Filters by the user's permissions and finds all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 947 * 948 * @param classNameId the class name ID to search with 949 * @param classPK the class p k to search with 950 * @param alert the alert to search with 951 * @return the matching announcements entries that the user has permission to view 952 * @throws SystemException if a system exception occurred 953 */ 954 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 955 long classNameId, long classPK, boolean alert) 956 throws com.liferay.portal.kernel.exception.SystemException { 957 return getPersistence().filterFindByC_C_A(classNameId, classPK, alert); 958 } 959 960 /** 961 * Filters by the user's permissions and finds a range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 962 * 963 * <p> 964 * 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. 965 * </p> 966 * 967 * @param classNameId the class name ID to search with 968 * @param classPK the class p k to search with 969 * @param alert the alert to search with 970 * @param start the lower bound of the range of announcements entries to return 971 * @param end the upper bound of the range of announcements entries to return (not inclusive) 972 * @return the range of matching announcements entries that the user has permission to view 973 * @throws SystemException if a system exception occurred 974 */ 975 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 976 long classNameId, long classPK, boolean alert, int start, int end) 977 throws com.liferay.portal.kernel.exception.SystemException { 978 return getPersistence() 979 .filterFindByC_C_A(classNameId, classPK, alert, start, end); 980 } 981 982 /** 983 * Filters by the user's permissions and finds an ordered range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 984 * 985 * <p> 986 * 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. 987 * </p> 988 * 989 * @param classNameId the class name ID to search with 990 * @param classPK the class p k to search with 991 * @param alert the alert to search with 992 * @param start the lower bound of the range of announcements entries to return 993 * @param end the upper bound of the range of announcements entries to return (not inclusive) 994 * @param orderByComparator the comparator to order the results by 995 * @return the ordered range of matching announcements entries that the user has permission to view 996 * @throws SystemException if a system exception occurred 997 */ 998 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 999 long classNameId, long classPK, boolean alert, int start, int end, 1000 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1001 throws com.liferay.portal.kernel.exception.SystemException { 1002 return getPersistence() 1003 .filterFindByC_C_A(classNameId, classPK, alert, start, end, 1004 orderByComparator); 1005 } 1006 1007 /** 1008 * Filters the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1009 * 1010 * <p> 1011 * 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. 1012 * </p> 1013 * 1014 * @param entryId the primary key of the current announcements entry 1015 * @param classNameId the class name ID to search with 1016 * @param classPK the class p k to search with 1017 * @param alert the alert to search with 1018 * @param orderByComparator the comparator to order the set by 1019 * @return the previous, current, and next announcements entry 1020 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1021 * @throws SystemException if a system exception occurred 1022 */ 1023 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext( 1024 long entryId, long classNameId, long classPK, boolean alert, 1025 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1026 throws com.liferay.portal.kernel.exception.SystemException, 1027 com.liferay.portlet.announcements.NoSuchEntryException { 1028 return getPersistence() 1029 .filterFindByC_C_A_PrevAndNext(entryId, classNameId, 1030 classPK, alert, orderByComparator); 1031 } 1032 1033 /** 1034 * Finds all the announcements entries. 1035 * 1036 * @return the announcements entries 1037 * @throws SystemException if a system exception occurred 1038 */ 1039 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll() 1040 throws com.liferay.portal.kernel.exception.SystemException { 1041 return getPersistence().findAll(); 1042 } 1043 1044 /** 1045 * Finds a range of all the announcements entries. 1046 * 1047 * <p> 1048 * 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. 1049 * </p> 1050 * 1051 * @param start the lower bound of the range of announcements entries to return 1052 * @param end the upper bound of the range of announcements entries to return (not inclusive) 1053 * @return the range of announcements entries 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1057 int start, int end) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 return getPersistence().findAll(start, end); 1060 } 1061 1062 /** 1063 * Finds an ordered range of all the announcements entries. 1064 * 1065 * <p> 1066 * 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. 1067 * </p> 1068 * 1069 * @param start the lower bound of the range of announcements entries to return 1070 * @param end the upper bound of the range of announcements entries to return (not inclusive) 1071 * @param orderByComparator the comparator to order the results by 1072 * @return the ordered range of announcements entries 1073 * @throws SystemException if a system exception occurred 1074 */ 1075 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1076 int start, int end, 1077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1078 throws com.liferay.portal.kernel.exception.SystemException { 1079 return getPersistence().findAll(start, end, orderByComparator); 1080 } 1081 1082 /** 1083 * Removes all the announcements entries where uuid = ? from the database. 1084 * 1085 * @param uuid the uuid to search with 1086 * @throws SystemException if a system exception occurred 1087 */ 1088 public static void removeByUuid(java.lang.String uuid) 1089 throws com.liferay.portal.kernel.exception.SystemException { 1090 getPersistence().removeByUuid(uuid); 1091 } 1092 1093 /** 1094 * Removes all the announcements entries where userId = ? from the database. 1095 * 1096 * @param userId the user ID to search with 1097 * @throws SystemException if a system exception occurred 1098 */ 1099 public static void removeByUserId(long userId) 1100 throws com.liferay.portal.kernel.exception.SystemException { 1101 getPersistence().removeByUserId(userId); 1102 } 1103 1104 /** 1105 * Removes all the announcements entries where classNameId = ? and classPK = ? from the database. 1106 * 1107 * @param classNameId the class name ID to search with 1108 * @param classPK the class p k to search with 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static void removeByC_C(long classNameId, long classPK) 1112 throws com.liferay.portal.kernel.exception.SystemException { 1113 getPersistence().removeByC_C(classNameId, classPK); 1114 } 1115 1116 /** 1117 * Removes all the announcements entries where classNameId = ? and classPK = ? and alert = ? from the database. 1118 * 1119 * @param classNameId the class name ID to search with 1120 * @param classPK the class p k to search with 1121 * @param alert the alert to search with 1122 * @throws SystemException if a system exception occurred 1123 */ 1124 public static void removeByC_C_A(long classNameId, long classPK, 1125 boolean alert) 1126 throws com.liferay.portal.kernel.exception.SystemException { 1127 getPersistence().removeByC_C_A(classNameId, classPK, alert); 1128 } 1129 1130 /** 1131 * Removes all the announcements entries from the database. 1132 * 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static void removeAll() 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 getPersistence().removeAll(); 1138 } 1139 1140 /** 1141 * Counts all the announcements entries where uuid = ?. 1142 * 1143 * @param uuid the uuid to search with 1144 * @return the number of matching announcements entries 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static int countByUuid(java.lang.String uuid) 1148 throws com.liferay.portal.kernel.exception.SystemException { 1149 return getPersistence().countByUuid(uuid); 1150 } 1151 1152 /** 1153 * Filters by the user's permissions and counts all the announcements entries where uuid = ?. 1154 * 1155 * @param uuid the uuid to search with 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 filterCountByUuid(java.lang.String uuid) 1160 throws com.liferay.portal.kernel.exception.SystemException { 1161 return getPersistence().filterCountByUuid(uuid); 1162 } 1163 1164 /** 1165 * Counts all the announcements entries where userId = ?. 1166 * 1167 * @param userId the user ID to search with 1168 * @return the number of matching announcements entries 1169 * @throws SystemException if a system exception occurred 1170 */ 1171 public static int countByUserId(long userId) 1172 throws com.liferay.portal.kernel.exception.SystemException { 1173 return getPersistence().countByUserId(userId); 1174 } 1175 1176 /** 1177 * Filters by the user's permissions and counts all the announcements entries where userId = ?. 1178 * 1179 * @param userId the user ID to search with 1180 * @return the number of matching announcements entries that the user has permission to view 1181 * @throws SystemException if a system exception occurred 1182 */ 1183 public static int filterCountByUserId(long userId) 1184 throws com.liferay.portal.kernel.exception.SystemException { 1185 return getPersistence().filterCountByUserId(userId); 1186 } 1187 1188 /** 1189 * Counts all the announcements entries where classNameId = ? and classPK = ?. 1190 * 1191 * @param classNameId the class name ID to search with 1192 * @param classPK the class p k to search with 1193 * @return the number of matching announcements entries 1194 * @throws SystemException if a system exception occurred 1195 */ 1196 public static int countByC_C(long classNameId, long classPK) 1197 throws com.liferay.portal.kernel.exception.SystemException { 1198 return getPersistence().countByC_C(classNameId, classPK); 1199 } 1200 1201 /** 1202 * Filters by the user's permissions and counts all the announcements entries where classNameId = ? and classPK = ?. 1203 * 1204 * @param classNameId the class name ID to search with 1205 * @param classPK the class p k to search with 1206 * @return the number of matching announcements entries that the user has permission to view 1207 * @throws SystemException if a system exception occurred 1208 */ 1209 public static int filterCountByC_C(long classNameId, long classPK) 1210 throws com.liferay.portal.kernel.exception.SystemException { 1211 return getPersistence().filterCountByC_C(classNameId, classPK); 1212 } 1213 1214 /** 1215 * Counts all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 1216 * 1217 * @param classNameId the class name ID to search with 1218 * @param classPK the class p k to search with 1219 * @param alert the alert to search with 1220 * @return the number of matching announcements entries 1221 * @throws SystemException if a system exception occurred 1222 */ 1223 public static int countByC_C_A(long classNameId, long classPK, boolean alert) 1224 throws com.liferay.portal.kernel.exception.SystemException { 1225 return getPersistence().countByC_C_A(classNameId, classPK, alert); 1226 } 1227 1228 /** 1229 * Filters by the user's permissions and counts all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 1230 * 1231 * @param classNameId the class name ID to search with 1232 * @param classPK the class p k to search with 1233 * @param alert the alert to search with 1234 * @return the number of matching announcements entries that the user has permission to view 1235 * @throws SystemException if a system exception occurred 1236 */ 1237 public static int filterCountByC_C_A(long classNameId, long classPK, 1238 boolean alert) 1239 throws com.liferay.portal.kernel.exception.SystemException { 1240 return getPersistence().filterCountByC_C_A(classNameId, classPK, alert); 1241 } 1242 1243 /** 1244 * Counts all the announcements entries. 1245 * 1246 * @return the number of announcements entries 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public static int countAll() 1250 throws com.liferay.portal.kernel.exception.SystemException { 1251 return getPersistence().countAll(); 1252 } 1253 1254 public static AnnouncementsEntryPersistence getPersistence() { 1255 if (_persistence == null) { 1256 _persistence = (AnnouncementsEntryPersistence)PortalBeanLocatorUtil.locate(AnnouncementsEntryPersistence.class.getName()); 1257 1258 ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class, 1259 "_persistence"); 1260 } 1261 1262 return _persistence; 1263 } 1264 1265 public void setPersistence(AnnouncementsEntryPersistence persistence) { 1266 _persistence = persistence; 1267 1268 ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class, 1269 "_persistence"); 1270 } 1271 1272 private static AnnouncementsEntryPersistence _persistence; 1273 }