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