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