001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.announcements.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.announcements.model.AnnouncementsEntry; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the announcements entry service. This utility wraps {@link AnnouncementsEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see AnnouncementsEntryPersistence 037 * @see AnnouncementsEntryPersistenceImpl 038 * @generated 039 */ 040 public class AnnouncementsEntryUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(AnnouncementsEntry announcementsEntry) { 058 getPersistence().clearCache(announcementsEntry); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<AnnouncementsEntry> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<AnnouncementsEntry> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AnnouncementsEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AnnouncementsEntry update( 101 AnnouncementsEntry announcementsEntry) throws SystemException { 102 return getPersistence().update(announcementsEntry); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static AnnouncementsEntry update( 109 AnnouncementsEntry announcementsEntry, ServiceContext serviceContext) 110 throws SystemException { 111 return getPersistence().update(announcementsEntry, serviceContext); 112 } 113 114 /** 115 * Returns all the announcements entries where uuid = ?. 116 * 117 * @param uuid the uuid 118 * @return the matching announcements entries 119 * @throws SystemException if a system exception occurred 120 */ 121 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 122 java.lang.String uuid) 123 throws com.liferay.portal.kernel.exception.SystemException { 124 return getPersistence().findByUuid(uuid); 125 } 126 127 /** 128 * Returns a range of all the announcements entries where uuid = ?. 129 * 130 * <p> 131 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 132 * </p> 133 * 134 * @param uuid the uuid 135 * @param start the lower bound of the range of announcements entries 136 * @param end the upper bound of the range of announcements entries (not inclusive) 137 * @return the range of matching announcements entries 138 * @throws SystemException if a system exception occurred 139 */ 140 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 141 java.lang.String uuid, int start, int end) 142 throws com.liferay.portal.kernel.exception.SystemException { 143 return getPersistence().findByUuid(uuid, start, end); 144 } 145 146 /** 147 * Returns an ordered range of all the announcements entries where uuid = ?. 148 * 149 * <p> 150 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 151 * </p> 152 * 153 * @param uuid the uuid 154 * @param start the lower bound of the range of announcements entries 155 * @param end the upper bound of the range of announcements entries (not inclusive) 156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 157 * @return the ordered range of matching announcements entries 158 * @throws SystemException if a system exception occurred 159 */ 160 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid( 161 java.lang.String uuid, int start, int end, 162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 165 } 166 167 /** 168 * Returns the first announcements entry in the ordered set where uuid = ?. 169 * 170 * @param uuid the uuid 171 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 172 * @return the first matching announcements entry 173 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 174 * @throws SystemException if a system exception occurred 175 */ 176 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_First( 177 java.lang.String uuid, 178 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 179 throws com.liferay.portal.kernel.exception.SystemException, 180 com.liferay.portlet.announcements.NoSuchEntryException { 181 return getPersistence().findByUuid_First(uuid, orderByComparator); 182 } 183 184 /** 185 * Returns the first announcements entry in the ordered set where uuid = ?. 186 * 187 * @param uuid the uuid 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 190 * @throws SystemException if a system exception occurred 191 */ 192 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUuid_First( 193 java.lang.String uuid, 194 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 195 throws com.liferay.portal.kernel.exception.SystemException { 196 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 197 } 198 199 /** 200 * Returns the last announcements entry in the ordered set where uuid = ?. 201 * 202 * @param uuid the uuid 203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 204 * @return the last matching announcements entry 205 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 206 * @throws SystemException if a system exception occurred 207 */ 208 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_Last( 209 java.lang.String uuid, 210 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 211 throws com.liferay.portal.kernel.exception.SystemException, 212 com.liferay.portlet.announcements.NoSuchEntryException { 213 return getPersistence().findByUuid_Last(uuid, orderByComparator); 214 } 215 216 /** 217 * Returns the last announcements entry in the ordered set where uuid = ?. 218 * 219 * @param uuid the uuid 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 222 * @throws SystemException if a system exception occurred 223 */ 224 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUuid_Last( 225 java.lang.String uuid, 226 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 227 throws com.liferay.portal.kernel.exception.SystemException { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = ?. 233 * 234 * @param entryId the primary key of the current announcements entry 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next announcements entry 238 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 239 * @throws SystemException if a system exception occurred 240 */ 241 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUuid_PrevAndNext( 242 long entryId, java.lang.String uuid, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException, 245 com.liferay.portlet.announcements.NoSuchEntryException { 246 return getPersistence() 247 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 248 } 249 250 /** 251 * Returns all the announcements entries that the user has permission to view where uuid = ?. 252 * 253 * @param uuid the uuid 254 * @return the matching announcements entries that the user has permission to view 255 * @throws SystemException if a system exception occurred 256 */ 257 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 258 java.lang.String uuid) 259 throws com.liferay.portal.kernel.exception.SystemException { 260 return getPersistence().filterFindByUuid(uuid); 261 } 262 263 /** 264 * Returns a range of all the announcements entries that the user has permission to view where uuid = ?. 265 * 266 * <p> 267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 268 * </p> 269 * 270 * @param uuid the uuid 271 * @param start the lower bound of the range of announcements entries 272 * @param end the upper bound of the range of announcements entries (not inclusive) 273 * @return the range of matching announcements entries that the user has permission to view 274 * @throws SystemException if a system exception occurred 275 */ 276 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 277 java.lang.String uuid, int start, int end) 278 throws com.liferay.portal.kernel.exception.SystemException { 279 return getPersistence().filterFindByUuid(uuid, start, end); 280 } 281 282 /** 283 * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = ?. 284 * 285 * <p> 286 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 287 * </p> 288 * 289 * @param uuid the uuid 290 * @param start the lower bound of the range of announcements entries 291 * @param end the upper bound of the range of announcements entries (not inclusive) 292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 293 * @return the ordered range of matching announcements entries that the user has permission to view 294 * @throws SystemException if a system exception occurred 295 */ 296 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid( 297 java.lang.String uuid, int start, int end, 298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 299 throws com.liferay.portal.kernel.exception.SystemException { 300 return getPersistence() 301 .filterFindByUuid(uuid, start, end, orderByComparator); 302 } 303 304 /** 305 * 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 = ?. 306 * 307 * @param entryId the primary key of the current announcements entry 308 * @param uuid the uuid 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the previous, current, and next announcements entry 311 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 312 * @throws SystemException if a system exception occurred 313 */ 314 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_PrevAndNext( 315 long entryId, java.lang.String uuid, 316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 317 throws com.liferay.portal.kernel.exception.SystemException, 318 com.liferay.portlet.announcements.NoSuchEntryException { 319 return getPersistence() 320 .filterFindByUuid_PrevAndNext(entryId, uuid, 321 orderByComparator); 322 } 323 324 /** 325 * Removes all the announcements entries where uuid = ? from the database. 326 * 327 * @param uuid the uuid 328 * @throws SystemException if a system exception occurred 329 */ 330 public static void removeByUuid(java.lang.String uuid) 331 throws com.liferay.portal.kernel.exception.SystemException { 332 getPersistence().removeByUuid(uuid); 333 } 334 335 /** 336 * Returns the number of announcements entries where uuid = ?. 337 * 338 * @param uuid the uuid 339 * @return the number of matching announcements entries 340 * @throws SystemException if a system exception occurred 341 */ 342 public static int countByUuid(java.lang.String uuid) 343 throws com.liferay.portal.kernel.exception.SystemException { 344 return getPersistence().countByUuid(uuid); 345 } 346 347 /** 348 * Returns the number of announcements entries that the user has permission to view where uuid = ?. 349 * 350 * @param uuid the uuid 351 * @return the number of matching announcements entries that the user has permission to view 352 * @throws SystemException if a system exception occurred 353 */ 354 public static int filterCountByUuid(java.lang.String uuid) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().filterCountByUuid(uuid); 357 } 358 359 /** 360 * Returns all the announcements entries where uuid = ? and companyId = ?. 361 * 362 * @param uuid the uuid 363 * @param companyId the company ID 364 * @return the matching announcements entries 365 * @throws SystemException if a system exception occurred 366 */ 367 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid_C( 368 java.lang.String uuid, long companyId) 369 throws com.liferay.portal.kernel.exception.SystemException { 370 return getPersistence().findByUuid_C(uuid, companyId); 371 } 372 373 /** 374 * Returns a range of all the announcements entries where uuid = ? and companyId = ?. 375 * 376 * <p> 377 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 378 * </p> 379 * 380 * @param uuid the uuid 381 * @param companyId the company ID 382 * @param start the lower bound of the range of announcements entries 383 * @param end the upper bound of the range of announcements entries (not inclusive) 384 * @return the range of matching announcements entries 385 * @throws SystemException if a system exception occurred 386 */ 387 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid_C( 388 java.lang.String uuid, long companyId, int start, int end) 389 throws com.liferay.portal.kernel.exception.SystemException { 390 return getPersistence().findByUuid_C(uuid, companyId, start, end); 391 } 392 393 /** 394 * Returns an ordered range of all the announcements entries where uuid = ? and companyId = ?. 395 * 396 * <p> 397 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 398 * </p> 399 * 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @param start the lower bound of the range of announcements entries 403 * @param end the upper bound of the range of announcements entries (not inclusive) 404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 405 * @return the ordered range of matching announcements entries 406 * @throws SystemException if a system exception occurred 407 */ 408 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid_C( 409 java.lang.String uuid, long companyId, int start, int end, 410 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 411 throws com.liferay.portal.kernel.exception.SystemException { 412 return getPersistence() 413 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 414 } 415 416 /** 417 * Returns the first announcements entry in the ordered set where uuid = ? and companyId = ?. 418 * 419 * @param uuid the uuid 420 * @param companyId the company ID 421 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 422 * @return the first matching announcements entry 423 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 424 * @throws SystemException if a system exception occurred 425 */ 426 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_C_First( 427 java.lang.String uuid, long companyId, 428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 429 throws com.liferay.portal.kernel.exception.SystemException, 430 com.liferay.portlet.announcements.NoSuchEntryException { 431 return getPersistence() 432 .findByUuid_C_First(uuid, companyId, orderByComparator); 433 } 434 435 /** 436 * Returns the first announcements entry in the ordered set where uuid = ? and companyId = ?. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 441 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 442 * @throws SystemException if a system exception occurred 443 */ 444 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUuid_C_First( 445 java.lang.String uuid, long companyId, 446 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 447 throws com.liferay.portal.kernel.exception.SystemException { 448 return getPersistence() 449 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 450 } 451 452 /** 453 * Returns the last announcements entry in the ordered set where uuid = ? and companyId = ?. 454 * 455 * @param uuid the uuid 456 * @param companyId the company ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the last 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 findByUuid_C_Last( 463 java.lang.String uuid, long companyId, 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() 468 .findByUuid_C_Last(uuid, companyId, orderByComparator); 469 } 470 471 /** 472 * Returns the last announcements entry in the ordered set where uuid = ? and companyId = ?. 473 * 474 * @param uuid the uuid 475 * @param companyId the company ID 476 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 477 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 478 * @throws SystemException if a system exception occurred 479 */ 480 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUuid_C_Last( 481 java.lang.String uuid, long companyId, 482 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 483 throws com.liferay.portal.kernel.exception.SystemException { 484 return getPersistence() 485 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 486 } 487 488 /** 489 * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = ? and companyId = ?. 490 * 491 * @param entryId the primary key of the current announcements entry 492 * @param uuid the uuid 493 * @param companyId the company ID 494 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 495 * @return the previous, current, and next announcements entry 496 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 497 * @throws SystemException if a system exception occurred 498 */ 499 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUuid_C_PrevAndNext( 500 long entryId, java.lang.String uuid, long companyId, 501 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 502 throws com.liferay.portal.kernel.exception.SystemException, 503 com.liferay.portlet.announcements.NoSuchEntryException { 504 return getPersistence() 505 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 506 orderByComparator); 507 } 508 509 /** 510 * Returns all the announcements entries that the user has permission to view where uuid = ? and companyId = ?. 511 * 512 * @param uuid the uuid 513 * @param companyId the company ID 514 * @return the matching announcements entries that the user has permission to view 515 * @throws SystemException if a system exception occurred 516 */ 517 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid_C( 518 java.lang.String uuid, long companyId) 519 throws com.liferay.portal.kernel.exception.SystemException { 520 return getPersistence().filterFindByUuid_C(uuid, companyId); 521 } 522 523 /** 524 * Returns a range of all the announcements entries that the user has permission to view where uuid = ? and companyId = ?. 525 * 526 * <p> 527 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 528 * </p> 529 * 530 * @param uuid the uuid 531 * @param companyId the company ID 532 * @param start the lower bound of the range of announcements entries 533 * @param end the upper bound of the range of announcements entries (not inclusive) 534 * @return the range of matching announcements entries that the user has permission to view 535 * @throws SystemException if a system exception occurred 536 */ 537 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid_C( 538 java.lang.String uuid, long companyId, int start, int end) 539 throws com.liferay.portal.kernel.exception.SystemException { 540 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 541 } 542 543 /** 544 * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = ? and companyId = ?. 545 * 546 * <p> 547 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 548 * </p> 549 * 550 * @param uuid the uuid 551 * @param companyId the company ID 552 * @param start the lower bound of the range of announcements entries 553 * @param end the upper bound of the range of announcements entries (not inclusive) 554 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 555 * @return the ordered range of matching announcements entries that the user has permission to view 556 * @throws SystemException if a system exception occurred 557 */ 558 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid_C( 559 java.lang.String uuid, long companyId, int start, int end, 560 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 561 throws com.liferay.portal.kernel.exception.SystemException { 562 return getPersistence() 563 .filterFindByUuid_C(uuid, companyId, start, end, 564 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 uuid = ? and companyId = ?. 569 * 570 * @param entryId the primary key of the current announcements entry 571 * @param uuid the uuid 572 * @param companyId the company ID 573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 574 * @return the previous, current, and next announcements entry 575 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 576 * @throws SystemException if a system exception occurred 577 */ 578 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_C_PrevAndNext( 579 long entryId, java.lang.String uuid, long companyId, 580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 581 throws com.liferay.portal.kernel.exception.SystemException, 582 com.liferay.portlet.announcements.NoSuchEntryException { 583 return getPersistence() 584 .filterFindByUuid_C_PrevAndNext(entryId, uuid, companyId, 585 orderByComparator); 586 } 587 588 /** 589 * Removes all the announcements entries where uuid = ? and companyId = ? from the database. 590 * 591 * @param uuid the uuid 592 * @param companyId the company ID 593 * @throws SystemException if a system exception occurred 594 */ 595 public static void removeByUuid_C(java.lang.String uuid, long companyId) 596 throws com.liferay.portal.kernel.exception.SystemException { 597 getPersistence().removeByUuid_C(uuid, companyId); 598 } 599 600 /** 601 * Returns the number of announcements entries where uuid = ? and companyId = ?. 602 * 603 * @param uuid the uuid 604 * @param companyId the company ID 605 * @return the number of matching announcements entries 606 * @throws SystemException if a system exception occurred 607 */ 608 public static int countByUuid_C(java.lang.String uuid, long companyId) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence().countByUuid_C(uuid, companyId); 611 } 612 613 /** 614 * Returns the number of announcements entries that the user has permission to view where uuid = ? and companyId = ?. 615 * 616 * @param uuid the uuid 617 * @param companyId the company ID 618 * @return the number of matching announcements entries that the user has permission to view 619 * @throws SystemException if a system exception occurred 620 */ 621 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) 622 throws com.liferay.portal.kernel.exception.SystemException { 623 return getPersistence().filterCountByUuid_C(uuid, companyId); 624 } 625 626 /** 627 * Returns all the announcements entries where userId = ?. 628 * 629 * @param userId the user ID 630 * @return the matching announcements entries 631 * @throws SystemException if a system exception occurred 632 */ 633 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 634 long userId) throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().findByUserId(userId); 636 } 637 638 /** 639 * Returns a range of all the announcements entries where userId = ?. 640 * 641 * <p> 642 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 643 * </p> 644 * 645 * @param userId the user ID 646 * @param start the lower bound of the range of announcements entries 647 * @param end the upper bound of the range of announcements entries (not inclusive) 648 * @return the range of matching announcements entries 649 * @throws SystemException if a system exception occurred 650 */ 651 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 652 long userId, int start, int end) 653 throws com.liferay.portal.kernel.exception.SystemException { 654 return getPersistence().findByUserId(userId, start, end); 655 } 656 657 /** 658 * Returns an ordered range of all the announcements entries where userId = ?. 659 * 660 * <p> 661 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 662 * </p> 663 * 664 * @param userId the user ID 665 * @param start the lower bound of the range of announcements entries 666 * @param end the upper bound of the range of announcements entries (not inclusive) 667 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 668 * @return the ordered range of matching announcements entries 669 * @throws SystemException if a system exception occurred 670 */ 671 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId( 672 long userId, int start, int end, 673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 return getPersistence() 676 .findByUserId(userId, start, end, orderByComparator); 677 } 678 679 /** 680 * Returns the first announcements entry in the ordered set where userId = ?. 681 * 682 * @param userId the user ID 683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 684 * @return the first matching announcements entry 685 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 686 * @throws SystemException if a system exception occurred 687 */ 688 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_First( 689 long userId, 690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 691 throws com.liferay.portal.kernel.exception.SystemException, 692 com.liferay.portlet.announcements.NoSuchEntryException { 693 return getPersistence().findByUserId_First(userId, orderByComparator); 694 } 695 696 /** 697 * Returns the first announcements entry in the ordered set where userId = ?. 698 * 699 * @param userId the user ID 700 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 701 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 702 * @throws SystemException if a system exception occurred 703 */ 704 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUserId_First( 705 long userId, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence().fetchByUserId_First(userId, orderByComparator); 709 } 710 711 /** 712 * Returns the last announcements entry in the ordered set where userId = ?. 713 * 714 * @param userId the user ID 715 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 716 * @return the last matching announcements entry 717 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 718 * @throws SystemException if a system exception occurred 719 */ 720 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_Last( 721 long userId, 722 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 723 throws com.liferay.portal.kernel.exception.SystemException, 724 com.liferay.portlet.announcements.NoSuchEntryException { 725 return getPersistence().findByUserId_Last(userId, orderByComparator); 726 } 727 728 /** 729 * Returns the last announcements entry in the ordered set where userId = ?. 730 * 731 * @param userId the user ID 732 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 733 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 734 * @throws SystemException if a system exception occurred 735 */ 736 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByUserId_Last( 737 long userId, 738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 739 throws com.liferay.portal.kernel.exception.SystemException { 740 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 741 } 742 743 /** 744 * Returns the announcements entries before and after the current announcements entry in the ordered set where userId = ?. 745 * 746 * @param entryId the primary key of the current announcements entry 747 * @param userId the user ID 748 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 749 * @return the previous, current, and next announcements entry 750 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 751 * @throws SystemException if a system exception occurred 752 */ 753 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUserId_PrevAndNext( 754 long entryId, long userId, 755 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 756 throws com.liferay.portal.kernel.exception.SystemException, 757 com.liferay.portlet.announcements.NoSuchEntryException { 758 return getPersistence() 759 .findByUserId_PrevAndNext(entryId, userId, orderByComparator); 760 } 761 762 /** 763 * Returns all the announcements entries that the user has permission to view where userId = ?. 764 * 765 * @param userId the user ID 766 * @return the matching announcements entries that the user has permission to view 767 * @throws SystemException if a system exception occurred 768 */ 769 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 770 long userId) throws com.liferay.portal.kernel.exception.SystemException { 771 return getPersistence().filterFindByUserId(userId); 772 } 773 774 /** 775 * Returns a range of all the announcements entries that the user has permission to view where userId = ?. 776 * 777 * <p> 778 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 779 * </p> 780 * 781 * @param userId the user ID 782 * @param start the lower bound of the range of announcements entries 783 * @param end the upper bound of the range of announcements entries (not inclusive) 784 * @return the range of matching announcements entries that the user has permission to view 785 * @throws SystemException if a system exception occurred 786 */ 787 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 788 long userId, int start, int end) 789 throws com.liferay.portal.kernel.exception.SystemException { 790 return getPersistence().filterFindByUserId(userId, start, end); 791 } 792 793 /** 794 * Returns an ordered range of all the announcements entries that the user has permissions to view where userId = ?. 795 * 796 * <p> 797 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 798 * </p> 799 * 800 * @param userId the user ID 801 * @param start the lower bound of the range of announcements entries 802 * @param end the upper bound of the range of announcements entries (not inclusive) 803 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 804 * @return the ordered range of matching announcements entries that the user has permission to view 805 * @throws SystemException if a system exception occurred 806 */ 807 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId( 808 long userId, int start, int end, 809 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 810 throws com.liferay.portal.kernel.exception.SystemException { 811 return getPersistence() 812 .filterFindByUserId(userId, start, end, orderByComparator); 813 } 814 815 /** 816 * 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 = ?. 817 * 818 * @param entryId the primary key of the current announcements entry 819 * @param userId the user ID 820 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 821 * @return the previous, current, and next announcements entry 822 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 823 * @throws SystemException if a system exception occurred 824 */ 825 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUserId_PrevAndNext( 826 long entryId, long userId, 827 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 828 throws com.liferay.portal.kernel.exception.SystemException, 829 com.liferay.portlet.announcements.NoSuchEntryException { 830 return getPersistence() 831 .filterFindByUserId_PrevAndNext(entryId, userId, 832 orderByComparator); 833 } 834 835 /** 836 * Removes all the announcements entries where userId = ? from the database. 837 * 838 * @param userId the user ID 839 * @throws SystemException if a system exception occurred 840 */ 841 public static void removeByUserId(long userId) 842 throws com.liferay.portal.kernel.exception.SystemException { 843 getPersistence().removeByUserId(userId); 844 } 845 846 /** 847 * Returns the number of announcements entries where userId = ?. 848 * 849 * @param userId the user ID 850 * @return the number of matching announcements entries 851 * @throws SystemException if a system exception occurred 852 */ 853 public static int countByUserId(long userId) 854 throws com.liferay.portal.kernel.exception.SystemException { 855 return getPersistence().countByUserId(userId); 856 } 857 858 /** 859 * Returns the number of announcements entries that the user has permission to view where userId = ?. 860 * 861 * @param userId the user ID 862 * @return the number of matching announcements entries that the user has permission to view 863 * @throws SystemException if a system exception occurred 864 */ 865 public static int filterCountByUserId(long userId) 866 throws com.liferay.portal.kernel.exception.SystemException { 867 return getPersistence().filterCountByUserId(userId); 868 } 869 870 /** 871 * Returns all the announcements entries where classNameId = ? and classPK = ?. 872 * 873 * @param classNameId the class name ID 874 * @param classPK the class p k 875 * @return the matching announcements entries 876 * @throws SystemException if a system exception occurred 877 */ 878 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 879 long classNameId, long classPK) 880 throws com.liferay.portal.kernel.exception.SystemException { 881 return getPersistence().findByC_C(classNameId, classPK); 882 } 883 884 /** 885 * Returns a range of all the announcements entries where classNameId = ? and classPK = ?. 886 * 887 * <p> 888 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 889 * </p> 890 * 891 * @param classNameId the class name ID 892 * @param classPK the class p k 893 * @param start the lower bound of the range of announcements entries 894 * @param end the upper bound of the range of announcements entries (not inclusive) 895 * @return the range of matching announcements entries 896 * @throws SystemException if a system exception occurred 897 */ 898 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 899 long classNameId, long classPK, int start, int end) 900 throws com.liferay.portal.kernel.exception.SystemException { 901 return getPersistence().findByC_C(classNameId, classPK, start, end); 902 } 903 904 /** 905 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ?. 906 * 907 * <p> 908 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 909 * </p> 910 * 911 * @param classNameId the class name ID 912 * @param classPK the class p k 913 * @param start the lower bound of the range of announcements entries 914 * @param end the upper bound of the range of announcements entries (not inclusive) 915 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 916 * @return the ordered range of matching announcements entries 917 * @throws SystemException if a system exception occurred 918 */ 919 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C( 920 long classNameId, long classPK, int start, int end, 921 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence() 924 .findByC_C(classNameId, classPK, start, end, 925 orderByComparator); 926 } 927 928 /** 929 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 930 * 931 * @param classNameId the class name ID 932 * @param classPK the class p k 933 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 934 * @return the first matching announcements entry 935 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 936 * @throws SystemException if a system exception occurred 937 */ 938 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_First( 939 long classNameId, long classPK, 940 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 941 throws com.liferay.portal.kernel.exception.SystemException, 942 com.liferay.portlet.announcements.NoSuchEntryException { 943 return getPersistence() 944 .findByC_C_First(classNameId, classPK, orderByComparator); 945 } 946 947 /** 948 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 949 * 950 * @param classNameId the class name ID 951 * @param classPK the class p k 952 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 953 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 954 * @throws SystemException if a system exception occurred 955 */ 956 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByC_C_First( 957 long classNameId, long classPK, 958 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 959 throws com.liferay.portal.kernel.exception.SystemException { 960 return getPersistence() 961 .fetchByC_C_First(classNameId, classPK, orderByComparator); 962 } 963 964 /** 965 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 966 * 967 * @param classNameId the class name ID 968 * @param classPK the class p k 969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 970 * @return the last matching announcements entry 971 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 972 * @throws SystemException if a system exception occurred 973 */ 974 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_Last( 975 long classNameId, long classPK, 976 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 977 throws com.liferay.portal.kernel.exception.SystemException, 978 com.liferay.portlet.announcements.NoSuchEntryException { 979 return getPersistence() 980 .findByC_C_Last(classNameId, classPK, orderByComparator); 981 } 982 983 /** 984 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 985 * 986 * @param classNameId the class name ID 987 * @param classPK the class p k 988 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 989 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 990 * @throws SystemException if a system exception occurred 991 */ 992 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByC_C_Last( 993 long classNameId, long classPK, 994 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 995 throws com.liferay.portal.kernel.exception.SystemException { 996 return getPersistence() 997 .fetchByC_C_Last(classNameId, classPK, orderByComparator); 998 } 999 1000 /** 1001 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ?. 1002 * 1003 * @param entryId the primary key of the current announcements entry 1004 * @param classNameId the class name ID 1005 * @param classPK the class p k 1006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1007 * @return the previous, current, and next announcements entry 1008 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1009 * @throws SystemException if a system exception occurred 1010 */ 1011 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_PrevAndNext( 1012 long entryId, long classNameId, long classPK, 1013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1014 throws com.liferay.portal.kernel.exception.SystemException, 1015 com.liferay.portlet.announcements.NoSuchEntryException { 1016 return getPersistence() 1017 .findByC_C_PrevAndNext(entryId, classNameId, classPK, 1018 orderByComparator); 1019 } 1020 1021 /** 1022 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 1023 * 1024 * @param classNameId the class name ID 1025 * @param classPK the class p k 1026 * @return the matching announcements entries that the user has permission to view 1027 * @throws SystemException if a system exception occurred 1028 */ 1029 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 1030 long classNameId, long classPK) 1031 throws com.liferay.portal.kernel.exception.SystemException { 1032 return getPersistence().filterFindByC_C(classNameId, classPK); 1033 } 1034 1035 /** 1036 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 1037 * 1038 * <p> 1039 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1040 * </p> 1041 * 1042 * @param classNameId the class name ID 1043 * @param classPK the class p k 1044 * @param start the lower bound of the range of announcements entries 1045 * @param end the upper bound of the range of announcements entries (not inclusive) 1046 * @return the range of matching announcements entries that the user has permission to view 1047 * @throws SystemException if a system exception occurred 1048 */ 1049 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 1050 long classNameId, long classPK, int start, int end) 1051 throws com.liferay.portal.kernel.exception.SystemException { 1052 return getPersistence().filterFindByC_C(classNameId, classPK, start, end); 1053 } 1054 1055 /** 1056 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ?. 1057 * 1058 * <p> 1059 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1060 * </p> 1061 * 1062 * @param classNameId the class name ID 1063 * @param classPK the class p k 1064 * @param start the lower bound of the range of announcements entries 1065 * @param end the upper bound of the range of announcements entries (not inclusive) 1066 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1067 * @return the ordered range of matching announcements entries that the user has permission to view 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C( 1071 long classNameId, long classPK, int start, int end, 1072 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1073 throws com.liferay.portal.kernel.exception.SystemException { 1074 return getPersistence() 1075 .filterFindByC_C(classNameId, classPK, start, end, 1076 orderByComparator); 1077 } 1078 1079 /** 1080 * 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 = ?. 1081 * 1082 * @param entryId the primary key of the current announcements entry 1083 * @param classNameId the class name ID 1084 * @param classPK the class p k 1085 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1086 * @return the previous, current, and next announcements entry 1087 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1088 * @throws SystemException if a system exception occurred 1089 */ 1090 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_PrevAndNext( 1091 long entryId, long classNameId, long classPK, 1092 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1093 throws com.liferay.portal.kernel.exception.SystemException, 1094 com.liferay.portlet.announcements.NoSuchEntryException { 1095 return getPersistence() 1096 .filterFindByC_C_PrevAndNext(entryId, classNameId, classPK, 1097 orderByComparator); 1098 } 1099 1100 /** 1101 * Removes all the announcements entries where classNameId = ? and classPK = ? from the database. 1102 * 1103 * @param classNameId the class name ID 1104 * @param classPK the class p k 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public static void removeByC_C(long classNameId, long classPK) 1108 throws com.liferay.portal.kernel.exception.SystemException { 1109 getPersistence().removeByC_C(classNameId, classPK); 1110 } 1111 1112 /** 1113 * Returns the number of announcements entries where classNameId = ? and classPK = ?. 1114 * 1115 * @param classNameId the class name ID 1116 * @param classPK the class p k 1117 * @return the number of matching announcements entries 1118 * @throws SystemException if a system exception occurred 1119 */ 1120 public static int countByC_C(long classNameId, long classPK) 1121 throws com.liferay.portal.kernel.exception.SystemException { 1122 return getPersistence().countByC_C(classNameId, classPK); 1123 } 1124 1125 /** 1126 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 1127 * 1128 * @param classNameId the class name ID 1129 * @param classPK the class p k 1130 * @return the number of matching announcements entries that the user has permission to view 1131 * @throws SystemException if a system exception occurred 1132 */ 1133 public static int filterCountByC_C(long classNameId, long classPK) 1134 throws com.liferay.portal.kernel.exception.SystemException { 1135 return getPersistence().filterCountByC_C(classNameId, classPK); 1136 } 1137 1138 /** 1139 * Returns all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 1140 * 1141 * @param classNameId the class name ID 1142 * @param classPK the class p k 1143 * @param alert the alert 1144 * @return the matching announcements entries 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 1148 long classNameId, long classPK, boolean alert) 1149 throws com.liferay.portal.kernel.exception.SystemException { 1150 return getPersistence().findByC_C_A(classNameId, classPK, alert); 1151 } 1152 1153 /** 1154 * Returns a range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 1155 * 1156 * <p> 1157 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1158 * </p> 1159 * 1160 * @param classNameId the class name ID 1161 * @param classPK the class p k 1162 * @param alert the alert 1163 * @param start the lower bound of the range of announcements entries 1164 * @param end the upper bound of the range of announcements entries (not inclusive) 1165 * @return the range of matching announcements entries 1166 * @throws SystemException if a system exception occurred 1167 */ 1168 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 1169 long classNameId, long classPK, boolean alert, int start, int end) 1170 throws com.liferay.portal.kernel.exception.SystemException { 1171 return getPersistence() 1172 .findByC_C_A(classNameId, classPK, alert, start, end); 1173 } 1174 1175 /** 1176 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 1177 * 1178 * <p> 1179 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1180 * </p> 1181 * 1182 * @param classNameId the class name ID 1183 * @param classPK the class p k 1184 * @param alert the alert 1185 * @param start the lower bound of the range of announcements entries 1186 * @param end the upper bound of the range of announcements entries (not inclusive) 1187 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1188 * @return the ordered range of matching announcements entries 1189 * @throws SystemException if a system exception occurred 1190 */ 1191 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A( 1192 long classNameId, long classPK, boolean alert, int start, int end, 1193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1194 throws com.liferay.portal.kernel.exception.SystemException { 1195 return getPersistence() 1196 .findByC_C_A(classNameId, classPK, alert, start, end, 1197 orderByComparator); 1198 } 1199 1200 /** 1201 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1202 * 1203 * @param classNameId the class name ID 1204 * @param classPK the class p k 1205 * @param alert the alert 1206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1207 * @return the first matching announcements entry 1208 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 1209 * @throws SystemException if a system exception occurred 1210 */ 1211 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_First( 1212 long classNameId, long classPK, boolean alert, 1213 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1214 throws com.liferay.portal.kernel.exception.SystemException, 1215 com.liferay.portlet.announcements.NoSuchEntryException { 1216 return getPersistence() 1217 .findByC_C_A_First(classNameId, classPK, alert, 1218 orderByComparator); 1219 } 1220 1221 /** 1222 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1223 * 1224 * @param classNameId the class name ID 1225 * @param classPK the class p k 1226 * @param alert the alert 1227 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1228 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 1229 * @throws SystemException if a system exception occurred 1230 */ 1231 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByC_C_A_First( 1232 long classNameId, long classPK, boolean alert, 1233 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1234 throws com.liferay.portal.kernel.exception.SystemException { 1235 return getPersistence() 1236 .fetchByC_C_A_First(classNameId, classPK, alert, 1237 orderByComparator); 1238 } 1239 1240 /** 1241 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1242 * 1243 * @param classNameId the class name ID 1244 * @param classPK the class p k 1245 * @param alert the alert 1246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1247 * @return the last matching announcements entry 1248 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found 1249 * @throws SystemException if a system exception occurred 1250 */ 1251 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_Last( 1252 long classNameId, long classPK, boolean alert, 1253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1254 throws com.liferay.portal.kernel.exception.SystemException, 1255 com.liferay.portlet.announcements.NoSuchEntryException { 1256 return getPersistence() 1257 .findByC_C_A_Last(classNameId, classPK, alert, 1258 orderByComparator); 1259 } 1260 1261 /** 1262 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1263 * 1264 * @param classNameId the class name ID 1265 * @param classPK the class p k 1266 * @param alert the alert 1267 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1268 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 1269 * @throws SystemException if a system exception occurred 1270 */ 1271 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByC_C_A_Last( 1272 long classNameId, long classPK, boolean alert, 1273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1274 throws com.liferay.portal.kernel.exception.SystemException { 1275 return getPersistence() 1276 .fetchByC_C_A_Last(classNameId, classPK, alert, 1277 orderByComparator); 1278 } 1279 1280 /** 1281 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 1282 * 1283 * @param entryId the primary key of the current announcements entry 1284 * @param classNameId the class name ID 1285 * @param classPK the class p k 1286 * @param alert the alert 1287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1288 * @return the previous, current, and next announcements entry 1289 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1290 * @throws SystemException if a system exception occurred 1291 */ 1292 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_A_PrevAndNext( 1293 long entryId, long classNameId, long classPK, boolean alert, 1294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1295 throws com.liferay.portal.kernel.exception.SystemException, 1296 com.liferay.portlet.announcements.NoSuchEntryException { 1297 return getPersistence() 1298 .findByC_C_A_PrevAndNext(entryId, classNameId, classPK, 1299 alert, orderByComparator); 1300 } 1301 1302 /** 1303 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 1304 * 1305 * @param classNameId the class name ID 1306 * @param classPK the class p k 1307 * @param alert the alert 1308 * @return the matching announcements entries that the user has permission to view 1309 * @throws SystemException if a system exception occurred 1310 */ 1311 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 1312 long classNameId, long classPK, boolean alert) 1313 throws com.liferay.portal.kernel.exception.SystemException { 1314 return getPersistence().filterFindByC_C_A(classNameId, classPK, alert); 1315 } 1316 1317 /** 1318 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 1319 * 1320 * <p> 1321 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1322 * </p> 1323 * 1324 * @param classNameId the class name ID 1325 * @param classPK the class p k 1326 * @param alert the alert 1327 * @param start the lower bound of the range of announcements entries 1328 * @param end the upper bound of the range of announcements entries (not inclusive) 1329 * @return the range of matching announcements entries that the user has permission to view 1330 * @throws SystemException if a system exception occurred 1331 */ 1332 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 1333 long classNameId, long classPK, boolean alert, int start, int end) 1334 throws com.liferay.portal.kernel.exception.SystemException { 1335 return getPersistence() 1336 .filterFindByC_C_A(classNameId, classPK, alert, start, end); 1337 } 1338 1339 /** 1340 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ? and alert = ?. 1341 * 1342 * <p> 1343 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1344 * </p> 1345 * 1346 * @param classNameId the class name ID 1347 * @param classPK the class p k 1348 * @param alert the alert 1349 * @param start the lower bound of the range of announcements entries 1350 * @param end the upper bound of the range of announcements entries (not inclusive) 1351 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1352 * @return the ordered range of matching announcements entries that the user has permission to view 1353 * @throws SystemException if a system exception occurred 1354 */ 1355 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A( 1356 long classNameId, long classPK, boolean alert, int start, int end, 1357 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1358 throws com.liferay.portal.kernel.exception.SystemException { 1359 return getPersistence() 1360 .filterFindByC_C_A(classNameId, classPK, alert, start, end, 1361 orderByComparator); 1362 } 1363 1364 /** 1365 * 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 = ?. 1366 * 1367 * @param entryId the primary key of the current announcements entry 1368 * @param classNameId the class name ID 1369 * @param classPK the class p k 1370 * @param alert the alert 1371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1372 * @return the previous, current, and next announcements entry 1373 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1374 * @throws SystemException if a system exception occurred 1375 */ 1376 public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext( 1377 long entryId, long classNameId, long classPK, boolean alert, 1378 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1379 throws com.liferay.portal.kernel.exception.SystemException, 1380 com.liferay.portlet.announcements.NoSuchEntryException { 1381 return getPersistence() 1382 .filterFindByC_C_A_PrevAndNext(entryId, classNameId, 1383 classPK, alert, orderByComparator); 1384 } 1385 1386 /** 1387 * Removes all the announcements entries where classNameId = ? and classPK = ? and alert = ? from the database. 1388 * 1389 * @param classNameId the class name ID 1390 * @param classPK the class p k 1391 * @param alert the alert 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public static void removeByC_C_A(long classNameId, long classPK, 1395 boolean alert) 1396 throws com.liferay.portal.kernel.exception.SystemException { 1397 getPersistence().removeByC_C_A(classNameId, classPK, alert); 1398 } 1399 1400 /** 1401 * Returns the number of announcements entries where classNameId = ? and classPK = ? and alert = ?. 1402 * 1403 * @param classNameId the class name ID 1404 * @param classPK the class p k 1405 * @param alert the alert 1406 * @return the number of matching announcements entries 1407 * @throws SystemException if a system exception occurred 1408 */ 1409 public static int countByC_C_A(long classNameId, long classPK, boolean alert) 1410 throws com.liferay.portal.kernel.exception.SystemException { 1411 return getPersistence().countByC_C_A(classNameId, classPK, alert); 1412 } 1413 1414 /** 1415 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 1416 * 1417 * @param classNameId the class name ID 1418 * @param classPK the class p k 1419 * @param alert the alert 1420 * @return the number of matching announcements entries that the user has permission to view 1421 * @throws SystemException if a system exception occurred 1422 */ 1423 public static int filterCountByC_C_A(long classNameId, long classPK, 1424 boolean alert) 1425 throws com.liferay.portal.kernel.exception.SystemException { 1426 return getPersistence().filterCountByC_C_A(classNameId, classPK, alert); 1427 } 1428 1429 /** 1430 * Caches the announcements entry in the entity cache if it is enabled. 1431 * 1432 * @param announcementsEntry the announcements entry 1433 */ 1434 public static void cacheResult( 1435 com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry) { 1436 getPersistence().cacheResult(announcementsEntry); 1437 } 1438 1439 /** 1440 * Caches the announcements entries in the entity cache if it is enabled. 1441 * 1442 * @param announcementsEntries the announcements entries 1443 */ 1444 public static void cacheResult( 1445 java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> announcementsEntries) { 1446 getPersistence().cacheResult(announcementsEntries); 1447 } 1448 1449 /** 1450 * Creates a new announcements entry with the primary key. Does not add the announcements entry to the database. 1451 * 1452 * @param entryId the primary key for the new announcements entry 1453 * @return the new announcements entry 1454 */ 1455 public static com.liferay.portlet.announcements.model.AnnouncementsEntry create( 1456 long entryId) { 1457 return getPersistence().create(entryId); 1458 } 1459 1460 /** 1461 * Removes the announcements entry with the primary key from the database. Also notifies the appropriate model listeners. 1462 * 1463 * @param entryId the primary key of the announcements entry 1464 * @return the announcements entry that was removed 1465 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1466 * @throws SystemException if a system exception occurred 1467 */ 1468 public static com.liferay.portlet.announcements.model.AnnouncementsEntry remove( 1469 long entryId) 1470 throws com.liferay.portal.kernel.exception.SystemException, 1471 com.liferay.portlet.announcements.NoSuchEntryException { 1472 return getPersistence().remove(entryId); 1473 } 1474 1475 public static com.liferay.portlet.announcements.model.AnnouncementsEntry updateImpl( 1476 com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry) 1477 throws com.liferay.portal.kernel.exception.SystemException { 1478 return getPersistence().updateImpl(announcementsEntry); 1479 } 1480 1481 /** 1482 * Returns the announcements entry with the primary key or throws a {@link com.liferay.portlet.announcements.NoSuchEntryException} if it could not be found. 1483 * 1484 * @param entryId the primary key of the announcements entry 1485 * @return the announcements entry 1486 * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found 1487 * @throws SystemException if a system exception occurred 1488 */ 1489 public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByPrimaryKey( 1490 long entryId) 1491 throws com.liferay.portal.kernel.exception.SystemException, 1492 com.liferay.portlet.announcements.NoSuchEntryException { 1493 return getPersistence().findByPrimaryKey(entryId); 1494 } 1495 1496 /** 1497 * Returns the announcements entry with the primary key or returns <code>null</code> if it could not be found. 1498 * 1499 * @param entryId the primary key of the announcements entry 1500 * @return the announcements entry, or <code>null</code> if a announcements entry with the primary key could not be found 1501 * @throws SystemException if a system exception occurred 1502 */ 1503 public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByPrimaryKey( 1504 long entryId) 1505 throws com.liferay.portal.kernel.exception.SystemException { 1506 return getPersistence().fetchByPrimaryKey(entryId); 1507 } 1508 1509 /** 1510 * Returns all the announcements entries. 1511 * 1512 * @return the announcements entries 1513 * @throws SystemException if a system exception occurred 1514 */ 1515 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll() 1516 throws com.liferay.portal.kernel.exception.SystemException { 1517 return getPersistence().findAll(); 1518 } 1519 1520 /** 1521 * Returns a range of all the announcements entries. 1522 * 1523 * <p> 1524 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1525 * </p> 1526 * 1527 * @param start the lower bound of the range of announcements entries 1528 * @param end the upper bound of the range of announcements entries (not inclusive) 1529 * @return the range of announcements entries 1530 * @throws SystemException if a system exception occurred 1531 */ 1532 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1533 int start, int end) 1534 throws com.liferay.portal.kernel.exception.SystemException { 1535 return getPersistence().findAll(start, end); 1536 } 1537 1538 /** 1539 * Returns an ordered range of all the announcements entries. 1540 * 1541 * <p> 1542 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.announcements.model.impl.AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1543 * </p> 1544 * 1545 * @param start the lower bound of the range of announcements entries 1546 * @param end the upper bound of the range of announcements entries (not inclusive) 1547 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1548 * @return the ordered range of announcements entries 1549 * @throws SystemException if a system exception occurred 1550 */ 1551 public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll( 1552 int start, int end, 1553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1554 throws com.liferay.portal.kernel.exception.SystemException { 1555 return getPersistence().findAll(start, end, orderByComparator); 1556 } 1557 1558 /** 1559 * Removes all the announcements entries from the database. 1560 * 1561 * @throws SystemException if a system exception occurred 1562 */ 1563 public static void removeAll() 1564 throws com.liferay.portal.kernel.exception.SystemException { 1565 getPersistence().removeAll(); 1566 } 1567 1568 /** 1569 * Returns the number of announcements entries. 1570 * 1571 * @return the number of announcements entries 1572 * @throws SystemException if a system exception occurred 1573 */ 1574 public static int countAll() 1575 throws com.liferay.portal.kernel.exception.SystemException { 1576 return getPersistence().countAll(); 1577 } 1578 1579 public static AnnouncementsEntryPersistence getPersistence() { 1580 if (_persistence == null) { 1581 _persistence = (AnnouncementsEntryPersistence)PortalBeanLocatorUtil.locate(AnnouncementsEntryPersistence.class.getName()); 1582 1583 ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class, 1584 "_persistence"); 1585 } 1586 1587 return _persistence; 1588 } 1589 1590 /** 1591 * @deprecated As of 6.2.0 1592 */ 1593 public void setPersistence(AnnouncementsEntryPersistence persistence) { 1594 } 1595 1596 private static AnnouncementsEntryPersistence _persistence; 1597 }