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.trash.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.service.persistence.BasePersistence; 020 021 import com.liferay.trash.kernel.exception.NoSuchEntryException; 022 import com.liferay.trash.kernel.model.TrashEntry; 023 024 import java.util.Date; 025 026 /** 027 * The persistence interface for the trash entry service. 028 * 029 * <p> 030 * Caching information and settings can be found in <code>portal.properties</code> 031 * </p> 032 * 033 * @author Brian Wing Shun Chan 034 * @see com.liferay.portlet.trash.service.persistence.impl.TrashEntryPersistenceImpl 035 * @see TrashEntryUtil 036 * @generated 037 */ 038 @ProviderType 039 public interface TrashEntryPersistence extends BasePersistence<TrashEntry> { 040 /* 041 * NOTE FOR DEVELOPERS: 042 * 043 * Never modify or reference this interface directly. Always use {@link TrashEntryUtil} to access the trash entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 044 */ 045 046 /** 047 * Returns all the trash entries where groupId = ?. 048 * 049 * @param groupId the group ID 050 * @return the matching trash entries 051 */ 052 public java.util.List<TrashEntry> findByGroupId(long groupId); 053 054 /** 055 * Returns a range of all the trash entries where groupId = ?. 056 * 057 * <p> 058 * 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 TrashEntryModelImpl}. 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. 059 * </p> 060 * 061 * @param groupId the group ID 062 * @param start the lower bound of the range of trash entries 063 * @param end the upper bound of the range of trash entries (not inclusive) 064 * @return the range of matching trash entries 065 */ 066 public java.util.List<TrashEntry> findByGroupId(long groupId, int start, 067 int end); 068 069 /** 070 * Returns an ordered range of all the trash entries where groupId = ?. 071 * 072 * <p> 073 * 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 TrashEntryModelImpl}. 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. 074 * </p> 075 * 076 * @param groupId the group ID 077 * @param start the lower bound of the range of trash entries 078 * @param end the upper bound of the range of trash entries (not inclusive) 079 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 080 * @return the ordered range of matching trash entries 081 */ 082 public java.util.List<TrashEntry> findByGroupId(long groupId, int start, 083 int end, 084 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 085 086 /** 087 * Returns an ordered range of all the trash entries where groupId = ?. 088 * 089 * <p> 090 * 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 TrashEntryModelImpl}. 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. 091 * </p> 092 * 093 * @param groupId the group ID 094 * @param start the lower bound of the range of trash entries 095 * @param end the upper bound of the range of trash entries (not inclusive) 096 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 097 * @param retrieveFromCache whether to retrieve from the finder cache 098 * @return the ordered range of matching trash entries 099 */ 100 public java.util.List<TrashEntry> findByGroupId(long groupId, int start, 101 int end, 102 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator, 103 boolean retrieveFromCache); 104 105 /** 106 * Returns the first trash entry in the ordered set where groupId = ?. 107 * 108 * @param groupId the group ID 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the first matching trash entry 111 * @throws NoSuchEntryException if a matching trash entry could not be found 112 */ 113 public TrashEntry findByGroupId_First(long groupId, 114 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 115 throws NoSuchEntryException; 116 117 /** 118 * Returns the first trash entry in the ordered set where groupId = ?. 119 * 120 * @param groupId the group ID 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found 123 */ 124 public TrashEntry fetchByGroupId_First(long groupId, 125 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 126 127 /** 128 * Returns the last trash entry in the ordered set where groupId = ?. 129 * 130 * @param groupId the group ID 131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 132 * @return the last matching trash entry 133 * @throws NoSuchEntryException if a matching trash entry could not be found 134 */ 135 public TrashEntry findByGroupId_Last(long groupId, 136 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 137 throws NoSuchEntryException; 138 139 /** 140 * Returns the last trash entry in the ordered set where groupId = ?. 141 * 142 * @param groupId the group ID 143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 144 * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found 145 */ 146 public TrashEntry fetchByGroupId_Last(long groupId, 147 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 148 149 /** 150 * Returns the trash entries before and after the current trash entry in the ordered set where groupId = ?. 151 * 152 * @param entryId the primary key of the current trash entry 153 * @param groupId the group ID 154 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 155 * @return the previous, current, and next trash entry 156 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 157 */ 158 public TrashEntry[] findByGroupId_PrevAndNext(long entryId, long groupId, 159 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 160 throws NoSuchEntryException; 161 162 /** 163 * Removes all the trash entries where groupId = ? from the database. 164 * 165 * @param groupId the group ID 166 */ 167 public void removeByGroupId(long groupId); 168 169 /** 170 * Returns the number of trash entries where groupId = ?. 171 * 172 * @param groupId the group ID 173 * @return the number of matching trash entries 174 */ 175 public int countByGroupId(long groupId); 176 177 /** 178 * Returns all the trash entries where companyId = ?. 179 * 180 * @param companyId the company ID 181 * @return the matching trash entries 182 */ 183 public java.util.List<TrashEntry> findByCompanyId(long companyId); 184 185 /** 186 * Returns a range of all the trash entries where companyId = ?. 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 TrashEntryModelImpl}. 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 companyId the company ID 193 * @param start the lower bound of the range of trash entries 194 * @param end the upper bound of the range of trash entries (not inclusive) 195 * @return the range of matching trash entries 196 */ 197 public java.util.List<TrashEntry> findByCompanyId(long companyId, 198 int start, int end); 199 200 /** 201 * Returns an ordered range of all the trash entries where companyId = ?. 202 * 203 * <p> 204 * 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 TrashEntryModelImpl}. 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. 205 * </p> 206 * 207 * @param companyId the company ID 208 * @param start the lower bound of the range of trash entries 209 * @param end the upper bound of the range of trash entries (not inclusive) 210 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 211 * @return the ordered range of matching trash entries 212 */ 213 public java.util.List<TrashEntry> findByCompanyId(long companyId, 214 int start, int end, 215 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 216 217 /** 218 * Returns an ordered range of all the trash entries where companyId = ?. 219 * 220 * <p> 221 * 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 TrashEntryModelImpl}. 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. 222 * </p> 223 * 224 * @param companyId the company ID 225 * @param start the lower bound of the range of trash entries 226 * @param end the upper bound of the range of trash entries (not inclusive) 227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 228 * @param retrieveFromCache whether to retrieve from the finder cache 229 * @return the ordered range of matching trash entries 230 */ 231 public java.util.List<TrashEntry> findByCompanyId(long companyId, 232 int start, int end, 233 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator, 234 boolean retrieveFromCache); 235 236 /** 237 * Returns the first trash entry in the ordered set where companyId = ?. 238 * 239 * @param companyId the company ID 240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 241 * @return the first matching trash entry 242 * @throws NoSuchEntryException if a matching trash entry could not be found 243 */ 244 public TrashEntry findByCompanyId_First(long companyId, 245 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 246 throws NoSuchEntryException; 247 248 /** 249 * Returns the first trash entry in the ordered set where companyId = ?. 250 * 251 * @param companyId the company ID 252 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 253 * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found 254 */ 255 public TrashEntry fetchByCompanyId_First(long companyId, 256 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 257 258 /** 259 * Returns the last trash entry in the ordered set where companyId = ?. 260 * 261 * @param companyId the company ID 262 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 263 * @return the last matching trash entry 264 * @throws NoSuchEntryException if a matching trash entry could not be found 265 */ 266 public TrashEntry findByCompanyId_Last(long companyId, 267 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 268 throws NoSuchEntryException; 269 270 /** 271 * Returns the last trash entry in the ordered set where companyId = ?. 272 * 273 * @param companyId the company ID 274 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 275 * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found 276 */ 277 public TrashEntry fetchByCompanyId_Last(long companyId, 278 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 279 280 /** 281 * Returns the trash entries before and after the current trash entry in the ordered set where companyId = ?. 282 * 283 * @param entryId the primary key of the current trash entry 284 * @param companyId the company ID 285 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 286 * @return the previous, current, and next trash entry 287 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 288 */ 289 public TrashEntry[] findByCompanyId_PrevAndNext(long entryId, 290 long companyId, 291 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 292 throws NoSuchEntryException; 293 294 /** 295 * Removes all the trash entries where companyId = ? from the database. 296 * 297 * @param companyId the company ID 298 */ 299 public void removeByCompanyId(long companyId); 300 301 /** 302 * Returns the number of trash entries where companyId = ?. 303 * 304 * @param companyId the company ID 305 * @return the number of matching trash entries 306 */ 307 public int countByCompanyId(long companyId); 308 309 /** 310 * Returns all the trash entries where groupId = ? and createDate < ?. 311 * 312 * @param groupId the group ID 313 * @param createDate the create date 314 * @return the matching trash entries 315 */ 316 public java.util.List<TrashEntry> findByG_LtCD(long groupId, Date createDate); 317 318 /** 319 * Returns a range of all the trash entries where groupId = ? and createDate < ?. 320 * 321 * <p> 322 * 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 TrashEntryModelImpl}. 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. 323 * </p> 324 * 325 * @param groupId the group ID 326 * @param createDate the create date 327 * @param start the lower bound of the range of trash entries 328 * @param end the upper bound of the range of trash entries (not inclusive) 329 * @return the range of matching trash entries 330 */ 331 public java.util.List<TrashEntry> findByG_LtCD(long groupId, 332 Date createDate, int start, int end); 333 334 /** 335 * Returns an ordered range of all the trash entries where groupId = ? and createDate < ?. 336 * 337 * <p> 338 * 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 TrashEntryModelImpl}. 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. 339 * </p> 340 * 341 * @param groupId the group ID 342 * @param createDate the create date 343 * @param start the lower bound of the range of trash entries 344 * @param end the upper bound of the range of trash entries (not inclusive) 345 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 346 * @return the ordered range of matching trash entries 347 */ 348 public java.util.List<TrashEntry> findByG_LtCD(long groupId, 349 Date createDate, int start, int end, 350 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 351 352 /** 353 * Returns an ordered range of all the trash entries where groupId = ? and createDate < ?. 354 * 355 * <p> 356 * 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 TrashEntryModelImpl}. 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. 357 * </p> 358 * 359 * @param groupId the group ID 360 * @param createDate the create date 361 * @param start the lower bound of the range of trash entries 362 * @param end the upper bound of the range of trash entries (not inclusive) 363 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 364 * @param retrieveFromCache whether to retrieve from the finder cache 365 * @return the ordered range of matching trash entries 366 */ 367 public java.util.List<TrashEntry> findByG_LtCD(long groupId, 368 Date createDate, int start, int end, 369 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator, 370 boolean retrieveFromCache); 371 372 /** 373 * Returns the first trash entry in the ordered set where groupId = ? and createDate < ?. 374 * 375 * @param groupId the group ID 376 * @param createDate the create date 377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 378 * @return the first matching trash entry 379 * @throws NoSuchEntryException if a matching trash entry could not be found 380 */ 381 public TrashEntry findByG_LtCD_First(long groupId, Date createDate, 382 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 383 throws NoSuchEntryException; 384 385 /** 386 * Returns the first trash entry in the ordered set where groupId = ? and createDate < ?. 387 * 388 * @param groupId the group ID 389 * @param createDate the create date 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found 392 */ 393 public TrashEntry fetchByG_LtCD_First(long groupId, Date createDate, 394 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 395 396 /** 397 * Returns the last trash entry in the ordered set where groupId = ? and createDate < ?. 398 * 399 * @param groupId the group ID 400 * @param createDate the create date 401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 402 * @return the last matching trash entry 403 * @throws NoSuchEntryException if a matching trash entry could not be found 404 */ 405 public TrashEntry findByG_LtCD_Last(long groupId, Date createDate, 406 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 407 throws NoSuchEntryException; 408 409 /** 410 * Returns the last trash entry in the ordered set where groupId = ? and createDate < ?. 411 * 412 * @param groupId the group ID 413 * @param createDate the create date 414 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 415 * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found 416 */ 417 public TrashEntry fetchByG_LtCD_Last(long groupId, Date createDate, 418 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 419 420 /** 421 * Returns the trash entries before and after the current trash entry in the ordered set where groupId = ? and createDate < ?. 422 * 423 * @param entryId the primary key of the current trash entry 424 * @param groupId the group ID 425 * @param createDate the create date 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the previous, current, and next trash entry 428 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 429 */ 430 public TrashEntry[] findByG_LtCD_PrevAndNext(long entryId, long groupId, 431 Date createDate, 432 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 433 throws NoSuchEntryException; 434 435 /** 436 * Removes all the trash entries where groupId = ? and createDate < ? from the database. 437 * 438 * @param groupId the group ID 439 * @param createDate the create date 440 */ 441 public void removeByG_LtCD(long groupId, Date createDate); 442 443 /** 444 * Returns the number of trash entries where groupId = ? and createDate < ?. 445 * 446 * @param groupId the group ID 447 * @param createDate the create date 448 * @return the number of matching trash entries 449 */ 450 public int countByG_LtCD(long groupId, Date createDate); 451 452 /** 453 * Returns all the trash entries where groupId = ? and classNameId = ?. 454 * 455 * @param groupId the group ID 456 * @param classNameId the class name ID 457 * @return the matching trash entries 458 */ 459 public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId); 460 461 /** 462 * Returns a range of all the trash entries where groupId = ? and classNameId = ?. 463 * 464 * <p> 465 * 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 TrashEntryModelImpl}. 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. 466 * </p> 467 * 468 * @param groupId the group ID 469 * @param classNameId the class name ID 470 * @param start the lower bound of the range of trash entries 471 * @param end the upper bound of the range of trash entries (not inclusive) 472 * @return the range of matching trash entries 473 */ 474 public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId, 475 int start, int end); 476 477 /** 478 * Returns an ordered range of all the trash entries where groupId = ? and classNameId = ?. 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 TrashEntryModelImpl}. 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 groupId the group ID 485 * @param classNameId the class name ID 486 * @param start the lower bound of the range of trash entries 487 * @param end the upper bound of the range of trash entries (not inclusive) 488 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 489 * @return the ordered range of matching trash entries 490 */ 491 public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId, 492 int start, int end, 493 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 494 495 /** 496 * Returns an ordered range of all the trash entries where groupId = ? and classNameId = ?. 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 TrashEntryModelImpl}. 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 groupId the group ID 503 * @param classNameId the class name ID 504 * @param start the lower bound of the range of trash entries 505 * @param end the upper bound of the range of trash entries (not inclusive) 506 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 507 * @param retrieveFromCache whether to retrieve from the finder cache 508 * @return the ordered range of matching trash entries 509 */ 510 public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId, 511 int start, int end, 512 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator, 513 boolean retrieveFromCache); 514 515 /** 516 * Returns the first trash entry in the ordered set where groupId = ? and classNameId = ?. 517 * 518 * @param groupId the group ID 519 * @param classNameId the class name ID 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the first matching trash entry 522 * @throws NoSuchEntryException if a matching trash entry could not be found 523 */ 524 public TrashEntry findByG_C_First(long groupId, long classNameId, 525 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 526 throws NoSuchEntryException; 527 528 /** 529 * Returns the first trash entry in the ordered set where groupId = ? and classNameId = ?. 530 * 531 * @param groupId the group ID 532 * @param classNameId the class name ID 533 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 534 * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found 535 */ 536 public TrashEntry fetchByG_C_First(long groupId, long classNameId, 537 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 538 539 /** 540 * Returns the last trash entry in the ordered set where groupId = ? and classNameId = ?. 541 * 542 * @param groupId the group ID 543 * @param classNameId the class name ID 544 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 545 * @return the last matching trash entry 546 * @throws NoSuchEntryException if a matching trash entry could not be found 547 */ 548 public TrashEntry findByG_C_Last(long groupId, long classNameId, 549 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 550 throws NoSuchEntryException; 551 552 /** 553 * Returns the last trash entry in the ordered set where groupId = ? and classNameId = ?. 554 * 555 * @param groupId the group ID 556 * @param classNameId the class name ID 557 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 558 * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found 559 */ 560 public TrashEntry fetchByG_C_Last(long groupId, long classNameId, 561 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 562 563 /** 564 * Returns the trash entries before and after the current trash entry in the ordered set where groupId = ? and classNameId = ?. 565 * 566 * @param entryId the primary key of the current trash entry 567 * @param groupId the group ID 568 * @param classNameId the class name ID 569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 570 * @return the previous, current, and next trash entry 571 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 572 */ 573 public TrashEntry[] findByG_C_PrevAndNext(long entryId, long groupId, 574 long classNameId, 575 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator) 576 throws NoSuchEntryException; 577 578 /** 579 * Removes all the trash entries where groupId = ? and classNameId = ? from the database. 580 * 581 * @param groupId the group ID 582 * @param classNameId the class name ID 583 */ 584 public void removeByG_C(long groupId, long classNameId); 585 586 /** 587 * Returns the number of trash entries where groupId = ? and classNameId = ?. 588 * 589 * @param groupId the group ID 590 * @param classNameId the class name ID 591 * @return the number of matching trash entries 592 */ 593 public int countByG_C(long groupId, long classNameId); 594 595 /** 596 * Returns the trash entry where classNameId = ? and classPK = ? or throws a {@link NoSuchEntryException} if it could not be found. 597 * 598 * @param classNameId the class name ID 599 * @param classPK the class p k 600 * @return the matching trash entry 601 * @throws NoSuchEntryException if a matching trash entry could not be found 602 */ 603 public TrashEntry findByC_C(long classNameId, long classPK) 604 throws NoSuchEntryException; 605 606 /** 607 * Returns the trash entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 608 * 609 * @param classNameId the class name ID 610 * @param classPK the class p k 611 * @return the matching trash entry, or <code>null</code> if a matching trash entry could not be found 612 */ 613 public TrashEntry fetchByC_C(long classNameId, long classPK); 614 615 /** 616 * Returns the trash entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 617 * 618 * @param classNameId the class name ID 619 * @param classPK the class p k 620 * @param retrieveFromCache whether to retrieve from the finder cache 621 * @return the matching trash entry, or <code>null</code> if a matching trash entry could not be found 622 */ 623 public TrashEntry fetchByC_C(long classNameId, long classPK, 624 boolean retrieveFromCache); 625 626 /** 627 * Removes the trash entry where classNameId = ? and classPK = ? from the database. 628 * 629 * @param classNameId the class name ID 630 * @param classPK the class p k 631 * @return the trash entry that was removed 632 */ 633 public TrashEntry removeByC_C(long classNameId, long classPK) 634 throws NoSuchEntryException; 635 636 /** 637 * Returns the number of trash entries where classNameId = ? and classPK = ?. 638 * 639 * @param classNameId the class name ID 640 * @param classPK the class p k 641 * @return the number of matching trash entries 642 */ 643 public int countByC_C(long classNameId, long classPK); 644 645 /** 646 * Caches the trash entry in the entity cache if it is enabled. 647 * 648 * @param trashEntry the trash entry 649 */ 650 public void cacheResult(TrashEntry trashEntry); 651 652 /** 653 * Caches the trash entries in the entity cache if it is enabled. 654 * 655 * @param trashEntries the trash entries 656 */ 657 public void cacheResult(java.util.List<TrashEntry> trashEntries); 658 659 /** 660 * Creates a new trash entry with the primary key. Does not add the trash entry to the database. 661 * 662 * @param entryId the primary key for the new trash entry 663 * @return the new trash entry 664 */ 665 public TrashEntry create(long entryId); 666 667 /** 668 * Removes the trash entry with the primary key from the database. Also notifies the appropriate model listeners. 669 * 670 * @param entryId the primary key of the trash entry 671 * @return the trash entry that was removed 672 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 673 */ 674 public TrashEntry remove(long entryId) throws NoSuchEntryException; 675 676 public TrashEntry updateImpl(TrashEntry trashEntry); 677 678 /** 679 * Returns the trash entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 680 * 681 * @param entryId the primary key of the trash entry 682 * @return the trash entry 683 * @throws NoSuchEntryException if a trash entry with the primary key could not be found 684 */ 685 public TrashEntry findByPrimaryKey(long entryId) 686 throws NoSuchEntryException; 687 688 /** 689 * Returns the trash entry with the primary key or returns <code>null</code> if it could not be found. 690 * 691 * @param entryId the primary key of the trash entry 692 * @return the trash entry, or <code>null</code> if a trash entry with the primary key could not be found 693 */ 694 public TrashEntry fetchByPrimaryKey(long entryId); 695 696 @Override 697 public java.util.Map<java.io.Serializable, TrashEntry> fetchByPrimaryKeys( 698 java.util.Set<java.io.Serializable> primaryKeys); 699 700 /** 701 * Returns all the trash entries. 702 * 703 * @return the trash entries 704 */ 705 public java.util.List<TrashEntry> findAll(); 706 707 /** 708 * Returns a range of all the trash entries. 709 * 710 * <p> 711 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TrashEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 712 * </p> 713 * 714 * @param start the lower bound of the range of trash entries 715 * @param end the upper bound of the range of trash entries (not inclusive) 716 * @return the range of trash entries 717 */ 718 public java.util.List<TrashEntry> findAll(int start, int end); 719 720 /** 721 * Returns an ordered range of all the trash entries. 722 * 723 * <p> 724 * 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 TrashEntryModelImpl}. 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. 725 * </p> 726 * 727 * @param start the lower bound of the range of trash entries 728 * @param end the upper bound of the range of trash entries (not inclusive) 729 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 730 * @return the ordered range of trash entries 731 */ 732 public java.util.List<TrashEntry> findAll(int start, int end, 733 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator); 734 735 /** 736 * Returns an ordered range of all the trash entries. 737 * 738 * <p> 739 * 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 TrashEntryModelImpl}. 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. 740 * </p> 741 * 742 * @param start the lower bound of the range of trash entries 743 * @param end the upper bound of the range of trash entries (not inclusive) 744 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 745 * @param retrieveFromCache whether to retrieve from the finder cache 746 * @return the ordered range of trash entries 747 */ 748 public java.util.List<TrashEntry> findAll(int start, int end, 749 com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator, 750 boolean retrieveFromCache); 751 752 /** 753 * Removes all the trash entries from the database. 754 */ 755 public void removeAll(); 756 757 /** 758 * Returns the number of trash entries. 759 * 760 * @return the number of trash entries 761 */ 762 public int countAll(); 763 }