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