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.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.announcements.model.AnnouncementsEntry; 022 023 /** 024 * The persistence interface for the announcements entry service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.announcements.service.persistence.impl.AnnouncementsEntryPersistenceImpl 032 * @see AnnouncementsEntryUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface AnnouncementsEntryPersistence extends BasePersistence<AnnouncementsEntry> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link AnnouncementsEntryUtil} to access the announcements entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the announcements entries where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching announcements entries 048 */ 049 public java.util.List<AnnouncementsEntry> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the announcements entries where uuid = ?. 053 * 054 * <p> 055 * 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. 056 * </p> 057 * 058 * @param uuid the uuid 059 * @param start the lower bound of the range of announcements entries 060 * @param end the upper bound of the range of announcements entries (not inclusive) 061 * @return the range of matching announcements entries 062 */ 063 public java.util.List<AnnouncementsEntry> findByUuid( 064 java.lang.String uuid, int start, int end); 065 066 /** 067 * Returns an ordered range of all the announcements entries where uuid = ?. 068 * 069 * <p> 070 * 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. 071 * </p> 072 * 073 * @param uuid the uuid 074 * @param start the lower bound of the range of announcements entries 075 * @param end the upper bound of the range of announcements entries (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching announcements entries 078 */ 079 public java.util.List<AnnouncementsEntry> findByUuid( 080 java.lang.String uuid, int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 082 083 /** 084 * Returns the first announcements entry in the ordered set where uuid = ?. 085 * 086 * @param uuid the uuid 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching announcements entry 089 * @throws NoSuchEntryException if a matching announcements entry could not be found 090 */ 091 public AnnouncementsEntry findByUuid_First(java.lang.String uuid, 092 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 093 throws com.liferay.portlet.announcements.NoSuchEntryException; 094 095 /** 096 * Returns the first announcements entry in the ordered set where uuid = ?. 097 * 098 * @param uuid the uuid 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 101 */ 102 public AnnouncementsEntry fetchByUuid_First(java.lang.String uuid, 103 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 104 105 /** 106 * Returns the last announcements entry in the ordered set where uuid = ?. 107 * 108 * @param uuid the uuid 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching announcements entry 111 * @throws NoSuchEntryException if a matching announcements entry could not be found 112 */ 113 public AnnouncementsEntry findByUuid_Last(java.lang.String uuid, 114 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 115 throws com.liferay.portlet.announcements.NoSuchEntryException; 116 117 /** 118 * Returns the last announcements entry in the ordered set where uuid = ?. 119 * 120 * @param uuid the uuid 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 123 */ 124 public AnnouncementsEntry fetchByUuid_Last(java.lang.String uuid, 125 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 126 127 /** 128 * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = ?. 129 * 130 * @param entryId the primary key of the current announcements entry 131 * @param uuid the uuid 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next announcements entry 134 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 135 */ 136 public AnnouncementsEntry[] findByUuid_PrevAndNext(long entryId, 137 java.lang.String uuid, 138 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 139 throws com.liferay.portlet.announcements.NoSuchEntryException; 140 141 /** 142 * Returns all the announcements entries that the user has permission to view where uuid = ?. 143 * 144 * @param uuid the uuid 145 * @return the matching announcements entries that the user has permission to view 146 */ 147 public java.util.List<AnnouncementsEntry> filterFindByUuid( 148 java.lang.String uuid); 149 150 /** 151 * Returns a range of all the announcements entries that the user has permission to view where uuid = ?. 152 * 153 * <p> 154 * 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. 155 * </p> 156 * 157 * @param uuid the uuid 158 * @param start the lower bound of the range of announcements entries 159 * @param end the upper bound of the range of announcements entries (not inclusive) 160 * @return the range of matching announcements entries that the user has permission to view 161 */ 162 public java.util.List<AnnouncementsEntry> filterFindByUuid( 163 java.lang.String uuid, int start, int end); 164 165 /** 166 * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = ?. 167 * 168 * <p> 169 * 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. 170 * </p> 171 * 172 * @param uuid the uuid 173 * @param start the lower bound of the range of announcements entries 174 * @param end the upper bound of the range of announcements entries (not inclusive) 175 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 176 * @return the ordered range of matching announcements entries that the user has permission to view 177 */ 178 public java.util.List<AnnouncementsEntry> filterFindByUuid( 179 java.lang.String uuid, int start, int end, 180 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 181 182 /** 183 * 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 = ?. 184 * 185 * @param entryId the primary key of the current announcements entry 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the previous, current, and next announcements entry 189 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 190 */ 191 public AnnouncementsEntry[] filterFindByUuid_PrevAndNext(long entryId, 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 194 throws com.liferay.portlet.announcements.NoSuchEntryException; 195 196 /** 197 * Removes all the announcements entries where uuid = ? from the database. 198 * 199 * @param uuid the uuid 200 */ 201 public void removeByUuid(java.lang.String uuid); 202 203 /** 204 * Returns the number of announcements entries where uuid = ?. 205 * 206 * @param uuid the uuid 207 * @return the number of matching announcements entries 208 */ 209 public int countByUuid(java.lang.String uuid); 210 211 /** 212 * Returns the number of announcements entries that the user has permission to view where uuid = ?. 213 * 214 * @param uuid the uuid 215 * @return the number of matching announcements entries that the user has permission to view 216 */ 217 public int filterCountByUuid(java.lang.String uuid); 218 219 /** 220 * Returns all the announcements entries where uuid = ? and companyId = ?. 221 * 222 * @param uuid the uuid 223 * @param companyId the company ID 224 * @return the matching announcements entries 225 */ 226 public java.util.List<AnnouncementsEntry> findByUuid_C( 227 java.lang.String uuid, long companyId); 228 229 /** 230 * Returns a range of all the announcements entries where uuid = ? and companyId = ?. 231 * 232 * <p> 233 * 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. 234 * </p> 235 * 236 * @param uuid the uuid 237 * @param companyId the company ID 238 * @param start the lower bound of the range of announcements entries 239 * @param end the upper bound of the range of announcements entries (not inclusive) 240 * @return the range of matching announcements entries 241 */ 242 public java.util.List<AnnouncementsEntry> findByUuid_C( 243 java.lang.String uuid, long companyId, int start, int end); 244 245 /** 246 * Returns an ordered range of all the announcements entries where uuid = ? and companyId = ?. 247 * 248 * <p> 249 * 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. 250 * </p> 251 * 252 * @param uuid the uuid 253 * @param companyId the company ID 254 * @param start the lower bound of the range of announcements entries 255 * @param end the upper bound of the range of announcements entries (not inclusive) 256 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 257 * @return the ordered range of matching announcements entries 258 */ 259 public java.util.List<AnnouncementsEntry> findByUuid_C( 260 java.lang.String uuid, long companyId, int start, int end, 261 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 262 263 /** 264 * Returns the first announcements entry in the ordered set where uuid = ? and companyId = ?. 265 * 266 * @param uuid the uuid 267 * @param companyId the company ID 268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 269 * @return the first matching announcements entry 270 * @throws NoSuchEntryException if a matching announcements entry could not be found 271 */ 272 public AnnouncementsEntry findByUuid_C_First(java.lang.String uuid, 273 long companyId, 274 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 275 throws com.liferay.portlet.announcements.NoSuchEntryException; 276 277 /** 278 * Returns the first announcements entry in the ordered set where uuid = ? and companyId = ?. 279 * 280 * @param uuid the uuid 281 * @param companyId the company ID 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 284 */ 285 public AnnouncementsEntry fetchByUuid_C_First(java.lang.String uuid, 286 long companyId, 287 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 288 289 /** 290 * Returns the last announcements entry in the ordered set where uuid = ? and companyId = ?. 291 * 292 * @param uuid the uuid 293 * @param companyId the company ID 294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 295 * @return the last matching announcements entry 296 * @throws NoSuchEntryException if a matching announcements entry could not be found 297 */ 298 public AnnouncementsEntry findByUuid_C_Last(java.lang.String uuid, 299 long companyId, 300 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 301 throws com.liferay.portlet.announcements.NoSuchEntryException; 302 303 /** 304 * Returns the last announcements entry in the ordered set where uuid = ? and companyId = ?. 305 * 306 * @param uuid the uuid 307 * @param companyId the company ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 310 */ 311 public AnnouncementsEntry fetchByUuid_C_Last(java.lang.String uuid, 312 long companyId, 313 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 314 315 /** 316 * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = ? and companyId = ?. 317 * 318 * @param entryId the primary key of the current announcements entry 319 * @param uuid the uuid 320 * @param companyId the company ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the previous, current, and next announcements entry 323 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 324 */ 325 public AnnouncementsEntry[] findByUuid_C_PrevAndNext(long entryId, 326 java.lang.String uuid, long companyId, 327 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 328 throws com.liferay.portlet.announcements.NoSuchEntryException; 329 330 /** 331 * Returns all the announcements entries that the user has permission to view where uuid = ? and companyId = ?. 332 * 333 * @param uuid the uuid 334 * @param companyId the company ID 335 * @return the matching announcements entries that the user has permission to view 336 */ 337 public java.util.List<AnnouncementsEntry> filterFindByUuid_C( 338 java.lang.String uuid, long companyId); 339 340 /** 341 * Returns a range of all the announcements entries that the user has permission to view 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 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. 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 that the user has permission to view 352 */ 353 public java.util.List<AnnouncementsEntry> filterFindByUuid_C( 354 java.lang.String uuid, long companyId, int start, int end); 355 356 /** 357 * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = ? and companyId = ?. 358 * 359 * <p> 360 * 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. 361 * </p> 362 * 363 * @param uuid the uuid 364 * @param companyId the company ID 365 * @param start the lower bound of the range of announcements entries 366 * @param end the upper bound of the range of announcements entries (not inclusive) 367 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 368 * @return the ordered range of matching announcements entries that the user has permission to view 369 */ 370 public java.util.List<AnnouncementsEntry> filterFindByUuid_C( 371 java.lang.String uuid, long companyId, int start, int end, 372 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 373 374 /** 375 * 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 = ?. 376 * 377 * @param entryId the primary key of the current announcements entry 378 * @param uuid the uuid 379 * @param companyId the company ID 380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 381 * @return the previous, current, and next announcements entry 382 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 383 */ 384 public AnnouncementsEntry[] filterFindByUuid_C_PrevAndNext(long entryId, 385 java.lang.String uuid, long companyId, 386 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 387 throws com.liferay.portlet.announcements.NoSuchEntryException; 388 389 /** 390 * Removes all the announcements entries where uuid = ? and companyId = ? from the database. 391 * 392 * @param uuid the uuid 393 * @param companyId the company ID 394 */ 395 public void removeByUuid_C(java.lang.String uuid, long companyId); 396 397 /** 398 * Returns the number of announcements entries where uuid = ? and companyId = ?. 399 * 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @return the number of matching announcements entries 403 */ 404 public int countByUuid_C(java.lang.String uuid, long companyId); 405 406 /** 407 * Returns the number of announcements entries that the user has permission to view where uuid = ? and companyId = ?. 408 * 409 * @param uuid the uuid 410 * @param companyId the company ID 411 * @return the number of matching announcements entries that the user has permission to view 412 */ 413 public int filterCountByUuid_C(java.lang.String uuid, long companyId); 414 415 /** 416 * Returns all the announcements entries where userId = ?. 417 * 418 * @param userId the user ID 419 * @return the matching announcements entries 420 */ 421 public java.util.List<AnnouncementsEntry> findByUserId(long userId); 422 423 /** 424 * Returns a range of all the announcements entries where userId = ?. 425 * 426 * <p> 427 * 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. 428 * </p> 429 * 430 * @param userId the user ID 431 * @param start the lower bound of the range of announcements entries 432 * @param end the upper bound of the range of announcements entries (not inclusive) 433 * @return the range of matching announcements entries 434 */ 435 public java.util.List<AnnouncementsEntry> findByUserId(long userId, 436 int start, int end); 437 438 /** 439 * Returns an ordered range of all the announcements entries where userId = ?. 440 * 441 * <p> 442 * 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. 443 * </p> 444 * 445 * @param userId the user ID 446 * @param start the lower bound of the range of announcements entries 447 * @param end the upper bound of the range of announcements entries (not inclusive) 448 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 449 * @return the ordered range of matching announcements entries 450 */ 451 public java.util.List<AnnouncementsEntry> findByUserId(long userId, 452 int start, int end, 453 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 454 455 /** 456 * Returns the first announcements entry in the ordered set where userId = ?. 457 * 458 * @param userId the user ID 459 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 460 * @return the first matching announcements entry 461 * @throws NoSuchEntryException if a matching announcements entry could not be found 462 */ 463 public AnnouncementsEntry findByUserId_First(long userId, 464 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 465 throws com.liferay.portlet.announcements.NoSuchEntryException; 466 467 /** 468 * Returns the first announcements entry in the ordered set where userId = ?. 469 * 470 * @param userId the user ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 473 */ 474 public AnnouncementsEntry fetchByUserId_First(long userId, 475 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 476 477 /** 478 * Returns the last announcements entry in the ordered set where userId = ?. 479 * 480 * @param userId the user ID 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the last matching announcements entry 483 * @throws NoSuchEntryException if a matching announcements entry could not be found 484 */ 485 public AnnouncementsEntry findByUserId_Last(long userId, 486 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 487 throws com.liferay.portlet.announcements.NoSuchEntryException; 488 489 /** 490 * Returns the last announcements entry in the ordered set where userId = ?. 491 * 492 * @param userId the user ID 493 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 494 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 495 */ 496 public AnnouncementsEntry fetchByUserId_Last(long userId, 497 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 498 499 /** 500 * Returns the announcements entries before and after the current announcements entry in the ordered set where userId = ?. 501 * 502 * @param entryId the primary key of the current announcements entry 503 * @param userId the user ID 504 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 505 * @return the previous, current, and next announcements entry 506 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 507 */ 508 public AnnouncementsEntry[] findByUserId_PrevAndNext(long entryId, 509 long userId, 510 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 511 throws com.liferay.portlet.announcements.NoSuchEntryException; 512 513 /** 514 * Returns all the announcements entries that the user has permission to view where userId = ?. 515 * 516 * @param userId the user ID 517 * @return the matching announcements entries that the user has permission to view 518 */ 519 public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId); 520 521 /** 522 * Returns a range of all the announcements entries that the user has permission to view where userId = ?. 523 * 524 * <p> 525 * 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. 526 * </p> 527 * 528 * @param userId the user ID 529 * @param start the lower bound of the range of announcements entries 530 * @param end the upper bound of the range of announcements entries (not inclusive) 531 * @return the range of matching announcements entries that the user has permission to view 532 */ 533 public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId, 534 int start, int end); 535 536 /** 537 * Returns an ordered range of all the announcements entries that the user has permissions to view where userId = ?. 538 * 539 * <p> 540 * 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. 541 * </p> 542 * 543 * @param userId the user ID 544 * @param start the lower bound of the range of announcements entries 545 * @param end the upper bound of the range of announcements entries (not inclusive) 546 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 547 * @return the ordered range of matching announcements entries that the user has permission to view 548 */ 549 public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId, 550 int start, int end, 551 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 552 553 /** 554 * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where userId = ?. 555 * 556 * @param entryId the primary key of the current announcements entry 557 * @param userId the user ID 558 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 559 * @return the previous, current, and next announcements entry 560 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 561 */ 562 public AnnouncementsEntry[] filterFindByUserId_PrevAndNext(long entryId, 563 long userId, 564 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 565 throws com.liferay.portlet.announcements.NoSuchEntryException; 566 567 /** 568 * Removes all the announcements entries where userId = ? from the database. 569 * 570 * @param userId the user ID 571 */ 572 public void removeByUserId(long userId); 573 574 /** 575 * Returns the number of announcements entries where userId = ?. 576 * 577 * @param userId the user ID 578 * @return the number of matching announcements entries 579 */ 580 public int countByUserId(long userId); 581 582 /** 583 * Returns the number of announcements entries that the user has permission to view where userId = ?. 584 * 585 * @param userId the user ID 586 * @return the number of matching announcements entries that the user has permission to view 587 */ 588 public int filterCountByUserId(long userId); 589 590 /** 591 * Returns all the announcements entries where classNameId = ? and classPK = ?. 592 * 593 * @param classNameId the class name ID 594 * @param classPK the class p k 595 * @return the matching announcements entries 596 */ 597 public java.util.List<AnnouncementsEntry> findByC_C(long classNameId, 598 long classPK); 599 600 /** 601 * Returns a range of all the announcements entries where classNameId = ? and classPK = ?. 602 * 603 * <p> 604 * 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. 605 * </p> 606 * 607 * @param classNameId the class name ID 608 * @param classPK the class p k 609 * @param start the lower bound of the range of announcements entries 610 * @param end the upper bound of the range of announcements entries (not inclusive) 611 * @return the range of matching announcements entries 612 */ 613 public java.util.List<AnnouncementsEntry> findByC_C(long classNameId, 614 long classPK, int start, int end); 615 616 /** 617 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ?. 618 * 619 * <p> 620 * 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. 621 * </p> 622 * 623 * @param classNameId the class name ID 624 * @param classPK the class p k 625 * @param start the lower bound of the range of announcements entries 626 * @param end the upper bound of the range of announcements entries (not inclusive) 627 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 628 * @return the ordered range of matching announcements entries 629 */ 630 public java.util.List<AnnouncementsEntry> findByC_C(long classNameId, 631 long classPK, int start, int end, 632 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 633 634 /** 635 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 636 * 637 * @param classNameId the class name ID 638 * @param classPK the class p k 639 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 640 * @return the first matching announcements entry 641 * @throws NoSuchEntryException if a matching announcements entry could not be found 642 */ 643 public AnnouncementsEntry findByC_C_First(long classNameId, long classPK, 644 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 645 throws com.liferay.portlet.announcements.NoSuchEntryException; 646 647 /** 648 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ?. 649 * 650 * @param classNameId the class name ID 651 * @param classPK the class p k 652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 653 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 654 */ 655 public AnnouncementsEntry fetchByC_C_First(long classNameId, long classPK, 656 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 657 658 /** 659 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 660 * 661 * @param classNameId the class name ID 662 * @param classPK the class p k 663 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 664 * @return the last matching announcements entry 665 * @throws NoSuchEntryException if a matching announcements entry could not be found 666 */ 667 public AnnouncementsEntry findByC_C_Last(long classNameId, long classPK, 668 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 669 throws com.liferay.portlet.announcements.NoSuchEntryException; 670 671 /** 672 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ?. 673 * 674 * @param classNameId the class name ID 675 * @param classPK the class p k 676 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 677 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 678 */ 679 public AnnouncementsEntry fetchByC_C_Last(long classNameId, long classPK, 680 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 681 682 /** 683 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ?. 684 * 685 * @param entryId the primary key of the current announcements entry 686 * @param classNameId the class name ID 687 * @param classPK the class p k 688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 689 * @return the previous, current, and next announcements entry 690 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 691 */ 692 public AnnouncementsEntry[] findByC_C_PrevAndNext(long entryId, 693 long classNameId, long classPK, 694 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 695 throws com.liferay.portlet.announcements.NoSuchEntryException; 696 697 /** 698 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 699 * 700 * @param classNameId the class name ID 701 * @param classPK the class p k 702 * @return the matching announcements entries that the user has permission to view 703 */ 704 public java.util.List<AnnouncementsEntry> filterFindByC_C( 705 long classNameId, long classPK); 706 707 /** 708 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 709 * 710 * <p> 711 * 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. 712 * </p> 713 * 714 * @param classNameId the class name ID 715 * @param classPK the class p k 716 * @param start the lower bound of the range of announcements entries 717 * @param end the upper bound of the range of announcements entries (not inclusive) 718 * @return the range of matching announcements entries that the user has permission to view 719 */ 720 public java.util.List<AnnouncementsEntry> filterFindByC_C( 721 long classNameId, long classPK, int start, int end); 722 723 /** 724 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ?. 725 * 726 * <p> 727 * 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. 728 * </p> 729 * 730 * @param classNameId the class name ID 731 * @param classPK the class p k 732 * @param start the lower bound of the range of announcements entries 733 * @param end the upper bound of the range of announcements entries (not inclusive) 734 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 735 * @return the ordered range of matching announcements entries that the user has permission to view 736 */ 737 public java.util.List<AnnouncementsEntry> filterFindByC_C( 738 long classNameId, long classPK, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 740 741 /** 742 * 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 = ?. 743 * 744 * @param entryId the primary key of the current announcements entry 745 * @param classNameId the class name ID 746 * @param classPK the class p k 747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 748 * @return the previous, current, and next announcements entry 749 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 750 */ 751 public AnnouncementsEntry[] filterFindByC_C_PrevAndNext(long entryId, 752 long classNameId, long classPK, 753 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 754 throws com.liferay.portlet.announcements.NoSuchEntryException; 755 756 /** 757 * Removes all the announcements entries where classNameId = ? and classPK = ? from the database. 758 * 759 * @param classNameId the class name ID 760 * @param classPK the class p k 761 */ 762 public void removeByC_C(long classNameId, long classPK); 763 764 /** 765 * Returns the number of announcements entries where classNameId = ? and classPK = ?. 766 * 767 * @param classNameId the class name ID 768 * @param classPK the class p k 769 * @return the number of matching announcements entries 770 */ 771 public int countByC_C(long classNameId, long classPK); 772 773 /** 774 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ?. 775 * 776 * @param classNameId the class name ID 777 * @param classPK the class p k 778 * @return the number of matching announcements entries that the user has permission to view 779 */ 780 public int filterCountByC_C(long classNameId, long classPK); 781 782 /** 783 * Returns all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 784 * 785 * @param classNameId the class name ID 786 * @param classPK the class p k 787 * @param alert the alert 788 * @return the matching announcements entries 789 */ 790 public java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId, 791 long classPK, boolean alert); 792 793 /** 794 * Returns a range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 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 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. 798 * </p> 799 * 800 * @param classNameId the class name ID 801 * @param classPK the class p k 802 * @param alert the alert 803 * @param start the lower bound of the range of announcements entries 804 * @param end the upper bound of the range of announcements entries (not inclusive) 805 * @return the range of matching announcements entries 806 */ 807 public java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId, 808 long classPK, boolean alert, int start, int end); 809 810 /** 811 * Returns an ordered range of all the announcements entries where classNameId = ? and classPK = ? and alert = ?. 812 * 813 * <p> 814 * 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. 815 * </p> 816 * 817 * @param classNameId the class name ID 818 * @param classPK the class p k 819 * @param alert the alert 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 java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId, 826 long classPK, boolean alert, int start, int end, 827 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 828 829 /** 830 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 831 * 832 * @param classNameId the class name ID 833 * @param classPK the class p k 834 * @param alert the alert 835 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 836 * @return the first matching announcements entry 837 * @throws NoSuchEntryException if a matching announcements entry could not be found 838 */ 839 public AnnouncementsEntry findByC_C_A_First(long classNameId, long classPK, 840 boolean alert, 841 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 842 throws com.liferay.portlet.announcements.NoSuchEntryException; 843 844 /** 845 * Returns the first announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 846 * 847 * @param classNameId the class name ID 848 * @param classPK the class p k 849 * @param alert the alert 850 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 851 * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 852 */ 853 public AnnouncementsEntry fetchByC_C_A_First(long classNameId, 854 long classPK, boolean alert, 855 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 856 857 /** 858 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 859 * 860 * @param classNameId the class name ID 861 * @param classPK the class p k 862 * @param alert the alert 863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 864 * @return the last matching announcements entry 865 * @throws NoSuchEntryException if a matching announcements entry could not be found 866 */ 867 public AnnouncementsEntry findByC_C_A_Last(long classNameId, long classPK, 868 boolean alert, 869 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 870 throws com.liferay.portlet.announcements.NoSuchEntryException; 871 872 /** 873 * Returns the last announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 874 * 875 * @param classNameId the class name ID 876 * @param classPK the class p k 877 * @param alert the alert 878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 879 * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found 880 */ 881 public AnnouncementsEntry fetchByC_C_A_Last(long classNameId, long classPK, 882 boolean alert, 883 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 884 885 /** 886 * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = ? and classPK = ? and alert = ?. 887 * 888 * @param entryId the primary key of the current announcements entry 889 * @param classNameId the class name ID 890 * @param classPK the class p k 891 * @param alert the alert 892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 893 * @return the previous, current, and next announcements entry 894 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 895 */ 896 public AnnouncementsEntry[] findByC_C_A_PrevAndNext(long entryId, 897 long classNameId, long classPK, boolean alert, 898 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 899 throws com.liferay.portlet.announcements.NoSuchEntryException; 900 901 /** 902 * Returns all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 903 * 904 * @param classNameId the class name ID 905 * @param classPK the class p k 906 * @param alert the alert 907 * @return the matching announcements entries that the user has permission to view 908 */ 909 public java.util.List<AnnouncementsEntry> filterFindByC_C_A( 910 long classNameId, long classPK, boolean alert); 911 912 /** 913 * Returns a range of all the announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 914 * 915 * <p> 916 * 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. 917 * </p> 918 * 919 * @param classNameId the class name ID 920 * @param classPK the class p k 921 * @param alert the alert 922 * @param start the lower bound of the range of announcements entries 923 * @param end the upper bound of the range of announcements entries (not inclusive) 924 * @return the range of matching announcements entries that the user has permission to view 925 */ 926 public java.util.List<AnnouncementsEntry> filterFindByC_C_A( 927 long classNameId, long classPK, boolean alert, int start, int end); 928 929 /** 930 * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = ? and classPK = ? and alert = ?. 931 * 932 * <p> 933 * 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. 934 * </p> 935 * 936 * @param classNameId the class name ID 937 * @param classPK the class p k 938 * @param alert the alert 939 * @param start the lower bound of the range of announcements entries 940 * @param end the upper bound of the range of announcements entries (not inclusive) 941 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 942 * @return the ordered range of matching announcements entries that the user has permission to view 943 */ 944 public java.util.List<AnnouncementsEntry> filterFindByC_C_A( 945 long classNameId, long classPK, boolean alert, int start, int end, 946 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 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 = ? and alert = ?. 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 alert the alert 955 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 956 * @return the previous, current, and next announcements entry 957 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 958 */ 959 public AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext(long entryId, 960 long classNameId, long classPK, boolean alert, 961 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator) 962 throws com.liferay.portlet.announcements.NoSuchEntryException; 963 964 /** 965 * Removes all the announcements entries where classNameId = ? and classPK = ? and alert = ? from the database. 966 * 967 * @param classNameId the class name ID 968 * @param classPK the class p k 969 * @param alert the alert 970 */ 971 public void removeByC_C_A(long classNameId, long classPK, boolean alert); 972 973 /** 974 * Returns the number of announcements entries where classNameId = ? and classPK = ? and alert = ?. 975 * 976 * @param classNameId the class name ID 977 * @param classPK the class p k 978 * @param alert the alert 979 * @return the number of matching announcements entries 980 */ 981 public int countByC_C_A(long classNameId, long classPK, boolean alert); 982 983 /** 984 * Returns the number of announcements entries that the user has permission to view where classNameId = ? and classPK = ? and alert = ?. 985 * 986 * @param classNameId the class name ID 987 * @param classPK the class p k 988 * @param alert the alert 989 * @return the number of matching announcements entries that the user has permission to view 990 */ 991 public int filterCountByC_C_A(long classNameId, long classPK, boolean alert); 992 993 /** 994 * Caches the announcements entry in the entity cache if it is enabled. 995 * 996 * @param announcementsEntry the announcements entry 997 */ 998 public void cacheResult(AnnouncementsEntry announcementsEntry); 999 1000 /** 1001 * Caches the announcements entries in the entity cache if it is enabled. 1002 * 1003 * @param announcementsEntries the announcements entries 1004 */ 1005 public void cacheResult( 1006 java.util.List<AnnouncementsEntry> announcementsEntries); 1007 1008 /** 1009 * Creates a new announcements entry with the primary key. Does not add the announcements entry to the database. 1010 * 1011 * @param entryId the primary key for the new announcements entry 1012 * @return the new announcements entry 1013 */ 1014 public AnnouncementsEntry create(long entryId); 1015 1016 /** 1017 * Removes the announcements entry with the primary key from the database. Also notifies the appropriate model listeners. 1018 * 1019 * @param entryId the primary key of the announcements entry 1020 * @return the announcements entry that was removed 1021 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 1022 */ 1023 public AnnouncementsEntry remove(long entryId) 1024 throws com.liferay.portlet.announcements.NoSuchEntryException; 1025 1026 public AnnouncementsEntry updateImpl(AnnouncementsEntry announcementsEntry); 1027 1028 /** 1029 * Returns the announcements entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 1030 * 1031 * @param entryId the primary key of the announcements entry 1032 * @return the announcements entry 1033 * @throws NoSuchEntryException if a announcements entry with the primary key could not be found 1034 */ 1035 public AnnouncementsEntry findByPrimaryKey(long entryId) 1036 throws com.liferay.portlet.announcements.NoSuchEntryException; 1037 1038 /** 1039 * Returns the announcements entry with the primary key or returns <code>null</code> if it could not be found. 1040 * 1041 * @param entryId the primary key of the announcements entry 1042 * @return the announcements entry, or <code>null</code> if a announcements entry with the primary key could not be found 1043 */ 1044 public AnnouncementsEntry fetchByPrimaryKey(long entryId); 1045 1046 @Override 1047 public java.util.Map<java.io.Serializable, AnnouncementsEntry> fetchByPrimaryKeys( 1048 java.util.Set<java.io.Serializable> primaryKeys); 1049 1050 /** 1051 * Returns all the announcements entries. 1052 * 1053 * @return the announcements entries 1054 */ 1055 public java.util.List<AnnouncementsEntry> findAll(); 1056 1057 /** 1058 * Returns a range of all the announcements entries. 1059 * 1060 * <p> 1061 * 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. 1062 * </p> 1063 * 1064 * @param start the lower bound of the range of announcements entries 1065 * @param end the upper bound of the range of announcements entries (not inclusive) 1066 * @return the range of announcements entries 1067 */ 1068 public java.util.List<AnnouncementsEntry> findAll(int start, int end); 1069 1070 /** 1071 * Returns an ordered range of all the announcements entries. 1072 * 1073 * <p> 1074 * 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. 1075 * </p> 1076 * 1077 * @param start the lower bound of the range of announcements entries 1078 * @param end the upper bound of the range of announcements entries (not inclusive) 1079 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1080 * @return the ordered range of announcements entries 1081 */ 1082 public java.util.List<AnnouncementsEntry> findAll(int start, int end, 1083 com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator); 1084 1085 /** 1086 * Removes all the announcements entries from the database. 1087 */ 1088 public void removeAll(); 1089 1090 /** 1091 * Returns the number of announcements entries. 1092 * 1093 * @return the number of announcements entries 1094 */ 1095 public int countAll(); 1096 }