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