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