001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.documentlibrary.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException; 022 import com.liferay.portlet.documentlibrary.model.DLFileEntry; 023 024 /** 025 * The persistence interface for the document library file 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.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl 033 * @see DLFileEntryUtil 034 * @generated 035 */ 036 @ProviderType 037 public interface DLFileEntryPersistence extends BasePersistence<DLFileEntry> { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify or reference this interface directly. Always use {@link DLFileEntryUtil} to access the document library file entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 042 */ 043 044 /** 045 * Returns all the document library file entries where uuid = ?. 046 * 047 * @param uuid the uuid 048 * @return the matching document library file entries 049 */ 050 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid); 051 052 /** 053 * Returns a range of all the document library file 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 DLFileEntryModelImpl}. 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 document library file entries 061 * @param end the upper bound of the range of document library file entries (not inclusive) 062 * @return the range of matching document library file entries 063 */ 064 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid, 065 int start, int end); 066 067 /** 068 * Returns an ordered range of all the document library file 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 DLFileEntryModelImpl}. 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 document library file entries 076 * @param end the upper bound of the range of document library file entries (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching document library file entries 079 */ 080 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid, 081 int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the document library file 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 DLFileEntryModelImpl}. 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 document library file entries 093 * @param end the upper bound of the range of document library file 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 document library file entries 097 */ 098 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid, 099 int start, int end, 100 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first document library file 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 document library file entry 109 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 110 */ 111 public DLFileEntry findByUuid_First(java.lang.String uuid, 112 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 113 throws NoSuchFileEntryException; 114 115 /** 116 * Returns the first document library file 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 document library file entry, or <code>null</code> if a matching document library file entry could not be found 121 */ 122 public DLFileEntry fetchByUuid_First(java.lang.String uuid, 123 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 124 125 /** 126 * Returns the last document library file 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 document library file entry 131 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 132 */ 133 public DLFileEntry findByUuid_Last(java.lang.String uuid, 134 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 135 throws NoSuchFileEntryException; 136 137 /** 138 * Returns the last document library file 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 document library file entry, or <code>null</code> if a matching document library file entry could not be found 143 */ 144 public DLFileEntry fetchByUuid_Last(java.lang.String uuid, 145 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 146 147 /** 148 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ?. 149 * 150 * @param fileEntryId the primary key of the current document library file 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 document library file entry 154 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 155 */ 156 public DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId, 157 java.lang.String uuid, 158 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 159 throws NoSuchFileEntryException; 160 161 /** 162 * Removes all the document library file entries where uuid = ? from the database. 163 * 164 * @param uuid the uuid 165 */ 166 public void removeByUuid(java.lang.String uuid); 167 168 /** 169 * Returns the number of document library file entries where uuid = ?. 170 * 171 * @param uuid the uuid 172 * @return the number of matching document library file entries 173 */ 174 public int countByUuid(java.lang.String uuid); 175 176 /** 177 * Returns the document library file entry where uuid = ? and groupId = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @return the matching document library file entry 182 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 183 */ 184 public DLFileEntry findByUUID_G(java.lang.String uuid, long groupId) 185 throws NoSuchFileEntryException; 186 187 /** 188 * Returns the document library file entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 193 */ 194 public DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId); 195 196 /** 197 * Returns the document library file entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 198 * 199 * @param uuid the uuid 200 * @param groupId the group ID 201 * @param retrieveFromCache whether to retrieve from the finder cache 202 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 203 */ 204 public DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId, 205 boolean retrieveFromCache); 206 207 /** 208 * Removes the document library file entry where uuid = ? and groupId = ? from the database. 209 * 210 * @param uuid the uuid 211 * @param groupId the group ID 212 * @return the document library file entry that was removed 213 */ 214 public DLFileEntry removeByUUID_G(java.lang.String uuid, long groupId) 215 throws NoSuchFileEntryException; 216 217 /** 218 * Returns the number of document library file entries where uuid = ? and groupId = ?. 219 * 220 * @param uuid the uuid 221 * @param groupId the group ID 222 * @return the number of matching document library file entries 223 */ 224 public int countByUUID_G(java.lang.String uuid, long groupId); 225 226 /** 227 * Returns all the document library file entries where uuid = ? and companyId = ?. 228 * 229 * @param uuid the uuid 230 * @param companyId the company ID 231 * @return the matching document library file entries 232 */ 233 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 234 long companyId); 235 236 /** 237 * Returns a range of all the document library file entries where uuid = ? and companyId = ?. 238 * 239 * <p> 240 * 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 DLFileEntryModelImpl}. 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. 241 * </p> 242 * 243 * @param uuid the uuid 244 * @param companyId the company ID 245 * @param start the lower bound of the range of document library file entries 246 * @param end the upper bound of the range of document library file entries (not inclusive) 247 * @return the range of matching document library file entries 248 */ 249 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 250 long companyId, int start, int end); 251 252 /** 253 * Returns an ordered range of all the document library file entries where uuid = ? and companyId = ?. 254 * 255 * <p> 256 * 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 DLFileEntryModelImpl}. 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. 257 * </p> 258 * 259 * @param uuid the uuid 260 * @param companyId the company ID 261 * @param start the lower bound of the range of document library file entries 262 * @param end the upper bound of the range of document library file entries (not inclusive) 263 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 264 * @return the ordered range of matching document library file entries 265 */ 266 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 267 long companyId, int start, int end, 268 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 269 270 /** 271 * Returns an ordered range of all the document library file entries where uuid = ? and companyId = ?. 272 * 273 * <p> 274 * 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 DLFileEntryModelImpl}. 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. 275 * </p> 276 * 277 * @param uuid the uuid 278 * @param companyId the company ID 279 * @param start the lower bound of the range of document library file entries 280 * @param end the upper bound of the range of document library file entries (not inclusive) 281 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 282 * @param retrieveFromCache whether to retrieve from the finder cache 283 * @return the ordered range of matching document library file entries 284 */ 285 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 286 long companyId, int start, int end, 287 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 288 boolean retrieveFromCache); 289 290 /** 291 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the first matching document library file entry 297 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 298 */ 299 public DLFileEntry findByUuid_C_First(java.lang.String uuid, 300 long companyId, 301 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 302 throws NoSuchFileEntryException; 303 304 /** 305 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 306 * 307 * @param uuid the uuid 308 * @param companyId the company ID 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 311 */ 312 public DLFileEntry fetchByUuid_C_First(java.lang.String uuid, 313 long companyId, 314 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 315 316 /** 317 * Returns the last document library file entry in the ordered set where uuid = ? and companyId = ?. 318 * 319 * @param uuid the uuid 320 * @param companyId the company ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the last matching document library file entry 323 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 324 */ 325 public DLFileEntry findByUuid_C_Last(java.lang.String uuid, long companyId, 326 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 327 throws NoSuchFileEntryException; 328 329 /** 330 * Returns the last document library file 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 document library file entry, or <code>null</code> if a matching document library file entry could not be found 336 */ 337 public DLFileEntry fetchByUuid_C_Last(java.lang.String uuid, 338 long companyId, 339 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 340 341 /** 342 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ? and companyId = ?. 343 * 344 * @param fileEntryId the primary key of the current document library file entry 345 * @param uuid the uuid 346 * @param companyId the company ID 347 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 348 * @return the previous, current, and next document library file entry 349 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 350 */ 351 public DLFileEntry[] findByUuid_C_PrevAndNext(long fileEntryId, 352 java.lang.String uuid, long companyId, 353 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 354 throws NoSuchFileEntryException; 355 356 /** 357 * Removes all the document library file entries where uuid = ? and companyId = ? from the database. 358 * 359 * @param uuid the uuid 360 * @param companyId the company ID 361 */ 362 public void removeByUuid_C(java.lang.String uuid, long companyId); 363 364 /** 365 * Returns the number of document library file entries where uuid = ? and companyId = ?. 366 * 367 * @param uuid the uuid 368 * @param companyId the company ID 369 * @return the number of matching document library file entries 370 */ 371 public int countByUuid_C(java.lang.String uuid, long companyId); 372 373 /** 374 * Returns all the document library file entries where groupId = ?. 375 * 376 * @param groupId the group ID 377 * @return the matching document library file entries 378 */ 379 public java.util.List<DLFileEntry> findByGroupId(long groupId); 380 381 /** 382 * Returns a range of all the document library file entries where groupId = ?. 383 * 384 * <p> 385 * 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 DLFileEntryModelImpl}. 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. 386 * </p> 387 * 388 * @param groupId the group ID 389 * @param start the lower bound of the range of document library file entries 390 * @param end the upper bound of the range of document library file entries (not inclusive) 391 * @return the range of matching document library file entries 392 */ 393 public java.util.List<DLFileEntry> findByGroupId(long groupId, int start, 394 int end); 395 396 /** 397 * Returns an ordered range of all the document library file entries where groupId = ?. 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 DLFileEntryModelImpl}. 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 groupId the group ID 404 * @param start the lower bound of the range of document library file entries 405 * @param end the upper bound of the range of document library file entries (not inclusive) 406 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 407 * @return the ordered range of matching document library file entries 408 */ 409 public java.util.List<DLFileEntry> findByGroupId(long groupId, int start, 410 int end, 411 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 412 413 /** 414 * Returns an ordered range of all the document library file entries where groupId = ?. 415 * 416 * <p> 417 * 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 DLFileEntryModelImpl}. 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. 418 * </p> 419 * 420 * @param groupId the group ID 421 * @param start the lower bound of the range of document library file entries 422 * @param end the upper bound of the range of document library file entries (not inclusive) 423 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 424 * @param retrieveFromCache whether to retrieve from the finder cache 425 * @return the ordered range of matching document library file entries 426 */ 427 public java.util.List<DLFileEntry> findByGroupId(long groupId, int start, 428 int end, 429 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 430 boolean retrieveFromCache); 431 432 /** 433 * Returns the first document library file entry in the ordered set where groupId = ?. 434 * 435 * @param groupId the group ID 436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 437 * @return the first matching document library file entry 438 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 439 */ 440 public DLFileEntry findByGroupId_First(long groupId, 441 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 442 throws NoSuchFileEntryException; 443 444 /** 445 * Returns the first document library file entry in the ordered set where groupId = ?. 446 * 447 * @param groupId the group ID 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 450 */ 451 public DLFileEntry fetchByGroupId_First(long groupId, 452 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 453 454 /** 455 * Returns the last document library file entry in the ordered set where groupId = ?. 456 * 457 * @param groupId the group ID 458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 459 * @return the last matching document library file entry 460 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 461 */ 462 public DLFileEntry findByGroupId_Last(long groupId, 463 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 464 throws NoSuchFileEntryException; 465 466 /** 467 * Returns the last document library file entry in the ordered set where groupId = ?. 468 * 469 * @param groupId the group ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 472 */ 473 public DLFileEntry fetchByGroupId_Last(long groupId, 474 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 475 476 /** 477 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ?. 478 * 479 * @param fileEntryId the primary key of the current document library file entry 480 * @param groupId the group ID 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the previous, current, and next document library file entry 483 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 484 */ 485 public DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId, 486 long groupId, 487 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 488 throws NoSuchFileEntryException; 489 490 /** 491 * Returns all the document library file entries that the user has permission to view where groupId = ?. 492 * 493 * @param groupId the group ID 494 * @return the matching document library file entries that the user has permission to view 495 */ 496 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId); 497 498 /** 499 * Returns a range of all the document library file entries that the user has permission to view where groupId = ?. 500 * 501 * <p> 502 * 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 DLFileEntryModelImpl}. 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. 503 * </p> 504 * 505 * @param groupId the group ID 506 * @param start the lower bound of the range of document library file entries 507 * @param end the upper bound of the range of document library file entries (not inclusive) 508 * @return the range of matching document library file entries that the user has permission to view 509 */ 510 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId, 511 int start, int end); 512 513 /** 514 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ?. 515 * 516 * <p> 517 * 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 DLFileEntryModelImpl}. 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. 518 * </p> 519 * 520 * @param groupId the group ID 521 * @param start the lower bound of the range of document library file entries 522 * @param end the upper bound of the range of document library file entries (not inclusive) 523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 524 * @return the ordered range of matching document library file entries that the user has permission to view 525 */ 526 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId, 527 int start, int end, 528 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 529 530 /** 531 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ?. 532 * 533 * @param fileEntryId the primary key of the current document library file entry 534 * @param groupId the group ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the previous, current, and next document library file entry 537 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 538 */ 539 public DLFileEntry[] filterFindByGroupId_PrevAndNext(long fileEntryId, 540 long groupId, 541 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 542 throws NoSuchFileEntryException; 543 544 /** 545 * Removes all the document library file entries where groupId = ? from the database. 546 * 547 * @param groupId the group ID 548 */ 549 public void removeByGroupId(long groupId); 550 551 /** 552 * Returns the number of document library file entries where groupId = ?. 553 * 554 * @param groupId the group ID 555 * @return the number of matching document library file entries 556 */ 557 public int countByGroupId(long groupId); 558 559 /** 560 * Returns the number of document library file entries that the user has permission to view where groupId = ?. 561 * 562 * @param groupId the group ID 563 * @return the number of matching document library file entries that the user has permission to view 564 */ 565 public int filterCountByGroupId(long groupId); 566 567 /** 568 * Returns all the document library file entries where companyId = ?. 569 * 570 * @param companyId the company ID 571 * @return the matching document library file entries 572 */ 573 public java.util.List<DLFileEntry> findByCompanyId(long companyId); 574 575 /** 576 * Returns a range of all the document library file entries where companyId = ?. 577 * 578 * <p> 579 * 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 DLFileEntryModelImpl}. 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. 580 * </p> 581 * 582 * @param companyId the company ID 583 * @param start the lower bound of the range of document library file entries 584 * @param end the upper bound of the range of document library file entries (not inclusive) 585 * @return the range of matching document library file entries 586 */ 587 public java.util.List<DLFileEntry> findByCompanyId(long companyId, 588 int start, int end); 589 590 /** 591 * Returns an ordered range of all the document library file entries where companyId = ?. 592 * 593 * <p> 594 * 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 DLFileEntryModelImpl}. 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. 595 * </p> 596 * 597 * @param companyId the company ID 598 * @param start the lower bound of the range of document library file entries 599 * @param end the upper bound of the range of document library file entries (not inclusive) 600 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 601 * @return the ordered range of matching document library file entries 602 */ 603 public java.util.List<DLFileEntry> findByCompanyId(long companyId, 604 int start, int end, 605 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 606 607 /** 608 * Returns an ordered range of all the document library file entries where companyId = ?. 609 * 610 * <p> 611 * 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 DLFileEntryModelImpl}. 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. 612 * </p> 613 * 614 * @param companyId the company ID 615 * @param start the lower bound of the range of document library file entries 616 * @param end the upper bound of the range of document library file entries (not inclusive) 617 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 618 * @param retrieveFromCache whether to retrieve from the finder cache 619 * @return the ordered range of matching document library file entries 620 */ 621 public java.util.List<DLFileEntry> findByCompanyId(long companyId, 622 int start, int end, 623 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 624 boolean retrieveFromCache); 625 626 /** 627 * Returns the first document library file entry in the ordered set where companyId = ?. 628 * 629 * @param companyId the company ID 630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 631 * @return the first matching document library file entry 632 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 633 */ 634 public DLFileEntry findByCompanyId_First(long companyId, 635 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 636 throws NoSuchFileEntryException; 637 638 /** 639 * Returns the first document library file entry in the ordered set where companyId = ?. 640 * 641 * @param companyId the company ID 642 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 643 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 644 */ 645 public DLFileEntry fetchByCompanyId_First(long companyId, 646 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 647 648 /** 649 * Returns the last document library file entry in the ordered set where companyId = ?. 650 * 651 * @param companyId the company ID 652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 653 * @return the last matching document library file entry 654 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 655 */ 656 public DLFileEntry findByCompanyId_Last(long companyId, 657 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 658 throws NoSuchFileEntryException; 659 660 /** 661 * Returns the last document library file entry in the ordered set where companyId = ?. 662 * 663 * @param companyId the company ID 664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 665 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 666 */ 667 public DLFileEntry fetchByCompanyId_Last(long companyId, 668 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 669 670 /** 671 * Returns the document library file entries before and after the current document library file entry in the ordered set where companyId = ?. 672 * 673 * @param fileEntryId the primary key of the current document library file entry 674 * @param companyId the company ID 675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 676 * @return the previous, current, and next document library file entry 677 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 678 */ 679 public DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId, 680 long companyId, 681 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 682 throws NoSuchFileEntryException; 683 684 /** 685 * Removes all the document library file entries where companyId = ? from the database. 686 * 687 * @param companyId the company ID 688 */ 689 public void removeByCompanyId(long companyId); 690 691 /** 692 * Returns the number of document library file entries where companyId = ?. 693 * 694 * @param companyId the company ID 695 * @return the number of matching document library file entries 696 */ 697 public int countByCompanyId(long companyId); 698 699 /** 700 * Returns all the document library file entries where repositoryId = ?. 701 * 702 * @param repositoryId the repository ID 703 * @return the matching document library file entries 704 */ 705 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId); 706 707 /** 708 * Returns a range of all the document library file entries where repositoryId = ?. 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 DLFileEntryModelImpl}. 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 repositoryId the repository ID 715 * @param start the lower bound of the range of document library file entries 716 * @param end the upper bound of the range of document library file entries (not inclusive) 717 * @return the range of matching document library file entries 718 */ 719 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId, 720 int start, int end); 721 722 /** 723 * Returns an ordered range of all the document library file entries where repositoryId = ?. 724 * 725 * <p> 726 * 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 DLFileEntryModelImpl}. 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. 727 * </p> 728 * 729 * @param repositoryId the repository ID 730 * @param start the lower bound of the range of document library file entries 731 * @param end the upper bound of the range of document library file entries (not inclusive) 732 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 733 * @return the ordered range of matching document library file entries 734 */ 735 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId, 736 int start, int end, 737 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 738 739 /** 740 * Returns an ordered range of all the document library file entries where repositoryId = ?. 741 * 742 * <p> 743 * 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 DLFileEntryModelImpl}. 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. 744 * </p> 745 * 746 * @param repositoryId the repository ID 747 * @param start the lower bound of the range of document library file entries 748 * @param end the upper bound of the range of document library file entries (not inclusive) 749 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 750 * @param retrieveFromCache whether to retrieve from the finder cache 751 * @return the ordered range of matching document library file entries 752 */ 753 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId, 754 int start, int end, 755 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 756 boolean retrieveFromCache); 757 758 /** 759 * Returns the first document library file entry in the ordered set where repositoryId = ?. 760 * 761 * @param repositoryId the repository ID 762 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 763 * @return the first matching document library file entry 764 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 765 */ 766 public DLFileEntry findByRepositoryId_First(long repositoryId, 767 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 768 throws NoSuchFileEntryException; 769 770 /** 771 * Returns the first document library file entry in the ordered set where repositoryId = ?. 772 * 773 * @param repositoryId the repository ID 774 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 775 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 776 */ 777 public DLFileEntry fetchByRepositoryId_First(long repositoryId, 778 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 779 780 /** 781 * Returns the last document library file entry in the ordered set where repositoryId = ?. 782 * 783 * @param repositoryId the repository ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the last matching document library file entry 786 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 787 */ 788 public DLFileEntry findByRepositoryId_Last(long repositoryId, 789 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 790 throws NoSuchFileEntryException; 791 792 /** 793 * Returns the last document library file entry in the ordered set where repositoryId = ?. 794 * 795 * @param repositoryId the repository ID 796 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 797 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 798 */ 799 public DLFileEntry fetchByRepositoryId_Last(long repositoryId, 800 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 801 802 /** 803 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ?. 804 * 805 * @param fileEntryId the primary key of the current document library file entry 806 * @param repositoryId the repository ID 807 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 808 * @return the previous, current, and next document library file entry 809 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 810 */ 811 public DLFileEntry[] findByRepositoryId_PrevAndNext(long fileEntryId, 812 long repositoryId, 813 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 814 throws NoSuchFileEntryException; 815 816 /** 817 * Removes all the document library file entries where repositoryId = ? from the database. 818 * 819 * @param repositoryId the repository ID 820 */ 821 public void removeByRepositoryId(long repositoryId); 822 823 /** 824 * Returns the number of document library file entries where repositoryId = ?. 825 * 826 * @param repositoryId the repository ID 827 * @return the number of matching document library file entries 828 */ 829 public int countByRepositoryId(long repositoryId); 830 831 /** 832 * Returns all the document library file entries where mimeType = ?. 833 * 834 * @param mimeType the mime type 835 * @return the matching document library file entries 836 */ 837 public java.util.List<DLFileEntry> findByMimeType(java.lang.String mimeType); 838 839 /** 840 * Returns a range of all the document library file entries where mimeType = ?. 841 * 842 * <p> 843 * 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 DLFileEntryModelImpl}. 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. 844 * </p> 845 * 846 * @param mimeType the mime type 847 * @param start the lower bound of the range of document library file entries 848 * @param end the upper bound of the range of document library file entries (not inclusive) 849 * @return the range of matching document library file entries 850 */ 851 public java.util.List<DLFileEntry> findByMimeType( 852 java.lang.String mimeType, int start, int end); 853 854 /** 855 * Returns an ordered range of all the document library file entries where mimeType = ?. 856 * 857 * <p> 858 * 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 DLFileEntryModelImpl}. 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. 859 * </p> 860 * 861 * @param mimeType the mime type 862 * @param start the lower bound of the range of document library file entries 863 * @param end the upper bound of the range of document library file entries (not inclusive) 864 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 865 * @return the ordered range of matching document library file entries 866 */ 867 public java.util.List<DLFileEntry> findByMimeType( 868 java.lang.String mimeType, int start, int end, 869 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 870 871 /** 872 * Returns an ordered range of all the document library file entries where mimeType = ?. 873 * 874 * <p> 875 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 876 * </p> 877 * 878 * @param mimeType the mime type 879 * @param start the lower bound of the range of document library file entries 880 * @param end the upper bound of the range of document library file entries (not inclusive) 881 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 882 * @param retrieveFromCache whether to retrieve from the finder cache 883 * @return the ordered range of matching document library file entries 884 */ 885 public java.util.List<DLFileEntry> findByMimeType( 886 java.lang.String mimeType, int start, int end, 887 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 888 boolean retrieveFromCache); 889 890 /** 891 * Returns the first document library file entry in the ordered set where mimeType = ?. 892 * 893 * @param mimeType the mime type 894 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 895 * @return the first matching document library file entry 896 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 897 */ 898 public DLFileEntry findByMimeType_First(java.lang.String mimeType, 899 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 900 throws NoSuchFileEntryException; 901 902 /** 903 * Returns the first document library file entry in the ordered set where mimeType = ?. 904 * 905 * @param mimeType the mime type 906 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 907 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 908 */ 909 public DLFileEntry fetchByMimeType_First(java.lang.String mimeType, 910 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 911 912 /** 913 * Returns the last document library file entry in the ordered set where mimeType = ?. 914 * 915 * @param mimeType the mime type 916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 917 * @return the last matching document library file entry 918 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 919 */ 920 public DLFileEntry findByMimeType_Last(java.lang.String mimeType, 921 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 922 throws NoSuchFileEntryException; 923 924 /** 925 * Returns the last document library file entry in the ordered set where mimeType = ?. 926 * 927 * @param mimeType the mime type 928 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 929 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 930 */ 931 public DLFileEntry fetchByMimeType_Last(java.lang.String mimeType, 932 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 933 934 /** 935 * Returns the document library file entries before and after the current document library file entry in the ordered set where mimeType = ?. 936 * 937 * @param fileEntryId the primary key of the current document library file entry 938 * @param mimeType the mime type 939 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 940 * @return the previous, current, and next document library file entry 941 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 942 */ 943 public DLFileEntry[] findByMimeType_PrevAndNext(long fileEntryId, 944 java.lang.String mimeType, 945 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 946 throws NoSuchFileEntryException; 947 948 /** 949 * Removes all the document library file entries where mimeType = ? from the database. 950 * 951 * @param mimeType the mime type 952 */ 953 public void removeByMimeType(java.lang.String mimeType); 954 955 /** 956 * Returns the number of document library file entries where mimeType = ?. 957 * 958 * @param mimeType the mime type 959 * @return the number of matching document library file entries 960 */ 961 public int countByMimeType(java.lang.String mimeType); 962 963 /** 964 * Returns all the document library file entries where fileEntryTypeId = ?. 965 * 966 * @param fileEntryTypeId the file entry type ID 967 * @return the matching document library file entries 968 */ 969 public java.util.List<DLFileEntry> findByFileEntryTypeId( 970 long fileEntryTypeId); 971 972 /** 973 * Returns a range of all the document library file entries where fileEntryTypeId = ?. 974 * 975 * <p> 976 * 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 DLFileEntryModelImpl}. 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. 977 * </p> 978 * 979 * @param fileEntryTypeId the file entry type ID 980 * @param start the lower bound of the range of document library file entries 981 * @param end the upper bound of the range of document library file entries (not inclusive) 982 * @return the range of matching document library file entries 983 */ 984 public java.util.List<DLFileEntry> findByFileEntryTypeId( 985 long fileEntryTypeId, int start, int end); 986 987 /** 988 * Returns an ordered range of all the document library file entries where fileEntryTypeId = ?. 989 * 990 * <p> 991 * 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 DLFileEntryModelImpl}. 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. 992 * </p> 993 * 994 * @param fileEntryTypeId the file entry type ID 995 * @param start the lower bound of the range of document library file entries 996 * @param end the upper bound of the range of document library file entries (not inclusive) 997 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 998 * @return the ordered range of matching document library file entries 999 */ 1000 public java.util.List<DLFileEntry> findByFileEntryTypeId( 1001 long fileEntryTypeId, int start, int end, 1002 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1003 1004 /** 1005 * Returns an ordered range of all the document library file entries where fileEntryTypeId = ?. 1006 * 1007 * <p> 1008 * 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 DLFileEntryModelImpl}. 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. 1009 * </p> 1010 * 1011 * @param fileEntryTypeId the file entry type ID 1012 * @param start the lower bound of the range of document library file entries 1013 * @param end the upper bound of the range of document library file entries (not inclusive) 1014 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1015 * @param retrieveFromCache whether to retrieve from the finder cache 1016 * @return the ordered range of matching document library file entries 1017 */ 1018 public java.util.List<DLFileEntry> findByFileEntryTypeId( 1019 long fileEntryTypeId, int start, int end, 1020 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1021 boolean retrieveFromCache); 1022 1023 /** 1024 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 1025 * 1026 * @param fileEntryTypeId the file entry type ID 1027 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1028 * @return the first matching document library file entry 1029 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1030 */ 1031 public DLFileEntry findByFileEntryTypeId_First(long fileEntryTypeId, 1032 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1033 throws NoSuchFileEntryException; 1034 1035 /** 1036 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 1037 * 1038 * @param fileEntryTypeId the file entry type ID 1039 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1040 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1041 */ 1042 public DLFileEntry fetchByFileEntryTypeId_First(long fileEntryTypeId, 1043 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1044 1045 /** 1046 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 1047 * 1048 * @param fileEntryTypeId the file entry type ID 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the last matching document library file entry 1051 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1052 */ 1053 public DLFileEntry findByFileEntryTypeId_Last(long fileEntryTypeId, 1054 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1055 throws NoSuchFileEntryException; 1056 1057 /** 1058 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 1059 * 1060 * @param fileEntryTypeId the file entry type ID 1061 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1062 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1063 */ 1064 public DLFileEntry fetchByFileEntryTypeId_Last(long fileEntryTypeId, 1065 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1066 1067 /** 1068 * Returns the document library file entries before and after the current document library file entry in the ordered set where fileEntryTypeId = ?. 1069 * 1070 * @param fileEntryId the primary key of the current document library file entry 1071 * @param fileEntryTypeId the file entry type ID 1072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1073 * @return the previous, current, and next document library file entry 1074 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1075 */ 1076 public DLFileEntry[] findByFileEntryTypeId_PrevAndNext(long fileEntryId, 1077 long fileEntryTypeId, 1078 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1079 throws NoSuchFileEntryException; 1080 1081 /** 1082 * Removes all the document library file entries where fileEntryTypeId = ? from the database. 1083 * 1084 * @param fileEntryTypeId the file entry type ID 1085 */ 1086 public void removeByFileEntryTypeId(long fileEntryTypeId); 1087 1088 /** 1089 * Returns the number of document library file entries where fileEntryTypeId = ?. 1090 * 1091 * @param fileEntryTypeId the file entry type ID 1092 * @return the number of matching document library file entries 1093 */ 1094 public int countByFileEntryTypeId(long fileEntryTypeId); 1095 1096 /** 1097 * Returns all the document library file entries where groupId = ? and userId = ?. 1098 * 1099 * @param groupId the group ID 1100 * @param userId the user ID 1101 * @return the matching document library file entries 1102 */ 1103 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId); 1104 1105 /** 1106 * Returns a range of all the document library file entries where groupId = ? and userId = ?. 1107 * 1108 * <p> 1109 * 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 DLFileEntryModelImpl}. 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. 1110 * </p> 1111 * 1112 * @param groupId the group ID 1113 * @param userId the user ID 1114 * @param start the lower bound of the range of document library file entries 1115 * @param end the upper bound of the range of document library file entries (not inclusive) 1116 * @return the range of matching document library file entries 1117 */ 1118 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId, 1119 int start, int end); 1120 1121 /** 1122 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ?. 1123 * 1124 * <p> 1125 * 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 DLFileEntryModelImpl}. 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. 1126 * </p> 1127 * 1128 * @param groupId the group ID 1129 * @param userId the user ID 1130 * @param start the lower bound of the range of document library file entries 1131 * @param end the upper bound of the range of document library file entries (not inclusive) 1132 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1133 * @return the ordered range of matching document library file entries 1134 */ 1135 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId, 1136 int start, int end, 1137 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1138 1139 /** 1140 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ?. 1141 * 1142 * <p> 1143 * 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 DLFileEntryModelImpl}. 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. 1144 * </p> 1145 * 1146 * @param groupId the group ID 1147 * @param userId the user ID 1148 * @param start the lower bound of the range of document library file entries 1149 * @param end the upper bound of the range of document library file entries (not inclusive) 1150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1151 * @param retrieveFromCache whether to retrieve from the finder cache 1152 * @return the ordered range of matching document library file entries 1153 */ 1154 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId, 1155 int start, int end, 1156 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1157 boolean retrieveFromCache); 1158 1159 /** 1160 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1161 * 1162 * @param groupId the group ID 1163 * @param userId the user ID 1164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1165 * @return the first matching document library file entry 1166 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1167 */ 1168 public DLFileEntry findByG_U_First(long groupId, long userId, 1169 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1170 throws NoSuchFileEntryException; 1171 1172 /** 1173 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1174 * 1175 * @param groupId the group ID 1176 * @param userId the user ID 1177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1178 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1179 */ 1180 public DLFileEntry fetchByG_U_First(long groupId, long userId, 1181 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1182 1183 /** 1184 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1185 * 1186 * @param groupId the group ID 1187 * @param userId the user ID 1188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1189 * @return the last matching document library file entry 1190 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1191 */ 1192 public DLFileEntry findByG_U_Last(long groupId, long userId, 1193 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1194 throws NoSuchFileEntryException; 1195 1196 /** 1197 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1198 * 1199 * @param groupId the group ID 1200 * @param userId the user ID 1201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1202 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1203 */ 1204 public DLFileEntry fetchByG_U_Last(long groupId, long userId, 1205 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1206 1207 /** 1208 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and userId = ?. 1209 * 1210 * @param fileEntryId the primary key of the current document library file entry 1211 * @param groupId the group ID 1212 * @param userId the user ID 1213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1214 * @return the previous, current, and next document library file entry 1215 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1216 */ 1217 public DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId, long groupId, 1218 long userId, 1219 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1220 throws NoSuchFileEntryException; 1221 1222 /** 1223 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1224 * 1225 * @param groupId the group ID 1226 * @param userId the user ID 1227 * @return the matching document library file entries that the user has permission to view 1228 */ 1229 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, long userId); 1230 1231 /** 1232 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1233 * 1234 * <p> 1235 * 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 DLFileEntryModelImpl}. 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. 1236 * </p> 1237 * 1238 * @param groupId the group ID 1239 * @param userId the user ID 1240 * @param start the lower bound of the range of document library file entries 1241 * @param end the upper bound of the range of document library file entries (not inclusive) 1242 * @return the range of matching document library file entries that the user has permission to view 1243 */ 1244 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, 1245 long userId, int start, int end); 1246 1247 /** 1248 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ?. 1249 * 1250 * <p> 1251 * 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 DLFileEntryModelImpl}. 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. 1252 * </p> 1253 * 1254 * @param groupId the group ID 1255 * @param userId the user ID 1256 * @param start the lower bound of the range of document library file entries 1257 * @param end the upper bound of the range of document library file entries (not inclusive) 1258 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1259 * @return the ordered range of matching document library file entries that the user has permission to view 1260 */ 1261 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, 1262 long userId, int start, int end, 1263 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1264 1265 /** 1266 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and userId = ?. 1267 * 1268 * @param fileEntryId the primary key of the current document library file entry 1269 * @param groupId the group ID 1270 * @param userId the user ID 1271 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1272 * @return the previous, current, and next document library file entry 1273 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1274 */ 1275 public DLFileEntry[] filterFindByG_U_PrevAndNext(long fileEntryId, 1276 long groupId, long userId, 1277 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1278 throws NoSuchFileEntryException; 1279 1280 /** 1281 * Removes all the document library file entries where groupId = ? and userId = ? from the database. 1282 * 1283 * @param groupId the group ID 1284 * @param userId the user ID 1285 */ 1286 public void removeByG_U(long groupId, long userId); 1287 1288 /** 1289 * Returns the number of document library file entries where groupId = ? and userId = ?. 1290 * 1291 * @param groupId the group ID 1292 * @param userId the user ID 1293 * @return the number of matching document library file entries 1294 */ 1295 public int countByG_U(long groupId, long userId); 1296 1297 /** 1298 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ?. 1299 * 1300 * @param groupId the group ID 1301 * @param userId the user ID 1302 * @return the number of matching document library file entries that the user has permission to view 1303 */ 1304 public int filterCountByG_U(long groupId, long userId); 1305 1306 /** 1307 * Returns all the document library file entries where groupId = ? and folderId = ?. 1308 * 1309 * @param groupId the group ID 1310 * @param folderId the folder ID 1311 * @return the matching document library file entries 1312 */ 1313 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId); 1314 1315 /** 1316 * Returns a range of all the document library file entries where groupId = ? and folderId = ?. 1317 * 1318 * <p> 1319 * 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 DLFileEntryModelImpl}. 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. 1320 * </p> 1321 * 1322 * @param groupId the group ID 1323 * @param folderId the folder ID 1324 * @param start the lower bound of the range of document library file entries 1325 * @param end the upper bound of the range of document library file entries (not inclusive) 1326 * @return the range of matching document library file entries 1327 */ 1328 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId, 1329 int start, int end); 1330 1331 /** 1332 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?. 1333 * 1334 * <p> 1335 * 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 DLFileEntryModelImpl}. 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. 1336 * </p> 1337 * 1338 * @param groupId the group ID 1339 * @param folderId the folder ID 1340 * @param start the lower bound of the range of document library file entries 1341 * @param end the upper bound of the range of document library file entries (not inclusive) 1342 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1343 * @return the ordered range of matching document library file entries 1344 */ 1345 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId, 1346 int start, int end, 1347 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1348 1349 /** 1350 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?. 1351 * 1352 * <p> 1353 * 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 DLFileEntryModelImpl}. 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. 1354 * </p> 1355 * 1356 * @param groupId the group ID 1357 * @param folderId the folder ID 1358 * @param start the lower bound of the range of document library file entries 1359 * @param end the upper bound of the range of document library file entries (not inclusive) 1360 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1361 * @param retrieveFromCache whether to retrieve from the finder cache 1362 * @return the ordered range of matching document library file entries 1363 */ 1364 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId, 1365 int start, int end, 1366 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1367 boolean retrieveFromCache); 1368 1369 /** 1370 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1371 * 1372 * @param groupId the group ID 1373 * @param folderId the folder ID 1374 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1375 * @return the first matching document library file entry 1376 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1377 */ 1378 public DLFileEntry findByG_F_First(long groupId, long folderId, 1379 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1380 throws NoSuchFileEntryException; 1381 1382 /** 1383 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1384 * 1385 * @param groupId the group ID 1386 * @param folderId the folder ID 1387 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1388 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1389 */ 1390 public DLFileEntry fetchByG_F_First(long groupId, long folderId, 1391 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1392 1393 /** 1394 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1395 * 1396 * @param groupId the group ID 1397 * @param folderId the folder ID 1398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1399 * @return the last matching document library file entry 1400 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1401 */ 1402 public DLFileEntry findByG_F_Last(long groupId, long folderId, 1403 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1404 throws NoSuchFileEntryException; 1405 1406 /** 1407 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1408 * 1409 * @param groupId the group ID 1410 * @param folderId the folder ID 1411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1412 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1413 */ 1414 public DLFileEntry fetchByG_F_Last(long groupId, long folderId, 1415 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1416 1417 /** 1418 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and folderId = ?. 1419 * 1420 * @param fileEntryId the primary key of the current document library file entry 1421 * @param groupId the group ID 1422 * @param folderId the folder ID 1423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1424 * @return the previous, current, and next document library file entry 1425 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1426 */ 1427 public DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId, long groupId, 1428 long folderId, 1429 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1430 throws NoSuchFileEntryException; 1431 1432 /** 1433 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1434 * 1435 * @param groupId the group ID 1436 * @param folderId the folder ID 1437 * @return the matching document library file entries that the user has permission to view 1438 */ 1439 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1440 long folderId); 1441 1442 /** 1443 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1444 * 1445 * <p> 1446 * 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 DLFileEntryModelImpl}. 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. 1447 * </p> 1448 * 1449 * @param groupId the group ID 1450 * @param folderId the folder ID 1451 * @param start the lower bound of the range of document library file entries 1452 * @param end the upper bound of the range of document library file entries (not inclusive) 1453 * @return the range of matching document library file entries that the user has permission to view 1454 */ 1455 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1456 long folderId, int start, int end); 1457 1458 /** 1459 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ?. 1460 * 1461 * <p> 1462 * 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 DLFileEntryModelImpl}. 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. 1463 * </p> 1464 * 1465 * @param groupId the group ID 1466 * @param folderId the folder ID 1467 * @param start the lower bound of the range of document library file entries 1468 * @param end the upper bound of the range of document library file entries (not inclusive) 1469 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1470 * @return the ordered range of matching document library file entries that the user has permission to view 1471 */ 1472 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1473 long folderId, int start, int end, 1474 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1475 1476 /** 1477 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1478 * 1479 * @param fileEntryId the primary key of the current document library file entry 1480 * @param groupId the group ID 1481 * @param folderId the folder ID 1482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1483 * @return the previous, current, and next document library file entry 1484 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1485 */ 1486 public DLFileEntry[] filterFindByG_F_PrevAndNext(long fileEntryId, 1487 long groupId, long folderId, 1488 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1489 throws NoSuchFileEntryException; 1490 1491 /** 1492 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1493 * 1494 * @param groupId the group ID 1495 * @param folderIds the folder IDs 1496 * @return the matching document library file entries that the user has permission to view 1497 */ 1498 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1499 long[] folderIds); 1500 1501 /** 1502 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1503 * 1504 * <p> 1505 * 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 DLFileEntryModelImpl}. 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. 1506 * </p> 1507 * 1508 * @param groupId the group ID 1509 * @param folderIds the folder IDs 1510 * @param start the lower bound of the range of document library file entries 1511 * @param end the upper bound of the range of document library file entries (not inclusive) 1512 * @return the range of matching document library file entries that the user has permission to view 1513 */ 1514 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1515 long[] folderIds, int start, int end); 1516 1517 /** 1518 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1519 * 1520 * <p> 1521 * 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 DLFileEntryModelImpl}. 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. 1522 * </p> 1523 * 1524 * @param groupId the group ID 1525 * @param folderIds the folder IDs 1526 * @param start the lower bound of the range of document library file entries 1527 * @param end the upper bound of the range of document library file entries (not inclusive) 1528 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1529 * @return the ordered range of matching document library file entries that the user has permission to view 1530 */ 1531 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1532 long[] folderIds, int start, int end, 1533 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1534 1535 /** 1536 * Returns all the document library file entries where groupId = ? and folderId = any ?. 1537 * 1538 * <p> 1539 * 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 DLFileEntryModelImpl}. 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. 1540 * </p> 1541 * 1542 * @param groupId the group ID 1543 * @param folderIds the folder IDs 1544 * @return the matching document library file entries 1545 */ 1546 public java.util.List<DLFileEntry> findByG_F(long groupId, long[] folderIds); 1547 1548 /** 1549 * Returns a range of all the document library file entries where groupId = ? and folderId = any ?. 1550 * 1551 * <p> 1552 * 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 DLFileEntryModelImpl}. 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. 1553 * </p> 1554 * 1555 * @param groupId the group ID 1556 * @param folderIds the folder IDs 1557 * @param start the lower bound of the range of document library file entries 1558 * @param end the upper bound of the range of document library file entries (not inclusive) 1559 * @return the range of matching document library file entries 1560 */ 1561 public java.util.List<DLFileEntry> findByG_F(long groupId, 1562 long[] folderIds, int start, int end); 1563 1564 /** 1565 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ?. 1566 * 1567 * <p> 1568 * 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 DLFileEntryModelImpl}. 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. 1569 * </p> 1570 * 1571 * @param groupId the group ID 1572 * @param folderIds the folder IDs 1573 * @param start the lower bound of the range of document library file entries 1574 * @param end the upper bound of the range of document library file entries (not inclusive) 1575 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1576 * @return the ordered range of matching document library file entries 1577 */ 1578 public java.util.List<DLFileEntry> findByG_F(long groupId, 1579 long[] folderIds, int start, int end, 1580 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1581 1582 /** 1583 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?, optionally using the finder cache. 1584 * 1585 * <p> 1586 * 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 DLFileEntryModelImpl}. 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. 1587 * </p> 1588 * 1589 * @param groupId the group ID 1590 * @param folderId the folder ID 1591 * @param start the lower bound of the range of document library file entries 1592 * @param end the upper bound of the range of document library file entries (not inclusive) 1593 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1594 * @param retrieveFromCache whether to retrieve from the finder cache 1595 * @return the ordered range of matching document library file entries 1596 */ 1597 public java.util.List<DLFileEntry> findByG_F(long groupId, 1598 long[] folderIds, int start, int end, 1599 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1600 boolean retrieveFromCache); 1601 1602 /** 1603 * Removes all the document library file entries where groupId = ? and folderId = ? from the database. 1604 * 1605 * @param groupId the group ID 1606 * @param folderId the folder ID 1607 */ 1608 public void removeByG_F(long groupId, long folderId); 1609 1610 /** 1611 * Returns the number of document library file entries where groupId = ? and folderId = ?. 1612 * 1613 * @param groupId the group ID 1614 * @param folderId the folder ID 1615 * @return the number of matching document library file entries 1616 */ 1617 public int countByG_F(long groupId, long folderId); 1618 1619 /** 1620 * Returns the number of document library file entries where groupId = ? and folderId = any ?. 1621 * 1622 * @param groupId the group ID 1623 * @param folderIds the folder IDs 1624 * @return the number of matching document library file entries 1625 */ 1626 public int countByG_F(long groupId, long[] folderIds); 1627 1628 /** 1629 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1630 * 1631 * @param groupId the group ID 1632 * @param folderId the folder ID 1633 * @return the number of matching document library file entries that the user has permission to view 1634 */ 1635 public int filterCountByG_F(long groupId, long folderId); 1636 1637 /** 1638 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1639 * 1640 * @param groupId the group ID 1641 * @param folderIds the folder IDs 1642 * @return the number of matching document library file entries that the user has permission to view 1643 */ 1644 public int filterCountByG_F(long groupId, long[] folderIds); 1645 1646 /** 1647 * Returns all the document library file entries where repositoryId = ? and folderId = ?. 1648 * 1649 * @param repositoryId the repository ID 1650 * @param folderId the folder ID 1651 * @return the matching document library file entries 1652 */ 1653 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1654 long folderId); 1655 1656 /** 1657 * Returns a range of all the document library file entries where repositoryId = ? and folderId = ?. 1658 * 1659 * <p> 1660 * 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 DLFileEntryModelImpl}. 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. 1661 * </p> 1662 * 1663 * @param repositoryId the repository ID 1664 * @param folderId the folder ID 1665 * @param start the lower bound of the range of document library file entries 1666 * @param end the upper bound of the range of document library file entries (not inclusive) 1667 * @return the range of matching document library file entries 1668 */ 1669 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1670 long folderId, int start, int end); 1671 1672 /** 1673 * Returns an ordered range of all the document library file entries where repositoryId = ? and folderId = ?. 1674 * 1675 * <p> 1676 * 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 DLFileEntryModelImpl}. 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. 1677 * </p> 1678 * 1679 * @param repositoryId the repository ID 1680 * @param folderId the folder ID 1681 * @param start the lower bound of the range of document library file entries 1682 * @param end the upper bound of the range of document library file entries (not inclusive) 1683 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1684 * @return the ordered range of matching document library file entries 1685 */ 1686 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1687 long folderId, int start, int end, 1688 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1689 1690 /** 1691 * Returns an ordered range of all the document library file entries where repositoryId = ? and folderId = ?. 1692 * 1693 * <p> 1694 * 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 DLFileEntryModelImpl}. 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. 1695 * </p> 1696 * 1697 * @param repositoryId the repository ID 1698 * @param folderId the folder ID 1699 * @param start the lower bound of the range of document library file entries 1700 * @param end the upper bound of the range of document library file entries (not inclusive) 1701 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1702 * @param retrieveFromCache whether to retrieve from the finder cache 1703 * @return the ordered range of matching document library file entries 1704 */ 1705 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1706 long folderId, int start, int end, 1707 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1708 boolean retrieveFromCache); 1709 1710 /** 1711 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1712 * 1713 * @param repositoryId the repository ID 1714 * @param folderId the folder ID 1715 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1716 * @return the first matching document library file entry 1717 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1718 */ 1719 public DLFileEntry findByR_F_First(long repositoryId, long folderId, 1720 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1721 throws NoSuchFileEntryException; 1722 1723 /** 1724 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1725 * 1726 * @param repositoryId the repository ID 1727 * @param folderId the folder ID 1728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1729 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1730 */ 1731 public DLFileEntry fetchByR_F_First(long repositoryId, long folderId, 1732 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1733 1734 /** 1735 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1736 * 1737 * @param repositoryId the repository ID 1738 * @param folderId the folder ID 1739 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1740 * @return the last matching document library file entry 1741 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1742 */ 1743 public DLFileEntry findByR_F_Last(long repositoryId, long folderId, 1744 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1745 throws NoSuchFileEntryException; 1746 1747 /** 1748 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1749 * 1750 * @param repositoryId the repository ID 1751 * @param folderId the folder ID 1752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1753 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1754 */ 1755 public DLFileEntry fetchByR_F_Last(long repositoryId, long folderId, 1756 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1757 1758 /** 1759 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1760 * 1761 * @param fileEntryId the primary key of the current document library file entry 1762 * @param repositoryId the repository ID 1763 * @param folderId the folder ID 1764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1765 * @return the previous, current, and next document library file entry 1766 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1767 */ 1768 public DLFileEntry[] findByR_F_PrevAndNext(long fileEntryId, 1769 long repositoryId, long folderId, 1770 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1771 throws NoSuchFileEntryException; 1772 1773 /** 1774 * Removes all the document library file entries where repositoryId = ? and folderId = ? from the database. 1775 * 1776 * @param repositoryId the repository ID 1777 * @param folderId the folder ID 1778 */ 1779 public void removeByR_F(long repositoryId, long folderId); 1780 1781 /** 1782 * Returns the number of document library file entries where repositoryId = ? and folderId = ?. 1783 * 1784 * @param repositoryId the repository ID 1785 * @param folderId the folder ID 1786 * @return the number of matching document library file entries 1787 */ 1788 public int countByR_F(long repositoryId, long folderId); 1789 1790 /** 1791 * Returns all the document library file entries where folderId = ? and name = ?. 1792 * 1793 * @param folderId the folder ID 1794 * @param name the name 1795 * @return the matching document library file entries 1796 */ 1797 public java.util.List<DLFileEntry> findByF_N(long folderId, 1798 java.lang.String name); 1799 1800 /** 1801 * Returns a range of all the document library file entries where folderId = ? and name = ?. 1802 * 1803 * <p> 1804 * 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 DLFileEntryModelImpl}. 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. 1805 * </p> 1806 * 1807 * @param folderId the folder ID 1808 * @param name the name 1809 * @param start the lower bound of the range of document library file entries 1810 * @param end the upper bound of the range of document library file entries (not inclusive) 1811 * @return the range of matching document library file entries 1812 */ 1813 public java.util.List<DLFileEntry> findByF_N(long folderId, 1814 java.lang.String name, int start, int end); 1815 1816 /** 1817 * Returns an ordered range of all the document library file entries where folderId = ? and name = ?. 1818 * 1819 * <p> 1820 * 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 DLFileEntryModelImpl}. 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. 1821 * </p> 1822 * 1823 * @param folderId the folder ID 1824 * @param name the name 1825 * @param start the lower bound of the range of document library file entries 1826 * @param end the upper bound of the range of document library file entries (not inclusive) 1827 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1828 * @return the ordered range of matching document library file entries 1829 */ 1830 public java.util.List<DLFileEntry> findByF_N(long folderId, 1831 java.lang.String name, int start, int end, 1832 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1833 1834 /** 1835 * Returns an ordered range of all the document library file entries where folderId = ? and name = ?. 1836 * 1837 * <p> 1838 * 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 DLFileEntryModelImpl}. 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. 1839 * </p> 1840 * 1841 * @param folderId the folder ID 1842 * @param name the name 1843 * @param start the lower bound of the range of document library file entries 1844 * @param end the upper bound of the range of document library file entries (not inclusive) 1845 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1846 * @param retrieveFromCache whether to retrieve from the finder cache 1847 * @return the ordered range of matching document library file entries 1848 */ 1849 public java.util.List<DLFileEntry> findByF_N(long folderId, 1850 java.lang.String name, int start, int end, 1851 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 1852 boolean retrieveFromCache); 1853 1854 /** 1855 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 1856 * 1857 * @param folderId the folder ID 1858 * @param name the name 1859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1860 * @return the first matching document library file entry 1861 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1862 */ 1863 public DLFileEntry findByF_N_First(long folderId, java.lang.String name, 1864 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1865 throws NoSuchFileEntryException; 1866 1867 /** 1868 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 1869 * 1870 * @param folderId the folder ID 1871 * @param name the name 1872 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1873 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1874 */ 1875 public DLFileEntry fetchByF_N_First(long folderId, java.lang.String name, 1876 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1877 1878 /** 1879 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 1880 * 1881 * @param folderId the folder ID 1882 * @param name the name 1883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1884 * @return the last matching document library file entry 1885 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1886 */ 1887 public DLFileEntry findByF_N_Last(long folderId, java.lang.String name, 1888 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1889 throws NoSuchFileEntryException; 1890 1891 /** 1892 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 1893 * 1894 * @param folderId the folder ID 1895 * @param name the name 1896 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1897 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1898 */ 1899 public DLFileEntry fetchByF_N_Last(long folderId, java.lang.String name, 1900 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1901 1902 /** 1903 * Returns the document library file entries before and after the current document library file entry in the ordered set where folderId = ? and name = ?. 1904 * 1905 * @param fileEntryId the primary key of the current document library file entry 1906 * @param folderId the folder ID 1907 * @param name the name 1908 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1909 * @return the previous, current, and next document library file entry 1910 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1911 */ 1912 public DLFileEntry[] findByF_N_PrevAndNext(long fileEntryId, long folderId, 1913 java.lang.String name, 1914 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1915 throws NoSuchFileEntryException; 1916 1917 /** 1918 * Removes all the document library file entries where folderId = ? and name = ? from the database. 1919 * 1920 * @param folderId the folder ID 1921 * @param name the name 1922 */ 1923 public void removeByF_N(long folderId, java.lang.String name); 1924 1925 /** 1926 * Returns the number of document library file entries where folderId = ? and name = ?. 1927 * 1928 * @param folderId the folder ID 1929 * @param name the name 1930 * @return the number of matching document library file entries 1931 */ 1932 public int countByF_N(long folderId, java.lang.String name); 1933 1934 /** 1935 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1936 * 1937 * @param groupId the group ID 1938 * @param userId the user ID 1939 * @param folderId the folder ID 1940 * @return the matching document library file entries 1941 */ 1942 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1943 long folderId); 1944 1945 /** 1946 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1947 * 1948 * <p> 1949 * 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 DLFileEntryModelImpl}. 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. 1950 * </p> 1951 * 1952 * @param groupId the group ID 1953 * @param userId the user ID 1954 * @param folderId the folder ID 1955 * @param start the lower bound of the range of document library file entries 1956 * @param end the upper bound of the range of document library file entries (not inclusive) 1957 * @return the range of matching document library file entries 1958 */ 1959 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1960 long folderId, int start, int end); 1961 1962 /** 1963 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1964 * 1965 * <p> 1966 * 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 DLFileEntryModelImpl}. 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. 1967 * </p> 1968 * 1969 * @param groupId the group ID 1970 * @param userId the user ID 1971 * @param folderId the folder ID 1972 * @param start the lower bound of the range of document library file entries 1973 * @param end the upper bound of the range of document library file entries (not inclusive) 1974 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1975 * @return the ordered range of matching document library file entries 1976 */ 1977 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1978 long folderId, int start, int end, 1979 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1980 1981 /** 1982 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1983 * 1984 * <p> 1985 * 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 DLFileEntryModelImpl}. 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. 1986 * </p> 1987 * 1988 * @param groupId the group ID 1989 * @param userId the user ID 1990 * @param folderId the folder ID 1991 * @param start the lower bound of the range of document library file entries 1992 * @param end the upper bound of the range of document library file entries (not inclusive) 1993 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1994 * @param retrieveFromCache whether to retrieve from the finder cache 1995 * @return the ordered range of matching document library file entries 1996 */ 1997 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1998 long folderId, int start, int end, 1999 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 2000 boolean retrieveFromCache); 2001 2002 /** 2003 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2004 * 2005 * @param groupId the group ID 2006 * @param userId the user ID 2007 * @param folderId the folder ID 2008 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2009 * @return the first matching document library file entry 2010 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2011 */ 2012 public DLFileEntry findByG_U_F_First(long groupId, long userId, 2013 long folderId, 2014 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2015 throws NoSuchFileEntryException; 2016 2017 /** 2018 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2019 * 2020 * @param groupId the group ID 2021 * @param userId the user ID 2022 * @param folderId the folder ID 2023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2024 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2025 */ 2026 public DLFileEntry fetchByG_U_F_First(long groupId, long userId, 2027 long folderId, 2028 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2029 2030 /** 2031 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2032 * 2033 * @param groupId the group ID 2034 * @param userId the user ID 2035 * @param folderId the folder ID 2036 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2037 * @return the last matching document library file entry 2038 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2039 */ 2040 public DLFileEntry findByG_U_F_Last(long groupId, long userId, 2041 long folderId, 2042 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2043 throws NoSuchFileEntryException; 2044 2045 /** 2046 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2047 * 2048 * @param groupId the group ID 2049 * @param userId the user ID 2050 * @param folderId the folder ID 2051 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2052 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2053 */ 2054 public DLFileEntry fetchByG_U_F_Last(long groupId, long userId, 2055 long folderId, 2056 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2057 2058 /** 2059 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2060 * 2061 * @param fileEntryId the primary key of the current document library file entry 2062 * @param groupId the group ID 2063 * @param userId the user ID 2064 * @param folderId the folder ID 2065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2066 * @return the previous, current, and next document library file entry 2067 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2068 */ 2069 public DLFileEntry[] findByG_U_F_PrevAndNext(long fileEntryId, 2070 long groupId, long userId, long folderId, 2071 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2072 throws NoSuchFileEntryException; 2073 2074 /** 2075 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2076 * 2077 * @param groupId the group ID 2078 * @param userId the user ID 2079 * @param folderId the folder ID 2080 * @return the matching document library file entries that the user has permission to view 2081 */ 2082 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2083 long userId, long folderId); 2084 2085 /** 2086 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2087 * 2088 * <p> 2089 * 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 DLFileEntryModelImpl}. 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. 2090 * </p> 2091 * 2092 * @param groupId the group ID 2093 * @param userId the user ID 2094 * @param folderId the folder ID 2095 * @param start the lower bound of the range of document library file entries 2096 * @param end the upper bound of the range of document library file entries (not inclusive) 2097 * @return the range of matching document library file entries that the user has permission to view 2098 */ 2099 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2100 long userId, long folderId, int start, int end); 2101 2102 /** 2103 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ?. 2104 * 2105 * <p> 2106 * 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 DLFileEntryModelImpl}. 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. 2107 * </p> 2108 * 2109 * @param groupId the group ID 2110 * @param userId the user ID 2111 * @param folderId the folder ID 2112 * @param start the lower bound of the range of document library file entries 2113 * @param end the upper bound of the range of document library file entries (not inclusive) 2114 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2115 * @return the ordered range of matching document library file entries that the user has permission to view 2116 */ 2117 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2118 long userId, long folderId, int start, int end, 2119 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2120 2121 /** 2122 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2123 * 2124 * @param fileEntryId the primary key of the current document library file entry 2125 * @param groupId the group ID 2126 * @param userId the user ID 2127 * @param folderId the folder ID 2128 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2129 * @return the previous, current, and next document library file entry 2130 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2131 */ 2132 public DLFileEntry[] filterFindByG_U_F_PrevAndNext(long fileEntryId, 2133 long groupId, long userId, long folderId, 2134 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2135 throws NoSuchFileEntryException; 2136 2137 /** 2138 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2139 * 2140 * @param groupId the group ID 2141 * @param userId the user ID 2142 * @param folderIds the folder IDs 2143 * @return the matching document library file entries that the user has permission to view 2144 */ 2145 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2146 long userId, long[] folderIds); 2147 2148 /** 2149 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2150 * 2151 * <p> 2152 * 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 DLFileEntryModelImpl}. 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. 2153 * </p> 2154 * 2155 * @param groupId the group ID 2156 * @param userId the user ID 2157 * @param folderIds the folder IDs 2158 * @param start the lower bound of the range of document library file entries 2159 * @param end the upper bound of the range of document library file entries (not inclusive) 2160 * @return the range of matching document library file entries that the user has permission to view 2161 */ 2162 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2163 long userId, long[] folderIds, int start, int end); 2164 2165 /** 2166 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2167 * 2168 * <p> 2169 * 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 DLFileEntryModelImpl}. 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. 2170 * </p> 2171 * 2172 * @param groupId the group ID 2173 * @param userId the user ID 2174 * @param folderIds the folder IDs 2175 * @param start the lower bound of the range of document library file entries 2176 * @param end the upper bound of the range of document library file entries (not inclusive) 2177 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2178 * @return the ordered range of matching document library file entries that the user has permission to view 2179 */ 2180 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 2181 long userId, long[] folderIds, int start, int end, 2182 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2183 2184 /** 2185 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2186 * 2187 * <p> 2188 * 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 DLFileEntryModelImpl}. 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. 2189 * </p> 2190 * 2191 * @param groupId the group ID 2192 * @param userId the user ID 2193 * @param folderIds the folder IDs 2194 * @return the matching document library file entries 2195 */ 2196 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 2197 long[] folderIds); 2198 2199 /** 2200 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2201 * 2202 * <p> 2203 * 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 DLFileEntryModelImpl}. 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. 2204 * </p> 2205 * 2206 * @param groupId the group ID 2207 * @param userId the user ID 2208 * @param folderIds the folder IDs 2209 * @param start the lower bound of the range of document library file entries 2210 * @param end the upper bound of the range of document library file entries (not inclusive) 2211 * @return the range of matching document library file entries 2212 */ 2213 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 2214 long[] folderIds, int start, int end); 2215 2216 /** 2217 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2218 * 2219 * <p> 2220 * 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 DLFileEntryModelImpl}. 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. 2221 * </p> 2222 * 2223 * @param groupId the group ID 2224 * @param userId the user ID 2225 * @param folderIds the folder IDs 2226 * @param start the lower bound of the range of document library file entries 2227 * @param end the upper bound of the range of document library file entries (not inclusive) 2228 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2229 * @return the ordered range of matching document library file entries 2230 */ 2231 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 2232 long[] folderIds, int start, int end, 2233 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2234 2235 /** 2236 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?, optionally using the finder cache. 2237 * 2238 * <p> 2239 * 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 DLFileEntryModelImpl}. 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. 2240 * </p> 2241 * 2242 * @param groupId the group ID 2243 * @param userId the user ID 2244 * @param folderId the folder ID 2245 * @param start the lower bound of the range of document library file entries 2246 * @param end the upper bound of the range of document library file entries (not inclusive) 2247 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2248 * @param retrieveFromCache whether to retrieve from the finder cache 2249 * @return the ordered range of matching document library file entries 2250 */ 2251 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 2252 long[] folderIds, int start, int end, 2253 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 2254 boolean retrieveFromCache); 2255 2256 /** 2257 * Removes all the document library file entries where groupId = ? and userId = ? and folderId = ? from the database. 2258 * 2259 * @param groupId the group ID 2260 * @param userId the user ID 2261 * @param folderId the folder ID 2262 */ 2263 public void removeByG_U_F(long groupId, long userId, long folderId); 2264 2265 /** 2266 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = ?. 2267 * 2268 * @param groupId the group ID 2269 * @param userId the user ID 2270 * @param folderId the folder ID 2271 * @return the number of matching document library file entries 2272 */ 2273 public int countByG_U_F(long groupId, long userId, long folderId); 2274 2275 /** 2276 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = any ?. 2277 * 2278 * @param groupId the group ID 2279 * @param userId the user ID 2280 * @param folderIds the folder IDs 2281 * @return the number of matching document library file entries 2282 */ 2283 public int countByG_U_F(long groupId, long userId, long[] folderIds); 2284 2285 /** 2286 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2287 * 2288 * @param groupId the group ID 2289 * @param userId the user ID 2290 * @param folderId the folder ID 2291 * @return the number of matching document library file entries that the user has permission to view 2292 */ 2293 public int filterCountByG_U_F(long groupId, long userId, long folderId); 2294 2295 /** 2296 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2297 * 2298 * @param groupId the group ID 2299 * @param userId the user ID 2300 * @param folderIds the folder IDs 2301 * @return the number of matching document library file entries that the user has permission to view 2302 */ 2303 public int filterCountByG_U_F(long groupId, long userId, long[] folderIds); 2304 2305 /** 2306 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2307 * 2308 * @param groupId the group ID 2309 * @param folderId the folder ID 2310 * @param name the name 2311 * @return the matching document library file entry 2312 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2313 */ 2314 public DLFileEntry findByG_F_N(long groupId, long folderId, 2315 java.lang.String name) throws NoSuchFileEntryException; 2316 2317 /** 2318 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2319 * 2320 * @param groupId the group ID 2321 * @param folderId the folder ID 2322 * @param name the name 2323 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2324 */ 2325 public DLFileEntry fetchByG_F_N(long groupId, long folderId, 2326 java.lang.String name); 2327 2328 /** 2329 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2330 * 2331 * @param groupId the group ID 2332 * @param folderId the folder ID 2333 * @param name the name 2334 * @param retrieveFromCache whether to retrieve from the finder cache 2335 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2336 */ 2337 public DLFileEntry fetchByG_F_N(long groupId, long folderId, 2338 java.lang.String name, boolean retrieveFromCache); 2339 2340 /** 2341 * Removes the document library file entry where groupId = ? and folderId = ? and name = ? from the database. 2342 * 2343 * @param groupId the group ID 2344 * @param folderId the folder ID 2345 * @param name the name 2346 * @return the document library file entry that was removed 2347 */ 2348 public DLFileEntry removeByG_F_N(long groupId, long folderId, 2349 java.lang.String name) throws NoSuchFileEntryException; 2350 2351 /** 2352 * Returns the number of document library file entries where groupId = ? and folderId = ? and name = ?. 2353 * 2354 * @param groupId the group ID 2355 * @param folderId the folder ID 2356 * @param name the name 2357 * @return the number of matching document library file entries 2358 */ 2359 public int countByG_F_N(long groupId, long folderId, java.lang.String name); 2360 2361 /** 2362 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2363 * 2364 * @param groupId the group ID 2365 * @param folderId the folder ID 2366 * @param fileName the file name 2367 * @return the matching document library file entry 2368 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2369 */ 2370 public DLFileEntry findByG_F_FN(long groupId, long folderId, 2371 java.lang.String fileName) throws NoSuchFileEntryException; 2372 2373 /** 2374 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2375 * 2376 * @param groupId the group ID 2377 * @param folderId the folder ID 2378 * @param fileName the file name 2379 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2380 */ 2381 public DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2382 java.lang.String fileName); 2383 2384 /** 2385 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2386 * 2387 * @param groupId the group ID 2388 * @param folderId the folder ID 2389 * @param fileName the file name 2390 * @param retrieveFromCache whether to retrieve from the finder cache 2391 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2392 */ 2393 public DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2394 java.lang.String fileName, boolean retrieveFromCache); 2395 2396 /** 2397 * Removes the document library file entry where groupId = ? and folderId = ? and fileName = ? from the database. 2398 * 2399 * @param groupId the group ID 2400 * @param folderId the folder ID 2401 * @param fileName the file name 2402 * @return the document library file entry that was removed 2403 */ 2404 public DLFileEntry removeByG_F_FN(long groupId, long folderId, 2405 java.lang.String fileName) throws NoSuchFileEntryException; 2406 2407 /** 2408 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileName = ?. 2409 * 2410 * @param groupId the group ID 2411 * @param folderId the folder ID 2412 * @param fileName the file name 2413 * @return the number of matching document library file entries 2414 */ 2415 public int countByG_F_FN(long groupId, long folderId, 2416 java.lang.String fileName); 2417 2418 /** 2419 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2420 * 2421 * @param groupId the group ID 2422 * @param folderId the folder ID 2423 * @param title the title 2424 * @return the matching document library file entry 2425 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2426 */ 2427 public DLFileEntry findByG_F_T(long groupId, long folderId, 2428 java.lang.String title) throws NoSuchFileEntryException; 2429 2430 /** 2431 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2432 * 2433 * @param groupId the group ID 2434 * @param folderId the folder ID 2435 * @param title the title 2436 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2437 */ 2438 public DLFileEntry fetchByG_F_T(long groupId, long folderId, 2439 java.lang.String title); 2440 2441 /** 2442 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2443 * 2444 * @param groupId the group ID 2445 * @param folderId the folder ID 2446 * @param title the title 2447 * @param retrieveFromCache whether to retrieve from the finder cache 2448 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2449 */ 2450 public DLFileEntry fetchByG_F_T(long groupId, long folderId, 2451 java.lang.String title, boolean retrieveFromCache); 2452 2453 /** 2454 * Removes the document library file entry where groupId = ? and folderId = ? and title = ? from the database. 2455 * 2456 * @param groupId the group ID 2457 * @param folderId the folder ID 2458 * @param title the title 2459 * @return the document library file entry that was removed 2460 */ 2461 public DLFileEntry removeByG_F_T(long groupId, long folderId, 2462 java.lang.String title) throws NoSuchFileEntryException; 2463 2464 /** 2465 * Returns the number of document library file entries where groupId = ? and folderId = ? and title = ?. 2466 * 2467 * @param groupId the group ID 2468 * @param folderId the folder ID 2469 * @param title the title 2470 * @return the number of matching document library file entries 2471 */ 2472 public int countByG_F_T(long groupId, long folderId, java.lang.String title); 2473 2474 /** 2475 * Returns all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2476 * 2477 * @param groupId the group ID 2478 * @param folderId the folder ID 2479 * @param fileEntryTypeId the file entry type ID 2480 * @return the matching document library file entries 2481 */ 2482 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2483 long fileEntryTypeId); 2484 2485 /** 2486 * Returns a range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2487 * 2488 * <p> 2489 * 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 DLFileEntryModelImpl}. 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. 2490 * </p> 2491 * 2492 * @param groupId the group ID 2493 * @param folderId the folder ID 2494 * @param fileEntryTypeId the file entry type ID 2495 * @param start the lower bound of the range of document library file entries 2496 * @param end the upper bound of the range of document library file entries (not inclusive) 2497 * @return the range of matching document library file entries 2498 */ 2499 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2500 long fileEntryTypeId, int start, int end); 2501 2502 /** 2503 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2504 * 2505 * <p> 2506 * 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 DLFileEntryModelImpl}. 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. 2507 * </p> 2508 * 2509 * @param groupId the group ID 2510 * @param folderId the folder ID 2511 * @param fileEntryTypeId the file entry type ID 2512 * @param start the lower bound of the range of document library file entries 2513 * @param end the upper bound of the range of document library file entries (not inclusive) 2514 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2515 * @return the ordered range of matching document library file entries 2516 */ 2517 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2518 long fileEntryTypeId, int start, int end, 2519 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2520 2521 /** 2522 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2523 * 2524 * <p> 2525 * 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 DLFileEntryModelImpl}. 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. 2526 * </p> 2527 * 2528 * @param groupId the group ID 2529 * @param folderId the folder ID 2530 * @param fileEntryTypeId the file entry type ID 2531 * @param start the lower bound of the range of document library file entries 2532 * @param end the upper bound of the range of document library file entries (not inclusive) 2533 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2534 * @param retrieveFromCache whether to retrieve from the finder cache 2535 * @return the ordered range of matching document library file entries 2536 */ 2537 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2538 long fileEntryTypeId, int start, int end, 2539 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 2540 boolean retrieveFromCache); 2541 2542 /** 2543 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2544 * 2545 * @param groupId the group ID 2546 * @param folderId the folder ID 2547 * @param fileEntryTypeId the file entry type ID 2548 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2549 * @return the first matching document library file entry 2550 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2551 */ 2552 public DLFileEntry findByG_F_F_First(long groupId, long folderId, 2553 long fileEntryTypeId, 2554 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2555 throws NoSuchFileEntryException; 2556 2557 /** 2558 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2559 * 2560 * @param groupId the group ID 2561 * @param folderId the folder ID 2562 * @param fileEntryTypeId the file entry type ID 2563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2564 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2565 */ 2566 public DLFileEntry fetchByG_F_F_First(long groupId, long folderId, 2567 long fileEntryTypeId, 2568 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2569 2570 /** 2571 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2572 * 2573 * @param groupId the group ID 2574 * @param folderId the folder ID 2575 * @param fileEntryTypeId the file entry type ID 2576 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2577 * @return the last matching document library file entry 2578 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2579 */ 2580 public DLFileEntry findByG_F_F_Last(long groupId, long folderId, 2581 long fileEntryTypeId, 2582 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2583 throws NoSuchFileEntryException; 2584 2585 /** 2586 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2587 * 2588 * @param groupId the group ID 2589 * @param folderId the folder ID 2590 * @param fileEntryTypeId the file entry type ID 2591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2592 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2593 */ 2594 public DLFileEntry fetchByG_F_F_Last(long groupId, long folderId, 2595 long fileEntryTypeId, 2596 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2597 2598 /** 2599 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2600 * 2601 * @param fileEntryId the primary key of the current document library file entry 2602 * @param groupId the group ID 2603 * @param folderId the folder ID 2604 * @param fileEntryTypeId the file entry type ID 2605 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2606 * @return the previous, current, and next document library file entry 2607 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2608 */ 2609 public DLFileEntry[] findByG_F_F_PrevAndNext(long fileEntryId, 2610 long groupId, long folderId, long fileEntryTypeId, 2611 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2612 throws NoSuchFileEntryException; 2613 2614 /** 2615 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2616 * 2617 * @param groupId the group ID 2618 * @param folderId the folder ID 2619 * @param fileEntryTypeId the file entry type ID 2620 * @return the matching document library file entries that the user has permission to view 2621 */ 2622 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2623 long folderId, long fileEntryTypeId); 2624 2625 /** 2626 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2627 * 2628 * <p> 2629 * 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 DLFileEntryModelImpl}. 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. 2630 * </p> 2631 * 2632 * @param groupId the group ID 2633 * @param folderId the folder ID 2634 * @param fileEntryTypeId the file entry type ID 2635 * @param start the lower bound of the range of document library file entries 2636 * @param end the upper bound of the range of document library file entries (not inclusive) 2637 * @return the range of matching document library file entries that the user has permission to view 2638 */ 2639 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2640 long folderId, long fileEntryTypeId, int start, int end); 2641 2642 /** 2643 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2644 * 2645 * <p> 2646 * 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 DLFileEntryModelImpl}. 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. 2647 * </p> 2648 * 2649 * @param groupId the group ID 2650 * @param folderId the folder ID 2651 * @param fileEntryTypeId the file entry type ID 2652 * @param start the lower bound of the range of document library file entries 2653 * @param end the upper bound of the range of document library file entries (not inclusive) 2654 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2655 * @return the ordered range of matching document library file entries that the user has permission to view 2656 */ 2657 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2658 long folderId, long fileEntryTypeId, int start, int end, 2659 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2660 2661 /** 2662 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2663 * 2664 * @param fileEntryId the primary key of the current document library file entry 2665 * @param groupId the group ID 2666 * @param folderId the folder ID 2667 * @param fileEntryTypeId the file entry type ID 2668 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2669 * @return the previous, current, and next document library file entry 2670 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2671 */ 2672 public DLFileEntry[] filterFindByG_F_F_PrevAndNext(long fileEntryId, 2673 long groupId, long folderId, long fileEntryTypeId, 2674 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2675 throws NoSuchFileEntryException; 2676 2677 /** 2678 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2679 * 2680 * @param groupId the group ID 2681 * @param folderIds the folder IDs 2682 * @param fileEntryTypeId the file entry type ID 2683 * @return the matching document library file entries that the user has permission to view 2684 */ 2685 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2686 long[] folderIds, long fileEntryTypeId); 2687 2688 /** 2689 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2690 * 2691 * <p> 2692 * 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 DLFileEntryModelImpl}. 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. 2693 * </p> 2694 * 2695 * @param groupId the group ID 2696 * @param folderIds the folder IDs 2697 * @param fileEntryTypeId the file entry type ID 2698 * @param start the lower bound of the range of document library file entries 2699 * @param end the upper bound of the range of document library file entries (not inclusive) 2700 * @return the range of matching document library file entries that the user has permission to view 2701 */ 2702 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2703 long[] folderIds, long fileEntryTypeId, int start, int end); 2704 2705 /** 2706 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2707 * 2708 * <p> 2709 * 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 DLFileEntryModelImpl}. 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. 2710 * </p> 2711 * 2712 * @param groupId the group ID 2713 * @param folderIds the folder IDs 2714 * @param fileEntryTypeId the file entry type ID 2715 * @param start the lower bound of the range of document library file entries 2716 * @param end the upper bound of the range of document library file entries (not inclusive) 2717 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2718 * @return the ordered range of matching document library file entries that the user has permission to view 2719 */ 2720 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2721 long[] folderIds, long fileEntryTypeId, int start, int end, 2722 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2723 2724 /** 2725 * Returns all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2726 * 2727 * <p> 2728 * 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 DLFileEntryModelImpl}. 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. 2729 * </p> 2730 * 2731 * @param groupId the group ID 2732 * @param folderIds the folder IDs 2733 * @param fileEntryTypeId the file entry type ID 2734 * @return the matching document library file entries 2735 */ 2736 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2737 long[] folderIds, long fileEntryTypeId); 2738 2739 /** 2740 * Returns a range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2741 * 2742 * <p> 2743 * 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 DLFileEntryModelImpl}. 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. 2744 * </p> 2745 * 2746 * @param groupId the group ID 2747 * @param folderIds the folder IDs 2748 * @param fileEntryTypeId the file entry type ID 2749 * @param start the lower bound of the range of document library file entries 2750 * @param end the upper bound of the range of document library file entries (not inclusive) 2751 * @return the range of matching document library file entries 2752 */ 2753 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2754 long[] folderIds, long fileEntryTypeId, int start, int end); 2755 2756 /** 2757 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2758 * 2759 * <p> 2760 * 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 DLFileEntryModelImpl}. 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. 2761 * </p> 2762 * 2763 * @param groupId the group ID 2764 * @param folderIds the folder IDs 2765 * @param fileEntryTypeId the file entry type ID 2766 * @param start the lower bound of the range of document library file entries 2767 * @param end the upper bound of the range of document library file entries (not inclusive) 2768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2769 * @return the ordered range of matching document library file entries 2770 */ 2771 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2772 long[] folderIds, long fileEntryTypeId, int start, int end, 2773 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2774 2775 /** 2776 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?, optionally using the finder cache. 2777 * 2778 * <p> 2779 * 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 DLFileEntryModelImpl}. 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. 2780 * </p> 2781 * 2782 * @param groupId the group ID 2783 * @param folderId the folder ID 2784 * @param fileEntryTypeId the file entry type ID 2785 * @param start the lower bound of the range of document library file entries 2786 * @param end the upper bound of the range of document library file entries (not inclusive) 2787 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2788 * @param retrieveFromCache whether to retrieve from the finder cache 2789 * @return the ordered range of matching document library file entries 2790 */ 2791 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2792 long[] folderIds, long fileEntryTypeId, int start, int end, 2793 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 2794 boolean retrieveFromCache); 2795 2796 /** 2797 * Removes all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ? from the database. 2798 * 2799 * @param groupId the group ID 2800 * @param folderId the folder ID 2801 * @param fileEntryTypeId the file entry type ID 2802 */ 2803 public void removeByG_F_F(long groupId, long folderId, long fileEntryTypeId); 2804 2805 /** 2806 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2807 * 2808 * @param groupId the group ID 2809 * @param folderId the folder ID 2810 * @param fileEntryTypeId the file entry type ID 2811 * @return the number of matching document library file entries 2812 */ 2813 public int countByG_F_F(long groupId, long folderId, long fileEntryTypeId); 2814 2815 /** 2816 * Returns the number of document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2817 * 2818 * @param groupId the group ID 2819 * @param folderIds the folder IDs 2820 * @param fileEntryTypeId the file entry type ID 2821 * @return the number of matching document library file entries 2822 */ 2823 public int countByG_F_F(long groupId, long[] folderIds, long fileEntryTypeId); 2824 2825 /** 2826 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2827 * 2828 * @param groupId the group ID 2829 * @param folderId the folder ID 2830 * @param fileEntryTypeId the file entry type ID 2831 * @return the number of matching document library file entries that the user has permission to view 2832 */ 2833 public int filterCountByG_F_F(long groupId, long folderId, 2834 long fileEntryTypeId); 2835 2836 /** 2837 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2838 * 2839 * @param groupId the group ID 2840 * @param folderIds the folder IDs 2841 * @param fileEntryTypeId the file entry type ID 2842 * @return the number of matching document library file entries that the user has permission to view 2843 */ 2844 public int filterCountByG_F_F(long groupId, long[] folderIds, 2845 long fileEntryTypeId); 2846 2847 /** 2848 * Caches the document library file entry in the entity cache if it is enabled. 2849 * 2850 * @param dlFileEntry the document library file entry 2851 */ 2852 public void cacheResult(DLFileEntry dlFileEntry); 2853 2854 /** 2855 * Caches the document library file entries in the entity cache if it is enabled. 2856 * 2857 * @param dlFileEntries the document library file entries 2858 */ 2859 public void cacheResult(java.util.List<DLFileEntry> dlFileEntries); 2860 2861 /** 2862 * Creates a new document library file entry with the primary key. Does not add the document library file entry to the database. 2863 * 2864 * @param fileEntryId the primary key for the new document library file entry 2865 * @return the new document library file entry 2866 */ 2867 public DLFileEntry create(long fileEntryId); 2868 2869 /** 2870 * Removes the document library file entry with the primary key from the database. Also notifies the appropriate model listeners. 2871 * 2872 * @param fileEntryId the primary key of the document library file entry 2873 * @return the document library file entry that was removed 2874 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2875 */ 2876 public DLFileEntry remove(long fileEntryId) throws NoSuchFileEntryException; 2877 2878 public DLFileEntry updateImpl(DLFileEntry dlFileEntry); 2879 2880 /** 2881 * Returns the document library file entry with the primary key or throws a {@link NoSuchFileEntryException} if it could not be found. 2882 * 2883 * @param fileEntryId the primary key of the document library file entry 2884 * @return the document library file entry 2885 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2886 */ 2887 public DLFileEntry findByPrimaryKey(long fileEntryId) 2888 throws NoSuchFileEntryException; 2889 2890 /** 2891 * Returns the document library file entry with the primary key or returns <code>null</code> if it could not be found. 2892 * 2893 * @param fileEntryId the primary key of the document library file entry 2894 * @return the document library file entry, or <code>null</code> if a document library file entry with the primary key could not be found 2895 */ 2896 public DLFileEntry fetchByPrimaryKey(long fileEntryId); 2897 2898 @Override 2899 public java.util.Map<java.io.Serializable, DLFileEntry> fetchByPrimaryKeys( 2900 java.util.Set<java.io.Serializable> primaryKeys); 2901 2902 /** 2903 * Returns all the document library file entries. 2904 * 2905 * @return the document library file entries 2906 */ 2907 public java.util.List<DLFileEntry> findAll(); 2908 2909 /** 2910 * Returns a range of all the document library file entries. 2911 * 2912 * <p> 2913 * 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 DLFileEntryModelImpl}. 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. 2914 * </p> 2915 * 2916 * @param start the lower bound of the range of document library file entries 2917 * @param end the upper bound of the range of document library file entries (not inclusive) 2918 * @return the range of document library file entries 2919 */ 2920 public java.util.List<DLFileEntry> findAll(int start, int end); 2921 2922 /** 2923 * Returns an ordered range of all the document library file entries. 2924 * 2925 * <p> 2926 * 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 DLFileEntryModelImpl}. 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. 2927 * </p> 2928 * 2929 * @param start the lower bound of the range of document library file entries 2930 * @param end the upper bound of the range of document library file entries (not inclusive) 2931 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2932 * @return the ordered range of document library file entries 2933 */ 2934 public java.util.List<DLFileEntry> findAll(int start, int end, 2935 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2936 2937 /** 2938 * Returns an ordered range of all the document library file entries. 2939 * 2940 * <p> 2941 * 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 DLFileEntryModelImpl}. 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. 2942 * </p> 2943 * 2944 * @param start the lower bound of the range of document library file entries 2945 * @param end the upper bound of the range of document library file entries (not inclusive) 2946 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2947 * @param retrieveFromCache whether to retrieve from the finder cache 2948 * @return the ordered range of document library file entries 2949 */ 2950 public java.util.List<DLFileEntry> findAll(int start, int end, 2951 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator, 2952 boolean retrieveFromCache); 2953 2954 /** 2955 * Removes all the document library file entries from the database. 2956 */ 2957 public void removeAll(); 2958 2959 /** 2960 * Returns the number of document library file entries. 2961 * 2962 * @return the number of document library file entries 2963 */ 2964 public int countAll(); 2965 2966 @Override 2967 public java.util.Set<java.lang.String> getBadColumnNames(); 2968 }