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.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.documentlibrary.model.DLFileEntry; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the document library file entry service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see DLFileEntryPersistence 038 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DLFileEntryUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(DLFileEntry dlFileEntry) { 060 getPersistence().clearCache(dlFileEntry); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<DLFileEntry> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<DLFileEntry> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<DLFileEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<DLFileEntry> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static DLFileEntry update(DLFileEntry dlFileEntry) { 101 return getPersistence().update(dlFileEntry); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static DLFileEntry update(DLFileEntry dlFileEntry, 108 ServiceContext serviceContext) { 109 return getPersistence().update(dlFileEntry, serviceContext); 110 } 111 112 /** 113 * Returns all the document library file entries where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching document library file entries 117 */ 118 public static List<DLFileEntry> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the document library file entries where uuid = ?. 124 * 125 * <p> 126 * 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. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of document library file entries 131 * @param end the upper bound of the range of document library file entries (not inclusive) 132 * @return the range of matching document library file entries 133 */ 134 public static List<DLFileEntry> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the document library file entries where uuid = ?. 141 * 142 * <p> 143 * 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. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of document library file entries 148 * @param end the upper bound of the range of document library file entries (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching document library file entries 151 */ 152 public static List<DLFileEntry> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the document library file entries where uuid = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of document library file entries 166 * @param end the upper bound of the range of document library file entries (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching document library file entries 170 */ 171 public static List<DLFileEntry> findByUuid(java.lang.String uuid, 172 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first document library file entry in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching document library file entry 185 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 186 */ 187 public static DLFileEntry findByUuid_First(java.lang.String uuid, 188 OrderByComparator<DLFileEntry> orderByComparator) 189 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first document library file entry in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 199 */ 200 public static DLFileEntry fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<DLFileEntry> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last document library file entry in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching document library file entry 211 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 212 */ 213 public static DLFileEntry findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<DLFileEntry> orderByComparator) 215 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last document library file entry in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 225 */ 226 public static DLFileEntry fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<DLFileEntry> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ?. 233 * 234 * @param fileEntryId the primary key of the current document library file entry 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next document library file entry 238 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 239 */ 240 public static DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId, 241 java.lang.String uuid, OrderByComparator<DLFileEntry> orderByComparator) 242 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 243 return getPersistence() 244 .findByUuid_PrevAndNext(fileEntryId, uuid, orderByComparator); 245 } 246 247 /** 248 * Removes all the document library file entries where uuid = ? from the database. 249 * 250 * @param uuid the uuid 251 */ 252 public static void removeByUuid(java.lang.String uuid) { 253 getPersistence().removeByUuid(uuid); 254 } 255 256 /** 257 * Returns the number of document library file entries where uuid = ?. 258 * 259 * @param uuid the uuid 260 * @return the number of matching document library file entries 261 */ 262 public static int countByUuid(java.lang.String uuid) { 263 return getPersistence().countByUuid(uuid); 264 } 265 266 /** 267 * Returns the document library file entry where uuid = ? and groupId = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 268 * 269 * @param uuid the uuid 270 * @param groupId the group ID 271 * @return the matching document library file entry 272 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 273 */ 274 public static DLFileEntry findByUUID_G(java.lang.String uuid, long groupId) 275 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 276 return getPersistence().findByUUID_G(uuid, groupId); 277 } 278 279 /** 280 * 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. 281 * 282 * @param uuid the uuid 283 * @param groupId the group ID 284 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 285 */ 286 public static DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId) { 287 return getPersistence().fetchByUUID_G(uuid, groupId); 288 } 289 290 /** 291 * 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. 292 * 293 * @param uuid the uuid 294 * @param groupId the group ID 295 * @param retrieveFromCache whether to retrieve from the finder cache 296 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 297 */ 298 public static DLFileEntry fetchByUUID_G(java.lang.String uuid, 299 long groupId, boolean retrieveFromCache) { 300 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 301 } 302 303 /** 304 * Removes the document library file entry where uuid = ? and groupId = ? from the database. 305 * 306 * @param uuid the uuid 307 * @param groupId the group ID 308 * @return the document library file entry that was removed 309 */ 310 public static DLFileEntry removeByUUID_G(java.lang.String uuid, long groupId) 311 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 312 return getPersistence().removeByUUID_G(uuid, groupId); 313 } 314 315 /** 316 * Returns the number of document library file entries where uuid = ? and groupId = ?. 317 * 318 * @param uuid the uuid 319 * @param groupId the group ID 320 * @return the number of matching document library file entries 321 */ 322 public static int countByUUID_G(java.lang.String uuid, long groupId) { 323 return getPersistence().countByUUID_G(uuid, groupId); 324 } 325 326 /** 327 * Returns all the document library file entries where uuid = ? and companyId = ?. 328 * 329 * @param uuid the uuid 330 * @param companyId the company ID 331 * @return the matching document library file entries 332 */ 333 public static List<DLFileEntry> findByUuid_C(java.lang.String uuid, 334 long companyId) { 335 return getPersistence().findByUuid_C(uuid, companyId); 336 } 337 338 /** 339 * Returns a range of all the document library file entries where uuid = ? and companyId = ?. 340 * 341 * <p> 342 * 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. 343 * </p> 344 * 345 * @param uuid the uuid 346 * @param companyId the company ID 347 * @param start the lower bound of the range of document library file entries 348 * @param end the upper bound of the range of document library file entries (not inclusive) 349 * @return the range of matching document library file entries 350 */ 351 public static List<DLFileEntry> findByUuid_C(java.lang.String uuid, 352 long companyId, int start, int end) { 353 return getPersistence().findByUuid_C(uuid, companyId, start, end); 354 } 355 356 /** 357 * Returns an ordered range of all the document library file entries where uuid = ? and companyId = ?. 358 * 359 * <p> 360 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 361 * </p> 362 * 363 * @param uuid the uuid 364 * @param companyId the company ID 365 * @param start the lower bound of the range of document library file entries 366 * @param end the upper bound of the range of document library file entries (not inclusive) 367 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 368 * @return the ordered range of matching document library file entries 369 */ 370 public static List<DLFileEntry> findByUuid_C(java.lang.String uuid, 371 long companyId, int start, int end, 372 OrderByComparator<DLFileEntry> orderByComparator) { 373 return getPersistence() 374 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 375 } 376 377 /** 378 * Returns an ordered range of all the document library file entries where uuid = ? and companyId = ?. 379 * 380 * <p> 381 * 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. 382 * </p> 383 * 384 * @param uuid the uuid 385 * @param companyId the company ID 386 * @param start the lower bound of the range of document library file entries 387 * @param end the upper bound of the range of document library file entries (not inclusive) 388 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 389 * @param retrieveFromCache whether to retrieve from the finder cache 390 * @return the ordered range of matching document library file entries 391 */ 392 public static List<DLFileEntry> findByUuid_C(java.lang.String uuid, 393 long companyId, int start, int end, 394 OrderByComparator<DLFileEntry> orderByComparator, 395 boolean retrieveFromCache) { 396 return getPersistence() 397 .findByUuid_C(uuid, companyId, start, end, 398 orderByComparator, retrieveFromCache); 399 } 400 401 /** 402 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 403 * 404 * @param uuid the uuid 405 * @param companyId the company ID 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the first matching document library file entry 408 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 409 */ 410 public static DLFileEntry findByUuid_C_First(java.lang.String uuid, 411 long companyId, OrderByComparator<DLFileEntry> orderByComparator) 412 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 413 return getPersistence() 414 .findByUuid_C_First(uuid, companyId, orderByComparator); 415 } 416 417 /** 418 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 419 * 420 * @param uuid the uuid 421 * @param companyId the company ID 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 424 */ 425 public static DLFileEntry fetchByUuid_C_First(java.lang.String uuid, 426 long companyId, OrderByComparator<DLFileEntry> orderByComparator) { 427 return getPersistence() 428 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 429 } 430 431 /** 432 * Returns the last document library file entry in the ordered set where uuid = ? and companyId = ?. 433 * 434 * @param uuid the uuid 435 * @param companyId the company ID 436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 437 * @return the last matching document library file entry 438 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 439 */ 440 public static DLFileEntry findByUuid_C_Last(java.lang.String uuid, 441 long companyId, OrderByComparator<DLFileEntry> orderByComparator) 442 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 443 return getPersistence() 444 .findByUuid_C_Last(uuid, companyId, orderByComparator); 445 } 446 447 /** 448 * Returns the last document library file entry in the ordered set where uuid = ? and companyId = ?. 449 * 450 * @param uuid the uuid 451 * @param companyId the company ID 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 454 */ 455 public static DLFileEntry fetchByUuid_C_Last(java.lang.String uuid, 456 long companyId, OrderByComparator<DLFileEntry> orderByComparator) { 457 return getPersistence() 458 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 459 } 460 461 /** 462 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ? and companyId = ?. 463 * 464 * @param fileEntryId the primary key of the current document library file entry 465 * @param uuid the uuid 466 * @param companyId the company ID 467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 468 * @return the previous, current, and next document library file entry 469 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 470 */ 471 public static DLFileEntry[] findByUuid_C_PrevAndNext(long fileEntryId, 472 java.lang.String uuid, long companyId, 473 OrderByComparator<DLFileEntry> orderByComparator) 474 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 475 return getPersistence() 476 .findByUuid_C_PrevAndNext(fileEntryId, uuid, companyId, 477 orderByComparator); 478 } 479 480 /** 481 * Removes all the document library file entries where uuid = ? and companyId = ? from the database. 482 * 483 * @param uuid the uuid 484 * @param companyId the company ID 485 */ 486 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 487 getPersistence().removeByUuid_C(uuid, companyId); 488 } 489 490 /** 491 * Returns the number of document library file entries where uuid = ? and companyId = ?. 492 * 493 * @param uuid the uuid 494 * @param companyId the company ID 495 * @return the number of matching document library file entries 496 */ 497 public static int countByUuid_C(java.lang.String uuid, long companyId) { 498 return getPersistence().countByUuid_C(uuid, companyId); 499 } 500 501 /** 502 * Returns all the document library file entries where groupId = ?. 503 * 504 * @param groupId the group ID 505 * @return the matching document library file entries 506 */ 507 public static List<DLFileEntry> findByGroupId(long groupId) { 508 return getPersistence().findByGroupId(groupId); 509 } 510 511 /** 512 * Returns a range of all the document library file entries where groupId = ?. 513 * 514 * <p> 515 * 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. 516 * </p> 517 * 518 * @param groupId the group ID 519 * @param start the lower bound of the range of document library file entries 520 * @param end the upper bound of the range of document library file entries (not inclusive) 521 * @return the range of matching document library file entries 522 */ 523 public static List<DLFileEntry> findByGroupId(long groupId, int start, 524 int end) { 525 return getPersistence().findByGroupId(groupId, start, end); 526 } 527 528 /** 529 * Returns an ordered range of all the document library file entries where groupId = ?. 530 * 531 * <p> 532 * 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. 533 * </p> 534 * 535 * @param groupId the group ID 536 * @param start the lower bound of the range of document library file entries 537 * @param end the upper bound of the range of document library file entries (not inclusive) 538 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 539 * @return the ordered range of matching document library file entries 540 */ 541 public static List<DLFileEntry> findByGroupId(long groupId, int start, 542 int end, OrderByComparator<DLFileEntry> orderByComparator) { 543 return getPersistence() 544 .findByGroupId(groupId, start, end, orderByComparator); 545 } 546 547 /** 548 * Returns an ordered range of all the document library file entries where groupId = ?. 549 * 550 * <p> 551 * 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. 552 * </p> 553 * 554 * @param groupId the group ID 555 * @param start the lower bound of the range of document library file entries 556 * @param end the upper bound of the range of document library file entries (not inclusive) 557 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 558 * @param retrieveFromCache whether to retrieve from the finder cache 559 * @return the ordered range of matching document library file entries 560 */ 561 public static List<DLFileEntry> findByGroupId(long groupId, int start, 562 int end, OrderByComparator<DLFileEntry> orderByComparator, 563 boolean retrieveFromCache) { 564 return getPersistence() 565 .findByGroupId(groupId, start, end, orderByComparator, 566 retrieveFromCache); 567 } 568 569 /** 570 * Returns the first document library file entry in the ordered set where groupId = ?. 571 * 572 * @param groupId the group ID 573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 574 * @return the first matching document library file entry 575 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 576 */ 577 public static DLFileEntry findByGroupId_First(long groupId, 578 OrderByComparator<DLFileEntry> orderByComparator) 579 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 580 return getPersistence().findByGroupId_First(groupId, orderByComparator); 581 } 582 583 /** 584 * Returns the first document library file entry in the ordered set where groupId = ?. 585 * 586 * @param groupId the group ID 587 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 588 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 589 */ 590 public static DLFileEntry fetchByGroupId_First(long groupId, 591 OrderByComparator<DLFileEntry> orderByComparator) { 592 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 593 } 594 595 /** 596 * Returns the last document library file entry in the ordered set where groupId = ?. 597 * 598 * @param groupId the group ID 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the last matching document library file entry 601 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 602 */ 603 public static DLFileEntry findByGroupId_Last(long groupId, 604 OrderByComparator<DLFileEntry> orderByComparator) 605 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 606 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 607 } 608 609 /** 610 * Returns the last document library file entry in the ordered set where groupId = ?. 611 * 612 * @param groupId the group ID 613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 614 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 615 */ 616 public static DLFileEntry fetchByGroupId_Last(long groupId, 617 OrderByComparator<DLFileEntry> orderByComparator) { 618 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 619 } 620 621 /** 622 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ?. 623 * 624 * @param fileEntryId the primary key of the current document library file entry 625 * @param groupId the group ID 626 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 627 * @return the previous, current, and next document library file entry 628 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 629 */ 630 public static DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId, 631 long groupId, OrderByComparator<DLFileEntry> orderByComparator) 632 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 633 return getPersistence() 634 .findByGroupId_PrevAndNext(fileEntryId, groupId, 635 orderByComparator); 636 } 637 638 /** 639 * Returns all the document library file entries that the user has permission to view where groupId = ?. 640 * 641 * @param groupId the group ID 642 * @return the matching document library file entries that the user has permission to view 643 */ 644 public static List<DLFileEntry> filterFindByGroupId(long groupId) { 645 return getPersistence().filterFindByGroupId(groupId); 646 } 647 648 /** 649 * Returns a range of all the document library file entries that the user has permission to view where groupId = ?. 650 * 651 * <p> 652 * 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. 653 * </p> 654 * 655 * @param groupId the group ID 656 * @param start the lower bound of the range of document library file entries 657 * @param end the upper bound of the range of document library file entries (not inclusive) 658 * @return the range of matching document library file entries that the user has permission to view 659 */ 660 public static List<DLFileEntry> filterFindByGroupId(long groupId, 661 int start, int end) { 662 return getPersistence().filterFindByGroupId(groupId, start, end); 663 } 664 665 /** 666 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ?. 667 * 668 * <p> 669 * 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. 670 * </p> 671 * 672 * @param groupId the group ID 673 * @param start the lower bound of the range of document library file entries 674 * @param end the upper bound of the range of document library file entries (not inclusive) 675 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 676 * @return the ordered range of matching document library file entries that the user has permission to view 677 */ 678 public static List<DLFileEntry> filterFindByGroupId(long groupId, 679 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 680 return getPersistence() 681 .filterFindByGroupId(groupId, start, end, orderByComparator); 682 } 683 684 /** 685 * 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 = ?. 686 * 687 * @param fileEntryId the primary key of the current document library file entry 688 * @param groupId the group ID 689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 690 * @return the previous, current, and next document library file entry 691 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 692 */ 693 public static DLFileEntry[] filterFindByGroupId_PrevAndNext( 694 long fileEntryId, long groupId, 695 OrderByComparator<DLFileEntry> orderByComparator) 696 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 697 return getPersistence() 698 .filterFindByGroupId_PrevAndNext(fileEntryId, groupId, 699 orderByComparator); 700 } 701 702 /** 703 * Removes all the document library file entries where groupId = ? from the database. 704 * 705 * @param groupId the group ID 706 */ 707 public static void removeByGroupId(long groupId) { 708 getPersistence().removeByGroupId(groupId); 709 } 710 711 /** 712 * Returns the number of document library file entries where groupId = ?. 713 * 714 * @param groupId the group ID 715 * @return the number of matching document library file entries 716 */ 717 public static int countByGroupId(long groupId) { 718 return getPersistence().countByGroupId(groupId); 719 } 720 721 /** 722 * Returns the number of document library file entries that the user has permission to view where groupId = ?. 723 * 724 * @param groupId the group ID 725 * @return the number of matching document library file entries that the user has permission to view 726 */ 727 public static int filterCountByGroupId(long groupId) { 728 return getPersistence().filterCountByGroupId(groupId); 729 } 730 731 /** 732 * Returns all the document library file entries where companyId = ?. 733 * 734 * @param companyId the company ID 735 * @return the matching document library file entries 736 */ 737 public static List<DLFileEntry> findByCompanyId(long companyId) { 738 return getPersistence().findByCompanyId(companyId); 739 } 740 741 /** 742 * Returns a range of all the document library file entries where companyId = ?. 743 * 744 * <p> 745 * 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. 746 * </p> 747 * 748 * @param companyId the company ID 749 * @param start the lower bound of the range of document library file entries 750 * @param end the upper bound of the range of document library file entries (not inclusive) 751 * @return the range of matching document library file entries 752 */ 753 public static List<DLFileEntry> findByCompanyId(long companyId, int start, 754 int end) { 755 return getPersistence().findByCompanyId(companyId, start, end); 756 } 757 758 /** 759 * Returns an ordered range of all the document library file entries where companyId = ?. 760 * 761 * <p> 762 * 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. 763 * </p> 764 * 765 * @param companyId the company ID 766 * @param start the lower bound of the range of document library file entries 767 * @param end the upper bound of the range of document library file entries (not inclusive) 768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 769 * @return the ordered range of matching document library file entries 770 */ 771 public static List<DLFileEntry> findByCompanyId(long companyId, int start, 772 int end, OrderByComparator<DLFileEntry> orderByComparator) { 773 return getPersistence() 774 .findByCompanyId(companyId, start, end, orderByComparator); 775 } 776 777 /** 778 * Returns an ordered range of all the document library file entries where companyId = ?. 779 * 780 * <p> 781 * 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. 782 * </p> 783 * 784 * @param companyId the company ID 785 * @param start the lower bound of the range of document library file entries 786 * @param end the upper bound of the range of document library file entries (not inclusive) 787 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 788 * @param retrieveFromCache whether to retrieve from the finder cache 789 * @return the ordered range of matching document library file entries 790 */ 791 public static List<DLFileEntry> findByCompanyId(long companyId, int start, 792 int end, OrderByComparator<DLFileEntry> orderByComparator, 793 boolean retrieveFromCache) { 794 return getPersistence() 795 .findByCompanyId(companyId, start, end, orderByComparator, 796 retrieveFromCache); 797 } 798 799 /** 800 * Returns the first document library file entry in the ordered set where companyId = ?. 801 * 802 * @param companyId the company ID 803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 804 * @return the first matching document library file entry 805 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 806 */ 807 public static DLFileEntry findByCompanyId_First(long companyId, 808 OrderByComparator<DLFileEntry> orderByComparator) 809 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 810 return getPersistence() 811 .findByCompanyId_First(companyId, orderByComparator); 812 } 813 814 /** 815 * Returns the first document library file entry in the ordered set where companyId = ?. 816 * 817 * @param companyId the company ID 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 820 */ 821 public static DLFileEntry fetchByCompanyId_First(long companyId, 822 OrderByComparator<DLFileEntry> orderByComparator) { 823 return getPersistence() 824 .fetchByCompanyId_First(companyId, orderByComparator); 825 } 826 827 /** 828 * Returns the last document library file entry in the ordered set where companyId = ?. 829 * 830 * @param companyId the company ID 831 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 832 * @return the last matching document library file entry 833 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 834 */ 835 public static DLFileEntry findByCompanyId_Last(long companyId, 836 OrderByComparator<DLFileEntry> orderByComparator) 837 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 838 return getPersistence() 839 .findByCompanyId_Last(companyId, orderByComparator); 840 } 841 842 /** 843 * Returns the last document library file entry in the ordered set where companyId = ?. 844 * 845 * @param companyId the company ID 846 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 847 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 848 */ 849 public static DLFileEntry fetchByCompanyId_Last(long companyId, 850 OrderByComparator<DLFileEntry> orderByComparator) { 851 return getPersistence() 852 .fetchByCompanyId_Last(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the document library file entries before and after the current document library file entry in the ordered set where companyId = ?. 857 * 858 * @param fileEntryId the primary key of the current document library file entry 859 * @param companyId the company ID 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the previous, current, and next document library file entry 862 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 863 */ 864 public static DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId, 865 long companyId, OrderByComparator<DLFileEntry> orderByComparator) 866 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 867 return getPersistence() 868 .findByCompanyId_PrevAndNext(fileEntryId, companyId, 869 orderByComparator); 870 } 871 872 /** 873 * Removes all the document library file entries where companyId = ? from the database. 874 * 875 * @param companyId the company ID 876 */ 877 public static void removeByCompanyId(long companyId) { 878 getPersistence().removeByCompanyId(companyId); 879 } 880 881 /** 882 * Returns the number of document library file entries where companyId = ?. 883 * 884 * @param companyId the company ID 885 * @return the number of matching document library file entries 886 */ 887 public static int countByCompanyId(long companyId) { 888 return getPersistence().countByCompanyId(companyId); 889 } 890 891 /** 892 * Returns all the document library file entries where repositoryId = ?. 893 * 894 * @param repositoryId the repository ID 895 * @return the matching document library file entries 896 */ 897 public static List<DLFileEntry> findByRepositoryId(long repositoryId) { 898 return getPersistence().findByRepositoryId(repositoryId); 899 } 900 901 /** 902 * Returns a range of all the document library file entries where repositoryId = ?. 903 * 904 * <p> 905 * 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. 906 * </p> 907 * 908 * @param repositoryId the repository ID 909 * @param start the lower bound of the range of document library file entries 910 * @param end the upper bound of the range of document library file entries (not inclusive) 911 * @return the range of matching document library file entries 912 */ 913 public static List<DLFileEntry> findByRepositoryId(long repositoryId, 914 int start, int end) { 915 return getPersistence().findByRepositoryId(repositoryId, start, end); 916 } 917 918 /** 919 * Returns an ordered range of all the document library file entries where repositoryId = ?. 920 * 921 * <p> 922 * 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. 923 * </p> 924 * 925 * @param repositoryId the repository ID 926 * @param start the lower bound of the range of document library file entries 927 * @param end the upper bound of the range of document library file entries (not inclusive) 928 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 929 * @return the ordered range of matching document library file entries 930 */ 931 public static List<DLFileEntry> findByRepositoryId(long repositoryId, 932 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 933 return getPersistence() 934 .findByRepositoryId(repositoryId, start, end, 935 orderByComparator); 936 } 937 938 /** 939 * Returns an ordered range of all the document library file entries where repositoryId = ?. 940 * 941 * <p> 942 * 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. 943 * </p> 944 * 945 * @param repositoryId the repository ID 946 * @param start the lower bound of the range of document library file entries 947 * @param end the upper bound of the range of document library file entries (not inclusive) 948 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 949 * @param retrieveFromCache whether to retrieve from the finder cache 950 * @return the ordered range of matching document library file entries 951 */ 952 public static List<DLFileEntry> findByRepositoryId(long repositoryId, 953 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 954 boolean retrieveFromCache) { 955 return getPersistence() 956 .findByRepositoryId(repositoryId, start, end, 957 orderByComparator, retrieveFromCache); 958 } 959 960 /** 961 * Returns the first document library file entry in the ordered set where repositoryId = ?. 962 * 963 * @param repositoryId the repository ID 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the first matching document library file entry 966 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 967 */ 968 public static DLFileEntry findByRepositoryId_First(long repositoryId, 969 OrderByComparator<DLFileEntry> orderByComparator) 970 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 971 return getPersistence() 972 .findByRepositoryId_First(repositoryId, orderByComparator); 973 } 974 975 /** 976 * Returns the first document library file entry in the ordered set where repositoryId = ?. 977 * 978 * @param repositoryId the repository ID 979 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 980 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 981 */ 982 public static DLFileEntry fetchByRepositoryId_First(long repositoryId, 983 OrderByComparator<DLFileEntry> orderByComparator) { 984 return getPersistence() 985 .fetchByRepositoryId_First(repositoryId, orderByComparator); 986 } 987 988 /** 989 * Returns the last document library file entry in the ordered set where repositoryId = ?. 990 * 991 * @param repositoryId the repository ID 992 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 993 * @return the last matching document library file entry 994 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 995 */ 996 public static DLFileEntry findByRepositoryId_Last(long repositoryId, 997 OrderByComparator<DLFileEntry> orderByComparator) 998 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 999 return getPersistence() 1000 .findByRepositoryId_Last(repositoryId, orderByComparator); 1001 } 1002 1003 /** 1004 * Returns the last document library file entry in the ordered set where repositoryId = ?. 1005 * 1006 * @param repositoryId the repository ID 1007 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1008 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1009 */ 1010 public static DLFileEntry fetchByRepositoryId_Last(long repositoryId, 1011 OrderByComparator<DLFileEntry> orderByComparator) { 1012 return getPersistence() 1013 .fetchByRepositoryId_Last(repositoryId, orderByComparator); 1014 } 1015 1016 /** 1017 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ?. 1018 * 1019 * @param fileEntryId the primary key of the current document library file entry 1020 * @param repositoryId the repository ID 1021 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1022 * @return the previous, current, and next document library file entry 1023 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1024 */ 1025 public static DLFileEntry[] findByRepositoryId_PrevAndNext( 1026 long fileEntryId, long repositoryId, 1027 OrderByComparator<DLFileEntry> orderByComparator) 1028 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1029 return getPersistence() 1030 .findByRepositoryId_PrevAndNext(fileEntryId, repositoryId, 1031 orderByComparator); 1032 } 1033 1034 /** 1035 * Removes all the document library file entries where repositoryId = ? from the database. 1036 * 1037 * @param repositoryId the repository ID 1038 */ 1039 public static void removeByRepositoryId(long repositoryId) { 1040 getPersistence().removeByRepositoryId(repositoryId); 1041 } 1042 1043 /** 1044 * Returns the number of document library file entries where repositoryId = ?. 1045 * 1046 * @param repositoryId the repository ID 1047 * @return the number of matching document library file entries 1048 */ 1049 public static int countByRepositoryId(long repositoryId) { 1050 return getPersistence().countByRepositoryId(repositoryId); 1051 } 1052 1053 /** 1054 * Returns all the document library file entries where mimeType = ?. 1055 * 1056 * @param mimeType the mime type 1057 * @return the matching document library file entries 1058 */ 1059 public static List<DLFileEntry> findByMimeType(java.lang.String mimeType) { 1060 return getPersistence().findByMimeType(mimeType); 1061 } 1062 1063 /** 1064 * Returns a range of all the document library file entries where mimeType = ?. 1065 * 1066 * <p> 1067 * 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. 1068 * </p> 1069 * 1070 * @param mimeType the mime type 1071 * @param start the lower bound of the range of document library file entries 1072 * @param end the upper bound of the range of document library file entries (not inclusive) 1073 * @return the range of matching document library file entries 1074 */ 1075 public static List<DLFileEntry> findByMimeType(java.lang.String mimeType, 1076 int start, int end) { 1077 return getPersistence().findByMimeType(mimeType, start, end); 1078 } 1079 1080 /** 1081 * Returns an ordered range of all the document library file entries where mimeType = ?. 1082 * 1083 * <p> 1084 * 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. 1085 * </p> 1086 * 1087 * @param mimeType the mime type 1088 * @param start the lower bound of the range of document library file entries 1089 * @param end the upper bound of the range of document library file entries (not inclusive) 1090 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1091 * @return the ordered range of matching document library file entries 1092 */ 1093 public static List<DLFileEntry> findByMimeType(java.lang.String mimeType, 1094 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 1095 return getPersistence() 1096 .findByMimeType(mimeType, start, end, orderByComparator); 1097 } 1098 1099 /** 1100 * Returns an ordered range of all the document library file entries where mimeType = ?. 1101 * 1102 * <p> 1103 * 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. 1104 * </p> 1105 * 1106 * @param mimeType the mime type 1107 * @param start the lower bound of the range of document library file entries 1108 * @param end the upper bound of the range of document library file entries (not inclusive) 1109 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1110 * @param retrieveFromCache whether to retrieve from the finder cache 1111 * @return the ordered range of matching document library file entries 1112 */ 1113 public static List<DLFileEntry> findByMimeType(java.lang.String mimeType, 1114 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 1115 boolean retrieveFromCache) { 1116 return getPersistence() 1117 .findByMimeType(mimeType, start, end, orderByComparator, 1118 retrieveFromCache); 1119 } 1120 1121 /** 1122 * Returns the first document library file entry in the ordered set where mimeType = ?. 1123 * 1124 * @param mimeType the mime type 1125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1126 * @return the first matching document library file entry 1127 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1128 */ 1129 public static DLFileEntry findByMimeType_First(java.lang.String mimeType, 1130 OrderByComparator<DLFileEntry> orderByComparator) 1131 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1132 return getPersistence().findByMimeType_First(mimeType, orderByComparator); 1133 } 1134 1135 /** 1136 * Returns the first document library file entry in the ordered set where mimeType = ?. 1137 * 1138 * @param mimeType the mime type 1139 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1140 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1141 */ 1142 public static DLFileEntry fetchByMimeType_First(java.lang.String mimeType, 1143 OrderByComparator<DLFileEntry> orderByComparator) { 1144 return getPersistence() 1145 .fetchByMimeType_First(mimeType, orderByComparator); 1146 } 1147 1148 /** 1149 * Returns the last document library file entry in the ordered set where mimeType = ?. 1150 * 1151 * @param mimeType the mime type 1152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1153 * @return the last matching document library file entry 1154 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1155 */ 1156 public static DLFileEntry findByMimeType_Last(java.lang.String mimeType, 1157 OrderByComparator<DLFileEntry> orderByComparator) 1158 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1159 return getPersistence().findByMimeType_Last(mimeType, orderByComparator); 1160 } 1161 1162 /** 1163 * Returns the last document library file entry in the ordered set where mimeType = ?. 1164 * 1165 * @param mimeType the mime type 1166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1167 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1168 */ 1169 public static DLFileEntry fetchByMimeType_Last(java.lang.String mimeType, 1170 OrderByComparator<DLFileEntry> orderByComparator) { 1171 return getPersistence().fetchByMimeType_Last(mimeType, orderByComparator); 1172 } 1173 1174 /** 1175 * Returns the document library file entries before and after the current document library file entry in the ordered set where mimeType = ?. 1176 * 1177 * @param fileEntryId the primary key of the current document library file entry 1178 * @param mimeType the mime type 1179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1180 * @return the previous, current, and next document library file entry 1181 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1182 */ 1183 public static DLFileEntry[] findByMimeType_PrevAndNext(long fileEntryId, 1184 java.lang.String mimeType, 1185 OrderByComparator<DLFileEntry> orderByComparator) 1186 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1187 return getPersistence() 1188 .findByMimeType_PrevAndNext(fileEntryId, mimeType, 1189 orderByComparator); 1190 } 1191 1192 /** 1193 * Removes all the document library file entries where mimeType = ? from the database. 1194 * 1195 * @param mimeType the mime type 1196 */ 1197 public static void removeByMimeType(java.lang.String mimeType) { 1198 getPersistence().removeByMimeType(mimeType); 1199 } 1200 1201 /** 1202 * Returns the number of document library file entries where mimeType = ?. 1203 * 1204 * @param mimeType the mime type 1205 * @return the number of matching document library file entries 1206 */ 1207 public static int countByMimeType(java.lang.String mimeType) { 1208 return getPersistence().countByMimeType(mimeType); 1209 } 1210 1211 /** 1212 * Returns all the document library file entries where fileEntryTypeId = ?. 1213 * 1214 * @param fileEntryTypeId the file entry type ID 1215 * @return the matching document library file entries 1216 */ 1217 public static List<DLFileEntry> findByFileEntryTypeId(long fileEntryTypeId) { 1218 return getPersistence().findByFileEntryTypeId(fileEntryTypeId); 1219 } 1220 1221 /** 1222 * Returns a range of all the document library file entries where fileEntryTypeId = ?. 1223 * 1224 * <p> 1225 * 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. 1226 * </p> 1227 * 1228 * @param fileEntryTypeId the file entry type ID 1229 * @param start the lower bound of the range of document library file entries 1230 * @param end the upper bound of the range of document library file entries (not inclusive) 1231 * @return the range of matching document library file entries 1232 */ 1233 public static List<DLFileEntry> findByFileEntryTypeId( 1234 long fileEntryTypeId, int start, int end) { 1235 return getPersistence() 1236 .findByFileEntryTypeId(fileEntryTypeId, start, end); 1237 } 1238 1239 /** 1240 * Returns an ordered range of all the document library file entries where fileEntryTypeId = ?. 1241 * 1242 * <p> 1243 * 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. 1244 * </p> 1245 * 1246 * @param fileEntryTypeId the file entry type ID 1247 * @param start the lower bound of the range of document library file entries 1248 * @param end the upper bound of the range of document library file entries (not inclusive) 1249 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1250 * @return the ordered range of matching document library file entries 1251 */ 1252 public static List<DLFileEntry> findByFileEntryTypeId( 1253 long fileEntryTypeId, int start, int end, 1254 OrderByComparator<DLFileEntry> orderByComparator) { 1255 return getPersistence() 1256 .findByFileEntryTypeId(fileEntryTypeId, start, end, 1257 orderByComparator); 1258 } 1259 1260 /** 1261 * Returns an ordered range of all the document library file entries where fileEntryTypeId = ?. 1262 * 1263 * <p> 1264 * 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. 1265 * </p> 1266 * 1267 * @param fileEntryTypeId the file entry type ID 1268 * @param start the lower bound of the range of document library file entries 1269 * @param end the upper bound of the range of document library file entries (not inclusive) 1270 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1271 * @param retrieveFromCache whether to retrieve from the finder cache 1272 * @return the ordered range of matching document library file entries 1273 */ 1274 public static List<DLFileEntry> findByFileEntryTypeId( 1275 long fileEntryTypeId, int start, int end, 1276 OrderByComparator<DLFileEntry> orderByComparator, 1277 boolean retrieveFromCache) { 1278 return getPersistence() 1279 .findByFileEntryTypeId(fileEntryTypeId, start, end, 1280 orderByComparator, retrieveFromCache); 1281 } 1282 1283 /** 1284 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 1285 * 1286 * @param fileEntryTypeId the file entry type ID 1287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1288 * @return the first matching document library file entry 1289 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1290 */ 1291 public static DLFileEntry findByFileEntryTypeId_First( 1292 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) 1293 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1294 return getPersistence() 1295 .findByFileEntryTypeId_First(fileEntryTypeId, 1296 orderByComparator); 1297 } 1298 1299 /** 1300 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 1301 * 1302 * @param fileEntryTypeId the file entry type ID 1303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1304 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1305 */ 1306 public static DLFileEntry fetchByFileEntryTypeId_First( 1307 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) { 1308 return getPersistence() 1309 .fetchByFileEntryTypeId_First(fileEntryTypeId, 1310 orderByComparator); 1311 } 1312 1313 /** 1314 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 1315 * 1316 * @param fileEntryTypeId the file entry type ID 1317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1318 * @return the last matching document library file entry 1319 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1320 */ 1321 public static DLFileEntry findByFileEntryTypeId_Last(long fileEntryTypeId, 1322 OrderByComparator<DLFileEntry> orderByComparator) 1323 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1324 return getPersistence() 1325 .findByFileEntryTypeId_Last(fileEntryTypeId, 1326 orderByComparator); 1327 } 1328 1329 /** 1330 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 1331 * 1332 * @param fileEntryTypeId the file entry type ID 1333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1334 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1335 */ 1336 public static DLFileEntry fetchByFileEntryTypeId_Last( 1337 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) { 1338 return getPersistence() 1339 .fetchByFileEntryTypeId_Last(fileEntryTypeId, 1340 orderByComparator); 1341 } 1342 1343 /** 1344 * Returns the document library file entries before and after the current document library file entry in the ordered set where fileEntryTypeId = ?. 1345 * 1346 * @param fileEntryId the primary key of the current document library file entry 1347 * @param fileEntryTypeId the file entry type ID 1348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1349 * @return the previous, current, and next document library file entry 1350 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1351 */ 1352 public static DLFileEntry[] findByFileEntryTypeId_PrevAndNext( 1353 long fileEntryId, long fileEntryTypeId, 1354 OrderByComparator<DLFileEntry> orderByComparator) 1355 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1356 return getPersistence() 1357 .findByFileEntryTypeId_PrevAndNext(fileEntryId, 1358 fileEntryTypeId, orderByComparator); 1359 } 1360 1361 /** 1362 * Removes all the document library file entries where fileEntryTypeId = ? from the database. 1363 * 1364 * @param fileEntryTypeId the file entry type ID 1365 */ 1366 public static void removeByFileEntryTypeId(long fileEntryTypeId) { 1367 getPersistence().removeByFileEntryTypeId(fileEntryTypeId); 1368 } 1369 1370 /** 1371 * Returns the number of document library file entries where fileEntryTypeId = ?. 1372 * 1373 * @param fileEntryTypeId the file entry type ID 1374 * @return the number of matching document library file entries 1375 */ 1376 public static int countByFileEntryTypeId(long fileEntryTypeId) { 1377 return getPersistence().countByFileEntryTypeId(fileEntryTypeId); 1378 } 1379 1380 /** 1381 * Returns all the document library file entries where groupId = ? and userId = ?. 1382 * 1383 * @param groupId the group ID 1384 * @param userId the user ID 1385 * @return the matching document library file entries 1386 */ 1387 public static List<DLFileEntry> findByG_U(long groupId, long userId) { 1388 return getPersistence().findByG_U(groupId, userId); 1389 } 1390 1391 /** 1392 * Returns a range of all the document library file entries where groupId = ? and userId = ?. 1393 * 1394 * <p> 1395 * 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. 1396 * </p> 1397 * 1398 * @param groupId the group ID 1399 * @param userId the user ID 1400 * @param start the lower bound of the range of document library file entries 1401 * @param end the upper bound of the range of document library file entries (not inclusive) 1402 * @return the range of matching document library file entries 1403 */ 1404 public static List<DLFileEntry> findByG_U(long groupId, long userId, 1405 int start, int end) { 1406 return getPersistence().findByG_U(groupId, userId, start, end); 1407 } 1408 1409 /** 1410 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ?. 1411 * 1412 * <p> 1413 * 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. 1414 * </p> 1415 * 1416 * @param groupId the group ID 1417 * @param userId the user ID 1418 * @param start the lower bound of the range of document library file entries 1419 * @param end the upper bound of the range of document library file entries (not inclusive) 1420 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1421 * @return the ordered range of matching document library file entries 1422 */ 1423 public static List<DLFileEntry> findByG_U(long groupId, long userId, 1424 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 1425 return getPersistence() 1426 .findByG_U(groupId, userId, start, end, orderByComparator); 1427 } 1428 1429 /** 1430 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ?. 1431 * 1432 * <p> 1433 * 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. 1434 * </p> 1435 * 1436 * @param groupId the group ID 1437 * @param userId the user ID 1438 * @param start the lower bound of the range of document library file entries 1439 * @param end the upper bound of the range of document library file entries (not inclusive) 1440 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1441 * @param retrieveFromCache whether to retrieve from the finder cache 1442 * @return the ordered range of matching document library file entries 1443 */ 1444 public static List<DLFileEntry> findByG_U(long groupId, long userId, 1445 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 1446 boolean retrieveFromCache) { 1447 return getPersistence() 1448 .findByG_U(groupId, userId, start, end, orderByComparator, 1449 retrieveFromCache); 1450 } 1451 1452 /** 1453 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1454 * 1455 * @param groupId the group ID 1456 * @param userId the user ID 1457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1458 * @return the first matching document library file entry 1459 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1460 */ 1461 public static DLFileEntry findByG_U_First(long groupId, long userId, 1462 OrderByComparator<DLFileEntry> orderByComparator) 1463 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1464 return getPersistence() 1465 .findByG_U_First(groupId, userId, orderByComparator); 1466 } 1467 1468 /** 1469 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1470 * 1471 * @param groupId the group ID 1472 * @param userId the user ID 1473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1474 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1475 */ 1476 public static DLFileEntry fetchByG_U_First(long groupId, long userId, 1477 OrderByComparator<DLFileEntry> orderByComparator) { 1478 return getPersistence() 1479 .fetchByG_U_First(groupId, userId, orderByComparator); 1480 } 1481 1482 /** 1483 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1484 * 1485 * @param groupId the group ID 1486 * @param userId the user ID 1487 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1488 * @return the last matching document library file entry 1489 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1490 */ 1491 public static DLFileEntry findByG_U_Last(long groupId, long userId, 1492 OrderByComparator<DLFileEntry> orderByComparator) 1493 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1494 return getPersistence() 1495 .findByG_U_Last(groupId, userId, orderByComparator); 1496 } 1497 1498 /** 1499 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1500 * 1501 * @param groupId the group ID 1502 * @param userId the user ID 1503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1504 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1505 */ 1506 public static DLFileEntry fetchByG_U_Last(long groupId, long userId, 1507 OrderByComparator<DLFileEntry> orderByComparator) { 1508 return getPersistence() 1509 .fetchByG_U_Last(groupId, userId, orderByComparator); 1510 } 1511 1512 /** 1513 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and userId = ?. 1514 * 1515 * @param fileEntryId the primary key of the current document library file entry 1516 * @param groupId the group ID 1517 * @param userId the user ID 1518 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1519 * @return the previous, current, and next document library file entry 1520 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1521 */ 1522 public static DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId, 1523 long groupId, long userId, 1524 OrderByComparator<DLFileEntry> orderByComparator) 1525 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1526 return getPersistence() 1527 .findByG_U_PrevAndNext(fileEntryId, groupId, userId, 1528 orderByComparator); 1529 } 1530 1531 /** 1532 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1533 * 1534 * @param groupId the group ID 1535 * @param userId the user ID 1536 * @return the matching document library file entries that the user has permission to view 1537 */ 1538 public static List<DLFileEntry> filterFindByG_U(long groupId, long userId) { 1539 return getPersistence().filterFindByG_U(groupId, userId); 1540 } 1541 1542 /** 1543 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1544 * 1545 * <p> 1546 * 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. 1547 * </p> 1548 * 1549 * @param groupId the group ID 1550 * @param userId the user ID 1551 * @param start the lower bound of the range of document library file entries 1552 * @param end the upper bound of the range of document library file entries (not inclusive) 1553 * @return the range of matching document library file entries that the user has permission to view 1554 */ 1555 public static List<DLFileEntry> filterFindByG_U(long groupId, long userId, 1556 int start, int end) { 1557 return getPersistence().filterFindByG_U(groupId, userId, start, end); 1558 } 1559 1560 /** 1561 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ?. 1562 * 1563 * <p> 1564 * 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. 1565 * </p> 1566 * 1567 * @param groupId the group ID 1568 * @param userId the user ID 1569 * @param start the lower bound of the range of document library file entries 1570 * @param end the upper bound of the range of document library file entries (not inclusive) 1571 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1572 * @return the ordered range of matching document library file entries that the user has permission to view 1573 */ 1574 public static List<DLFileEntry> filterFindByG_U(long groupId, long userId, 1575 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 1576 return getPersistence() 1577 .filterFindByG_U(groupId, userId, start, end, 1578 orderByComparator); 1579 } 1580 1581 /** 1582 * 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 = ?. 1583 * 1584 * @param fileEntryId the primary key of the current document library file entry 1585 * @param groupId the group ID 1586 * @param userId the user ID 1587 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1588 * @return the previous, current, and next document library file entry 1589 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1590 */ 1591 public static DLFileEntry[] filterFindByG_U_PrevAndNext(long fileEntryId, 1592 long groupId, long userId, 1593 OrderByComparator<DLFileEntry> orderByComparator) 1594 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1595 return getPersistence() 1596 .filterFindByG_U_PrevAndNext(fileEntryId, groupId, userId, 1597 orderByComparator); 1598 } 1599 1600 /** 1601 * Removes all the document library file entries where groupId = ? and userId = ? from the database. 1602 * 1603 * @param groupId the group ID 1604 * @param userId the user ID 1605 */ 1606 public static void removeByG_U(long groupId, long userId) { 1607 getPersistence().removeByG_U(groupId, userId); 1608 } 1609 1610 /** 1611 * Returns the number of document library file entries where groupId = ? and userId = ?. 1612 * 1613 * @param groupId the group ID 1614 * @param userId the user ID 1615 * @return the number of matching document library file entries 1616 */ 1617 public static int countByG_U(long groupId, long userId) { 1618 return getPersistence().countByG_U(groupId, userId); 1619 } 1620 1621 /** 1622 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ?. 1623 * 1624 * @param groupId the group ID 1625 * @param userId the user ID 1626 * @return the number of matching document library file entries that the user has permission to view 1627 */ 1628 public static int filterCountByG_U(long groupId, long userId) { 1629 return getPersistence().filterCountByG_U(groupId, userId); 1630 } 1631 1632 /** 1633 * Returns all the document library file entries where groupId = ? and folderId = ?. 1634 * 1635 * @param groupId the group ID 1636 * @param folderId the folder ID 1637 * @return the matching document library file entries 1638 */ 1639 public static List<DLFileEntry> findByG_F(long groupId, long folderId) { 1640 return getPersistence().findByG_F(groupId, folderId); 1641 } 1642 1643 /** 1644 * Returns a range of all the document library file entries where groupId = ? and folderId = ?. 1645 * 1646 * <p> 1647 * 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. 1648 * </p> 1649 * 1650 * @param groupId the group ID 1651 * @param folderId the folder ID 1652 * @param start the lower bound of the range of document library file entries 1653 * @param end the upper bound of the range of document library file entries (not inclusive) 1654 * @return the range of matching document library file entries 1655 */ 1656 public static List<DLFileEntry> findByG_F(long groupId, long folderId, 1657 int start, int end) { 1658 return getPersistence().findByG_F(groupId, folderId, start, end); 1659 } 1660 1661 /** 1662 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?. 1663 * 1664 * <p> 1665 * 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. 1666 * </p> 1667 * 1668 * @param groupId the group ID 1669 * @param folderId the folder ID 1670 * @param start the lower bound of the range of document library file entries 1671 * @param end the upper bound of the range of document library file entries (not inclusive) 1672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1673 * @return the ordered range of matching document library file entries 1674 */ 1675 public static List<DLFileEntry> findByG_F(long groupId, long folderId, 1676 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 1677 return getPersistence() 1678 .findByG_F(groupId, folderId, start, end, orderByComparator); 1679 } 1680 1681 /** 1682 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?. 1683 * 1684 * <p> 1685 * 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. 1686 * </p> 1687 * 1688 * @param groupId the group ID 1689 * @param folderId the folder ID 1690 * @param start the lower bound of the range of document library file entries 1691 * @param end the upper bound of the range of document library file entries (not inclusive) 1692 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1693 * @param retrieveFromCache whether to retrieve from the finder cache 1694 * @return the ordered range of matching document library file entries 1695 */ 1696 public static List<DLFileEntry> findByG_F(long groupId, long folderId, 1697 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 1698 boolean retrieveFromCache) { 1699 return getPersistence() 1700 .findByG_F(groupId, folderId, start, end, orderByComparator, 1701 retrieveFromCache); 1702 } 1703 1704 /** 1705 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1706 * 1707 * @param groupId the group ID 1708 * @param folderId the folder ID 1709 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1710 * @return the first matching document library file entry 1711 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1712 */ 1713 public static DLFileEntry findByG_F_First(long groupId, long folderId, 1714 OrderByComparator<DLFileEntry> orderByComparator) 1715 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1716 return getPersistence() 1717 .findByG_F_First(groupId, folderId, orderByComparator); 1718 } 1719 1720 /** 1721 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1722 * 1723 * @param groupId the group ID 1724 * @param folderId the folder ID 1725 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1726 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1727 */ 1728 public static DLFileEntry fetchByG_F_First(long groupId, long folderId, 1729 OrderByComparator<DLFileEntry> orderByComparator) { 1730 return getPersistence() 1731 .fetchByG_F_First(groupId, folderId, orderByComparator); 1732 } 1733 1734 /** 1735 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1736 * 1737 * @param groupId the group 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 static DLFileEntry findByG_F_Last(long groupId, long folderId, 1744 OrderByComparator<DLFileEntry> orderByComparator) 1745 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1746 return getPersistence() 1747 .findByG_F_Last(groupId, folderId, orderByComparator); 1748 } 1749 1750 /** 1751 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1752 * 1753 * @param groupId the group ID 1754 * @param folderId the folder ID 1755 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1756 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1757 */ 1758 public static DLFileEntry fetchByG_F_Last(long groupId, long folderId, 1759 OrderByComparator<DLFileEntry> orderByComparator) { 1760 return getPersistence() 1761 .fetchByG_F_Last(groupId, folderId, orderByComparator); 1762 } 1763 1764 /** 1765 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and folderId = ?. 1766 * 1767 * @param fileEntryId the primary key of the current document library file entry 1768 * @param groupId the group ID 1769 * @param folderId the folder ID 1770 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1771 * @return the previous, current, and next document library file entry 1772 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1773 */ 1774 public static DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId, 1775 long groupId, long folderId, 1776 OrderByComparator<DLFileEntry> orderByComparator) 1777 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1778 return getPersistence() 1779 .findByG_F_PrevAndNext(fileEntryId, groupId, folderId, 1780 orderByComparator); 1781 } 1782 1783 /** 1784 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1785 * 1786 * @param groupId the group ID 1787 * @param folderId the folder ID 1788 * @return the matching document library file entries that the user has permission to view 1789 */ 1790 public static List<DLFileEntry> filterFindByG_F(long groupId, long folderId) { 1791 return getPersistence().filterFindByG_F(groupId, folderId); 1792 } 1793 1794 /** 1795 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1796 * 1797 * <p> 1798 * 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. 1799 * </p> 1800 * 1801 * @param groupId the group ID 1802 * @param folderId the folder ID 1803 * @param start the lower bound of the range of document library file entries 1804 * @param end the upper bound of the range of document library file entries (not inclusive) 1805 * @return the range of matching document library file entries that the user has permission to view 1806 */ 1807 public static List<DLFileEntry> filterFindByG_F(long groupId, 1808 long folderId, int start, int end) { 1809 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 1810 } 1811 1812 /** 1813 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ?. 1814 * 1815 * <p> 1816 * 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. 1817 * </p> 1818 * 1819 * @param groupId the group ID 1820 * @param folderId the folder ID 1821 * @param start the lower bound of the range of document library file entries 1822 * @param end the upper bound of the range of document library file entries (not inclusive) 1823 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1824 * @return the ordered range of matching document library file entries that the user has permission to view 1825 */ 1826 public static List<DLFileEntry> filterFindByG_F(long groupId, 1827 long folderId, int start, int end, 1828 OrderByComparator<DLFileEntry> orderByComparator) { 1829 return getPersistence() 1830 .filterFindByG_F(groupId, folderId, start, end, 1831 orderByComparator); 1832 } 1833 1834 /** 1835 * 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 = ?. 1836 * 1837 * @param fileEntryId the primary key of the current document library file entry 1838 * @param groupId the group ID 1839 * @param folderId the folder ID 1840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1841 * @return the previous, current, and next document library file entry 1842 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1843 */ 1844 public static DLFileEntry[] filterFindByG_F_PrevAndNext(long fileEntryId, 1845 long groupId, long folderId, 1846 OrderByComparator<DLFileEntry> orderByComparator) 1847 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 1848 return getPersistence() 1849 .filterFindByG_F_PrevAndNext(fileEntryId, groupId, folderId, 1850 orderByComparator); 1851 } 1852 1853 /** 1854 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1855 * 1856 * @param groupId the group ID 1857 * @param folderIds the folder IDs 1858 * @return the matching document library file entries that the user has permission to view 1859 */ 1860 public static List<DLFileEntry> filterFindByG_F(long groupId, 1861 long[] folderIds) { 1862 return getPersistence().filterFindByG_F(groupId, folderIds); 1863 } 1864 1865 /** 1866 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1867 * 1868 * <p> 1869 * 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. 1870 * </p> 1871 * 1872 * @param groupId the group ID 1873 * @param folderIds the folder IDs 1874 * @param start the lower bound of the range of document library file entries 1875 * @param end the upper bound of the range of document library file entries (not inclusive) 1876 * @return the range of matching document library file entries that the user has permission to view 1877 */ 1878 public static List<DLFileEntry> filterFindByG_F(long groupId, 1879 long[] folderIds, int start, int end) { 1880 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 1881 } 1882 1883 /** 1884 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1885 * 1886 * <p> 1887 * 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. 1888 * </p> 1889 * 1890 * @param groupId the group ID 1891 * @param folderIds the folder IDs 1892 * @param start the lower bound of the range of document library file entries 1893 * @param end the upper bound of the range of document library file entries (not inclusive) 1894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1895 * @return the ordered range of matching document library file entries that the user has permission to view 1896 */ 1897 public static List<DLFileEntry> filterFindByG_F(long groupId, 1898 long[] folderIds, int start, int end, 1899 OrderByComparator<DLFileEntry> orderByComparator) { 1900 return getPersistence() 1901 .filterFindByG_F(groupId, folderIds, start, end, 1902 orderByComparator); 1903 } 1904 1905 /** 1906 * Returns all the document library file entries where groupId = ? and folderId = any ?. 1907 * 1908 * <p> 1909 * 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. 1910 * </p> 1911 * 1912 * @param groupId the group ID 1913 * @param folderIds the folder IDs 1914 * @return the matching document library file entries 1915 */ 1916 public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds) { 1917 return getPersistence().findByG_F(groupId, folderIds); 1918 } 1919 1920 /** 1921 * Returns a range of all the document library file entries where groupId = ? and folderId = any ?. 1922 * 1923 * <p> 1924 * 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. 1925 * </p> 1926 * 1927 * @param groupId the group ID 1928 * @param folderIds the folder IDs 1929 * @param start the lower bound of the range of document library file entries 1930 * @param end the upper bound of the range of document library file entries (not inclusive) 1931 * @return the range of matching document library file entries 1932 */ 1933 public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds, 1934 int start, int end) { 1935 return getPersistence().findByG_F(groupId, folderIds, start, end); 1936 } 1937 1938 /** 1939 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ?. 1940 * 1941 * <p> 1942 * 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. 1943 * </p> 1944 * 1945 * @param groupId the group ID 1946 * @param folderIds the folder IDs 1947 * @param start the lower bound of the range of document library file entries 1948 * @param end the upper bound of the range of document library file entries (not inclusive) 1949 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1950 * @return the ordered range of matching document library file entries 1951 */ 1952 public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds, 1953 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 1954 return getPersistence() 1955 .findByG_F(groupId, folderIds, start, end, orderByComparator); 1956 } 1957 1958 /** 1959 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?, optionally using the finder cache. 1960 * 1961 * <p> 1962 * 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. 1963 * </p> 1964 * 1965 * @param groupId the group ID 1966 * @param folderId the folder ID 1967 * @param start the lower bound of the range of document library file entries 1968 * @param end the upper bound of the range of document library file entries (not inclusive) 1969 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1970 * @param retrieveFromCache whether to retrieve from the finder cache 1971 * @return the ordered range of matching document library file entries 1972 */ 1973 public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds, 1974 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 1975 boolean retrieveFromCache) { 1976 return getPersistence() 1977 .findByG_F(groupId, folderIds, start, end, 1978 orderByComparator, retrieveFromCache); 1979 } 1980 1981 /** 1982 * Removes all the document library file entries where groupId = ? and folderId = ? from the database. 1983 * 1984 * @param groupId the group ID 1985 * @param folderId the folder ID 1986 */ 1987 public static void removeByG_F(long groupId, long folderId) { 1988 getPersistence().removeByG_F(groupId, folderId); 1989 } 1990 1991 /** 1992 * Returns the number of document library file entries where groupId = ? and folderId = ?. 1993 * 1994 * @param groupId the group ID 1995 * @param folderId the folder ID 1996 * @return the number of matching document library file entries 1997 */ 1998 public static int countByG_F(long groupId, long folderId) { 1999 return getPersistence().countByG_F(groupId, folderId); 2000 } 2001 2002 /** 2003 * Returns the number of document library file entries where groupId = ? and folderId = any ?. 2004 * 2005 * @param groupId the group ID 2006 * @param folderIds the folder IDs 2007 * @return the number of matching document library file entries 2008 */ 2009 public static int countByG_F(long groupId, long[] folderIds) { 2010 return getPersistence().countByG_F(groupId, folderIds); 2011 } 2012 2013 /** 2014 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ?. 2015 * 2016 * @param groupId the group ID 2017 * @param folderId the folder ID 2018 * @return the number of matching document library file entries that the user has permission to view 2019 */ 2020 public static int filterCountByG_F(long groupId, long folderId) { 2021 return getPersistence().filterCountByG_F(groupId, folderId); 2022 } 2023 2024 /** 2025 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 2026 * 2027 * @param groupId the group ID 2028 * @param folderIds the folder IDs 2029 * @return the number of matching document library file entries that the user has permission to view 2030 */ 2031 public static int filterCountByG_F(long groupId, long[] folderIds) { 2032 return getPersistence().filterCountByG_F(groupId, folderIds); 2033 } 2034 2035 /** 2036 * Returns all the document library file entries where repositoryId = ? and folderId = ?. 2037 * 2038 * @param repositoryId the repository ID 2039 * @param folderId the folder ID 2040 * @return the matching document library file entries 2041 */ 2042 public static List<DLFileEntry> findByR_F(long repositoryId, long folderId) { 2043 return getPersistence().findByR_F(repositoryId, folderId); 2044 } 2045 2046 /** 2047 * Returns a range of all the document library file entries where repositoryId = ? and folderId = ?. 2048 * 2049 * <p> 2050 * 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. 2051 * </p> 2052 * 2053 * @param repositoryId the repository ID 2054 * @param folderId the folder ID 2055 * @param start the lower bound of the range of document library file entries 2056 * @param end the upper bound of the range of document library file entries (not inclusive) 2057 * @return the range of matching document library file entries 2058 */ 2059 public static List<DLFileEntry> findByR_F(long repositoryId, long folderId, 2060 int start, int end) { 2061 return getPersistence().findByR_F(repositoryId, folderId, start, end); 2062 } 2063 2064 /** 2065 * Returns an ordered range of all the document library file entries where repositoryId = ? and folderId = ?. 2066 * 2067 * <p> 2068 * 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. 2069 * </p> 2070 * 2071 * @param repositoryId the repository ID 2072 * @param folderId the folder ID 2073 * @param start the lower bound of the range of document library file entries 2074 * @param end the upper bound of the range of document library file entries (not inclusive) 2075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2076 * @return the ordered range of matching document library file entries 2077 */ 2078 public static List<DLFileEntry> findByR_F(long repositoryId, long folderId, 2079 int start, int end, OrderByComparator<DLFileEntry> orderByComparator) { 2080 return getPersistence() 2081 .findByR_F(repositoryId, folderId, start, end, 2082 orderByComparator); 2083 } 2084 2085 /** 2086 * Returns an ordered range of all the document library file entries where repositoryId = ? 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 repositoryId the repository ID 2093 * @param folderId the folder ID 2094 * @param start the lower bound of the range of document library file entries 2095 * @param end the upper bound of the range of document library file entries (not inclusive) 2096 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2097 * @param retrieveFromCache whether to retrieve from the finder cache 2098 * @return the ordered range of matching document library file entries 2099 */ 2100 public static List<DLFileEntry> findByR_F(long repositoryId, long folderId, 2101 int start, int end, OrderByComparator<DLFileEntry> orderByComparator, 2102 boolean retrieveFromCache) { 2103 return getPersistence() 2104 .findByR_F(repositoryId, folderId, start, end, 2105 orderByComparator, retrieveFromCache); 2106 } 2107 2108 /** 2109 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 2110 * 2111 * @param repositoryId the repository ID 2112 * @param folderId the folder ID 2113 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2114 * @return the first matching document library file entry 2115 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2116 */ 2117 public static DLFileEntry findByR_F_First(long repositoryId, long folderId, 2118 OrderByComparator<DLFileEntry> orderByComparator) 2119 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2120 return getPersistence() 2121 .findByR_F_First(repositoryId, folderId, orderByComparator); 2122 } 2123 2124 /** 2125 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 2126 * 2127 * @param repositoryId the repository ID 2128 * @param folderId the folder ID 2129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2130 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2131 */ 2132 public static DLFileEntry fetchByR_F_First(long repositoryId, 2133 long folderId, OrderByComparator<DLFileEntry> orderByComparator) { 2134 return getPersistence() 2135 .fetchByR_F_First(repositoryId, folderId, orderByComparator); 2136 } 2137 2138 /** 2139 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 2140 * 2141 * @param repositoryId the repository ID 2142 * @param folderId the folder ID 2143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2144 * @return the last matching document library file entry 2145 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2146 */ 2147 public static DLFileEntry findByR_F_Last(long repositoryId, long folderId, 2148 OrderByComparator<DLFileEntry> orderByComparator) 2149 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2150 return getPersistence() 2151 .findByR_F_Last(repositoryId, folderId, orderByComparator); 2152 } 2153 2154 /** 2155 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 2156 * 2157 * @param repositoryId the repository ID 2158 * @param folderId the folder ID 2159 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2160 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2161 */ 2162 public static DLFileEntry fetchByR_F_Last(long repositoryId, long folderId, 2163 OrderByComparator<DLFileEntry> orderByComparator) { 2164 return getPersistence() 2165 .fetchByR_F_Last(repositoryId, folderId, orderByComparator); 2166 } 2167 2168 /** 2169 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ? and folderId = ?. 2170 * 2171 * @param fileEntryId the primary key of the current document library file entry 2172 * @param repositoryId the repository ID 2173 * @param folderId the folder ID 2174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2175 * @return the previous, current, and next document library file entry 2176 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2177 */ 2178 public static DLFileEntry[] findByR_F_PrevAndNext(long fileEntryId, 2179 long repositoryId, long folderId, 2180 OrderByComparator<DLFileEntry> orderByComparator) 2181 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2182 return getPersistence() 2183 .findByR_F_PrevAndNext(fileEntryId, repositoryId, folderId, 2184 orderByComparator); 2185 } 2186 2187 /** 2188 * Removes all the document library file entries where repositoryId = ? and folderId = ? from the database. 2189 * 2190 * @param repositoryId the repository ID 2191 * @param folderId the folder ID 2192 */ 2193 public static void removeByR_F(long repositoryId, long folderId) { 2194 getPersistence().removeByR_F(repositoryId, folderId); 2195 } 2196 2197 /** 2198 * Returns the number of document library file entries where repositoryId = ? and folderId = ?. 2199 * 2200 * @param repositoryId the repository ID 2201 * @param folderId the folder ID 2202 * @return the number of matching document library file entries 2203 */ 2204 public static int countByR_F(long repositoryId, long folderId) { 2205 return getPersistence().countByR_F(repositoryId, folderId); 2206 } 2207 2208 /** 2209 * Returns all the document library file entries where folderId = ? and name = ?. 2210 * 2211 * @param folderId the folder ID 2212 * @param name the name 2213 * @return the matching document library file entries 2214 */ 2215 public static List<DLFileEntry> findByF_N(long folderId, 2216 java.lang.String name) { 2217 return getPersistence().findByF_N(folderId, name); 2218 } 2219 2220 /** 2221 * Returns a range of all the document library file entries where folderId = ? and name = ?. 2222 * 2223 * <p> 2224 * 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. 2225 * </p> 2226 * 2227 * @param folderId the folder ID 2228 * @param name the name 2229 * @param start the lower bound of the range of document library file entries 2230 * @param end the upper bound of the range of document library file entries (not inclusive) 2231 * @return the range of matching document library file entries 2232 */ 2233 public static List<DLFileEntry> findByF_N(long folderId, 2234 java.lang.String name, int start, int end) { 2235 return getPersistence().findByF_N(folderId, name, start, end); 2236 } 2237 2238 /** 2239 * Returns an ordered range of all the document library file entries where folderId = ? and name = ?. 2240 * 2241 * <p> 2242 * 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. 2243 * </p> 2244 * 2245 * @param folderId the folder ID 2246 * @param name the name 2247 * @param start the lower bound of the range of document library file entries 2248 * @param end the upper bound of the range of document library file entries (not inclusive) 2249 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2250 * @return the ordered range of matching document library file entries 2251 */ 2252 public static List<DLFileEntry> findByF_N(long folderId, 2253 java.lang.String name, int start, int end, 2254 OrderByComparator<DLFileEntry> orderByComparator) { 2255 return getPersistence() 2256 .findByF_N(folderId, name, start, end, orderByComparator); 2257 } 2258 2259 /** 2260 * Returns an ordered range of all the document library file entries where folderId = ? and name = ?. 2261 * 2262 * <p> 2263 * 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. 2264 * </p> 2265 * 2266 * @param folderId the folder ID 2267 * @param name the name 2268 * @param start the lower bound of the range of document library file entries 2269 * @param end the upper bound of the range of document library file entries (not inclusive) 2270 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2271 * @param retrieveFromCache whether to retrieve from the finder cache 2272 * @return the ordered range of matching document library file entries 2273 */ 2274 public static List<DLFileEntry> findByF_N(long folderId, 2275 java.lang.String name, int start, int end, 2276 OrderByComparator<DLFileEntry> orderByComparator, 2277 boolean retrieveFromCache) { 2278 return getPersistence() 2279 .findByF_N(folderId, name, start, end, orderByComparator, 2280 retrieveFromCache); 2281 } 2282 2283 /** 2284 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 2285 * 2286 * @param folderId the folder ID 2287 * @param name the name 2288 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2289 * @return the first matching document library file entry 2290 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2291 */ 2292 public static DLFileEntry findByF_N_First(long folderId, 2293 java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) 2294 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2295 return getPersistence() 2296 .findByF_N_First(folderId, name, orderByComparator); 2297 } 2298 2299 /** 2300 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 2301 * 2302 * @param folderId the folder ID 2303 * @param name the name 2304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2305 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2306 */ 2307 public static DLFileEntry fetchByF_N_First(long folderId, 2308 java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) { 2309 return getPersistence() 2310 .fetchByF_N_First(folderId, name, orderByComparator); 2311 } 2312 2313 /** 2314 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 2315 * 2316 * @param folderId the folder ID 2317 * @param name the name 2318 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2319 * @return the last matching document library file entry 2320 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2321 */ 2322 public static DLFileEntry findByF_N_Last(long folderId, 2323 java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) 2324 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2325 return getPersistence().findByF_N_Last(folderId, name, orderByComparator); 2326 } 2327 2328 /** 2329 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 2330 * 2331 * @param folderId the folder ID 2332 * @param name the name 2333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2334 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2335 */ 2336 public static DLFileEntry fetchByF_N_Last(long folderId, 2337 java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) { 2338 return getPersistence() 2339 .fetchByF_N_Last(folderId, name, orderByComparator); 2340 } 2341 2342 /** 2343 * Returns the document library file entries before and after the current document library file entry in the ordered set where folderId = ? and name = ?. 2344 * 2345 * @param fileEntryId the primary key of the current document library file entry 2346 * @param folderId the folder ID 2347 * @param name the name 2348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2349 * @return the previous, current, and next document library file entry 2350 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2351 */ 2352 public static DLFileEntry[] findByF_N_PrevAndNext(long fileEntryId, 2353 long folderId, java.lang.String name, 2354 OrderByComparator<DLFileEntry> orderByComparator) 2355 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2356 return getPersistence() 2357 .findByF_N_PrevAndNext(fileEntryId, folderId, name, 2358 orderByComparator); 2359 } 2360 2361 /** 2362 * Removes all the document library file entries where folderId = ? and name = ? from the database. 2363 * 2364 * @param folderId the folder ID 2365 * @param name the name 2366 */ 2367 public static void removeByF_N(long folderId, java.lang.String name) { 2368 getPersistence().removeByF_N(folderId, name); 2369 } 2370 2371 /** 2372 * Returns the number of document library file entries where folderId = ? and name = ?. 2373 * 2374 * @param folderId the folder ID 2375 * @param name the name 2376 * @return the number of matching document library file entries 2377 */ 2378 public static int countByF_N(long folderId, java.lang.String name) { 2379 return getPersistence().countByF_N(folderId, name); 2380 } 2381 2382 /** 2383 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = ?. 2384 * 2385 * @param groupId the group ID 2386 * @param userId the user ID 2387 * @param folderId the folder ID 2388 * @return the matching document library file entries 2389 */ 2390 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2391 long folderId) { 2392 return getPersistence().findByG_U_F(groupId, userId, folderId); 2393 } 2394 2395 /** 2396 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 2397 * 2398 * <p> 2399 * 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. 2400 * </p> 2401 * 2402 * @param groupId the group ID 2403 * @param userId the user ID 2404 * @param folderId the folder ID 2405 * @param start the lower bound of the range of document library file entries 2406 * @param end the upper bound of the range of document library file entries (not inclusive) 2407 * @return the range of matching document library file entries 2408 */ 2409 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2410 long folderId, int start, int end) { 2411 return getPersistence() 2412 .findByG_U_F(groupId, userId, folderId, start, end); 2413 } 2414 2415 /** 2416 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 2417 * 2418 * <p> 2419 * 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. 2420 * </p> 2421 * 2422 * @param groupId the group ID 2423 * @param userId the user ID 2424 * @param folderId the folder ID 2425 * @param start the lower bound of the range of document library file entries 2426 * @param end the upper bound of the range of document library file entries (not inclusive) 2427 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2428 * @return the ordered range of matching document library file entries 2429 */ 2430 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2431 long folderId, int start, int end, 2432 OrderByComparator<DLFileEntry> orderByComparator) { 2433 return getPersistence() 2434 .findByG_U_F(groupId, userId, folderId, start, end, 2435 orderByComparator); 2436 } 2437 2438 /** 2439 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 2440 * 2441 * <p> 2442 * 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. 2443 * </p> 2444 * 2445 * @param groupId the group ID 2446 * @param userId the user ID 2447 * @param folderId the folder ID 2448 * @param start the lower bound of the range of document library file entries 2449 * @param end the upper bound of the range of document library file entries (not inclusive) 2450 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2451 * @param retrieveFromCache whether to retrieve from the finder cache 2452 * @return the ordered range of matching document library file entries 2453 */ 2454 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2455 long folderId, int start, int end, 2456 OrderByComparator<DLFileEntry> orderByComparator, 2457 boolean retrieveFromCache) { 2458 return getPersistence() 2459 .findByG_U_F(groupId, userId, folderId, start, end, 2460 orderByComparator, retrieveFromCache); 2461 } 2462 2463 /** 2464 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2465 * 2466 * @param groupId the group ID 2467 * @param userId the user ID 2468 * @param folderId the folder ID 2469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2470 * @return the first matching document library file entry 2471 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2472 */ 2473 public static DLFileEntry findByG_U_F_First(long groupId, long userId, 2474 long folderId, OrderByComparator<DLFileEntry> orderByComparator) 2475 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2476 return getPersistence() 2477 .findByG_U_F_First(groupId, userId, folderId, 2478 orderByComparator); 2479 } 2480 2481 /** 2482 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2483 * 2484 * @param groupId the group ID 2485 * @param userId the user ID 2486 * @param folderId the folder ID 2487 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2488 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2489 */ 2490 public static DLFileEntry fetchByG_U_F_First(long groupId, long userId, 2491 long folderId, OrderByComparator<DLFileEntry> orderByComparator) { 2492 return getPersistence() 2493 .fetchByG_U_F_First(groupId, userId, folderId, 2494 orderByComparator); 2495 } 2496 2497 /** 2498 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2499 * 2500 * @param groupId the group ID 2501 * @param userId the user ID 2502 * @param folderId the folder ID 2503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2504 * @return the last matching document library file entry 2505 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2506 */ 2507 public static DLFileEntry findByG_U_F_Last(long groupId, long userId, 2508 long folderId, OrderByComparator<DLFileEntry> orderByComparator) 2509 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2510 return getPersistence() 2511 .findByG_U_F_Last(groupId, userId, folderId, 2512 orderByComparator); 2513 } 2514 2515 /** 2516 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 2517 * 2518 * @param groupId the group ID 2519 * @param userId the user ID 2520 * @param folderId the folder ID 2521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2522 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2523 */ 2524 public static DLFileEntry fetchByG_U_F_Last(long groupId, long userId, 2525 long folderId, OrderByComparator<DLFileEntry> orderByComparator) { 2526 return getPersistence() 2527 .fetchByG_U_F_Last(groupId, userId, folderId, 2528 orderByComparator); 2529 } 2530 2531 /** 2532 * 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 = ?. 2533 * 2534 * @param fileEntryId the primary key of the current document library file entry 2535 * @param groupId the group ID 2536 * @param userId the user ID 2537 * @param folderId the folder ID 2538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2539 * @return the previous, current, and next document library file entry 2540 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2541 */ 2542 public static DLFileEntry[] findByG_U_F_PrevAndNext(long fileEntryId, 2543 long groupId, long userId, long folderId, 2544 OrderByComparator<DLFileEntry> orderByComparator) 2545 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2546 return getPersistence() 2547 .findByG_U_F_PrevAndNext(fileEntryId, groupId, userId, 2548 folderId, orderByComparator); 2549 } 2550 2551 /** 2552 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2553 * 2554 * @param groupId the group ID 2555 * @param userId the user ID 2556 * @param folderId the folder ID 2557 * @return the matching document library file entries that the user has permission to view 2558 */ 2559 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2560 long userId, long folderId) { 2561 return getPersistence().filterFindByG_U_F(groupId, userId, folderId); 2562 } 2563 2564 /** 2565 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2566 * 2567 * <p> 2568 * 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. 2569 * </p> 2570 * 2571 * @param groupId the group ID 2572 * @param userId the user ID 2573 * @param folderId the folder ID 2574 * @param start the lower bound of the range of document library file entries 2575 * @param end the upper bound of the range of document library file entries (not inclusive) 2576 * @return the range of matching document library file entries that the user has permission to view 2577 */ 2578 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2579 long userId, long folderId, int start, int end) { 2580 return getPersistence() 2581 .filterFindByG_U_F(groupId, userId, folderId, start, end); 2582 } 2583 2584 /** 2585 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ?. 2586 * 2587 * <p> 2588 * 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. 2589 * </p> 2590 * 2591 * @param groupId the group ID 2592 * @param userId the user ID 2593 * @param folderId the folder ID 2594 * @param start the lower bound of the range of document library file entries 2595 * @param end the upper bound of the range of document library file entries (not inclusive) 2596 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2597 * @return the ordered range of matching document library file entries that the user has permission to view 2598 */ 2599 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2600 long userId, long folderId, int start, int end, 2601 OrderByComparator<DLFileEntry> orderByComparator) { 2602 return getPersistence() 2603 .filterFindByG_U_F(groupId, userId, folderId, start, end, 2604 orderByComparator); 2605 } 2606 2607 /** 2608 * 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 = ?. 2609 * 2610 * @param fileEntryId the primary key of the current document library file entry 2611 * @param groupId the group ID 2612 * @param userId the user ID 2613 * @param folderId the folder ID 2614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2615 * @return the previous, current, and next document library file entry 2616 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2617 */ 2618 public static DLFileEntry[] filterFindByG_U_F_PrevAndNext( 2619 long fileEntryId, long groupId, long userId, long folderId, 2620 OrderByComparator<DLFileEntry> orderByComparator) 2621 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2622 return getPersistence() 2623 .filterFindByG_U_F_PrevAndNext(fileEntryId, groupId, userId, 2624 folderId, orderByComparator); 2625 } 2626 2627 /** 2628 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2629 * 2630 * @param groupId the group ID 2631 * @param userId the user ID 2632 * @param folderIds the folder IDs 2633 * @return the matching document library file entries that the user has permission to view 2634 */ 2635 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2636 long userId, long[] folderIds) { 2637 return getPersistence().filterFindByG_U_F(groupId, userId, folderIds); 2638 } 2639 2640 /** 2641 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2642 * 2643 * <p> 2644 * 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. 2645 * </p> 2646 * 2647 * @param groupId the group ID 2648 * @param userId the user ID 2649 * @param folderIds the folder IDs 2650 * @param start the lower bound of the range of document library file entries 2651 * @param end the upper bound of the range of document library file entries (not inclusive) 2652 * @return the range of matching document library file entries that the user has permission to view 2653 */ 2654 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2655 long userId, long[] folderIds, int start, int end) { 2656 return getPersistence() 2657 .filterFindByG_U_F(groupId, userId, folderIds, start, end); 2658 } 2659 2660 /** 2661 * 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 ?. 2662 * 2663 * <p> 2664 * 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. 2665 * </p> 2666 * 2667 * @param groupId the group ID 2668 * @param userId the user ID 2669 * @param folderIds the folder IDs 2670 * @param start the lower bound of the range of document library file entries 2671 * @param end the upper bound of the range of document library file entries (not inclusive) 2672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2673 * @return the ordered range of matching document library file entries that the user has permission to view 2674 */ 2675 public static List<DLFileEntry> filterFindByG_U_F(long groupId, 2676 long userId, long[] folderIds, int start, int end, 2677 OrderByComparator<DLFileEntry> orderByComparator) { 2678 return getPersistence() 2679 .filterFindByG_U_F(groupId, userId, folderIds, start, end, 2680 orderByComparator); 2681 } 2682 2683 /** 2684 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2685 * 2686 * <p> 2687 * 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. 2688 * </p> 2689 * 2690 * @param groupId the group ID 2691 * @param userId the user ID 2692 * @param folderIds the folder IDs 2693 * @return the matching document library file entries 2694 */ 2695 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2696 long[] folderIds) { 2697 return getPersistence().findByG_U_F(groupId, userId, folderIds); 2698 } 2699 2700 /** 2701 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2702 * 2703 * <p> 2704 * 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. 2705 * </p> 2706 * 2707 * @param groupId the group ID 2708 * @param userId the user ID 2709 * @param folderIds the folder IDs 2710 * @param start the lower bound of the range of document library file entries 2711 * @param end the upper bound of the range of document library file entries (not inclusive) 2712 * @return the range of matching document library file entries 2713 */ 2714 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2715 long[] folderIds, int start, int end) { 2716 return getPersistence() 2717 .findByG_U_F(groupId, userId, folderIds, start, end); 2718 } 2719 2720 /** 2721 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 2722 * 2723 * <p> 2724 * 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. 2725 * </p> 2726 * 2727 * @param groupId the group ID 2728 * @param userId the user ID 2729 * @param folderIds the folder IDs 2730 * @param start the lower bound of the range of document library file entries 2731 * @param end the upper bound of the range of document library file entries (not inclusive) 2732 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2733 * @return the ordered range of matching document library file entries 2734 */ 2735 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2736 long[] folderIds, int start, int end, 2737 OrderByComparator<DLFileEntry> orderByComparator) { 2738 return getPersistence() 2739 .findByG_U_F(groupId, userId, folderIds, start, end, 2740 orderByComparator); 2741 } 2742 2743 /** 2744 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?, optionally using the finder cache. 2745 * 2746 * <p> 2747 * 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. 2748 * </p> 2749 * 2750 * @param groupId the group ID 2751 * @param userId the user ID 2752 * @param folderId the folder ID 2753 * @param start the lower bound of the range of document library file entries 2754 * @param end the upper bound of the range of document library file entries (not inclusive) 2755 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2756 * @param retrieveFromCache whether to retrieve from the finder cache 2757 * @return the ordered range of matching document library file entries 2758 */ 2759 public static List<DLFileEntry> findByG_U_F(long groupId, long userId, 2760 long[] folderIds, int start, int end, 2761 OrderByComparator<DLFileEntry> orderByComparator, 2762 boolean retrieveFromCache) { 2763 return getPersistence() 2764 .findByG_U_F(groupId, userId, folderIds, start, end, 2765 orderByComparator, retrieveFromCache); 2766 } 2767 2768 /** 2769 * Removes all the document library file entries where groupId = ? and userId = ? and folderId = ? from the database. 2770 * 2771 * @param groupId the group ID 2772 * @param userId the user ID 2773 * @param folderId the folder ID 2774 */ 2775 public static void removeByG_U_F(long groupId, long userId, long folderId) { 2776 getPersistence().removeByG_U_F(groupId, userId, folderId); 2777 } 2778 2779 /** 2780 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = ?. 2781 * 2782 * @param groupId the group ID 2783 * @param userId the user ID 2784 * @param folderId the folder ID 2785 * @return the number of matching document library file entries 2786 */ 2787 public static int countByG_U_F(long groupId, long userId, long folderId) { 2788 return getPersistence().countByG_U_F(groupId, userId, folderId); 2789 } 2790 2791 /** 2792 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = any ?. 2793 * 2794 * @param groupId the group ID 2795 * @param userId the user ID 2796 * @param folderIds the folder IDs 2797 * @return the number of matching document library file entries 2798 */ 2799 public static int countByG_U_F(long groupId, long userId, long[] folderIds) { 2800 return getPersistence().countByG_U_F(groupId, userId, folderIds); 2801 } 2802 2803 /** 2804 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2805 * 2806 * @param groupId the group ID 2807 * @param userId the user ID 2808 * @param folderId the folder ID 2809 * @return the number of matching document library file entries that the user has permission to view 2810 */ 2811 public static int filterCountByG_U_F(long groupId, long userId, 2812 long folderId) { 2813 return getPersistence().filterCountByG_U_F(groupId, userId, folderId); 2814 } 2815 2816 /** 2817 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2818 * 2819 * @param groupId the group ID 2820 * @param userId the user ID 2821 * @param folderIds the folder IDs 2822 * @return the number of matching document library file entries that the user has permission to view 2823 */ 2824 public static int filterCountByG_U_F(long groupId, long userId, 2825 long[] folderIds) { 2826 return getPersistence().filterCountByG_U_F(groupId, userId, folderIds); 2827 } 2828 2829 /** 2830 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2831 * 2832 * @param groupId the group ID 2833 * @param folderId the folder ID 2834 * @param name the name 2835 * @return the matching document library file entry 2836 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2837 */ 2838 public static DLFileEntry findByG_F_N(long groupId, long folderId, 2839 java.lang.String name) 2840 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2841 return getPersistence().findByG_F_N(groupId, folderId, name); 2842 } 2843 2844 /** 2845 * 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. 2846 * 2847 * @param groupId the group ID 2848 * @param folderId the folder ID 2849 * @param name the name 2850 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2851 */ 2852 public static DLFileEntry fetchByG_F_N(long groupId, long folderId, 2853 java.lang.String name) { 2854 return getPersistence().fetchByG_F_N(groupId, folderId, name); 2855 } 2856 2857 /** 2858 * 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. 2859 * 2860 * @param groupId the group ID 2861 * @param folderId the folder ID 2862 * @param name the name 2863 * @param retrieveFromCache whether to retrieve from the finder cache 2864 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2865 */ 2866 public static DLFileEntry fetchByG_F_N(long groupId, long folderId, 2867 java.lang.String name, boolean retrieveFromCache) { 2868 return getPersistence() 2869 .fetchByG_F_N(groupId, folderId, name, retrieveFromCache); 2870 } 2871 2872 /** 2873 * Removes the document library file entry where groupId = ? and folderId = ? and name = ? from the database. 2874 * 2875 * @param groupId the group ID 2876 * @param folderId the folder ID 2877 * @param name the name 2878 * @return the document library file entry that was removed 2879 */ 2880 public static DLFileEntry removeByG_F_N(long groupId, long folderId, 2881 java.lang.String name) 2882 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2883 return getPersistence().removeByG_F_N(groupId, folderId, name); 2884 } 2885 2886 /** 2887 * Returns the number of document library file entries where groupId = ? and folderId = ? and name = ?. 2888 * 2889 * @param groupId the group ID 2890 * @param folderId the folder ID 2891 * @param name the name 2892 * @return the number of matching document library file entries 2893 */ 2894 public static int countByG_F_N(long groupId, long folderId, 2895 java.lang.String name) { 2896 return getPersistence().countByG_F_N(groupId, folderId, name); 2897 } 2898 2899 /** 2900 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2901 * 2902 * @param groupId the group ID 2903 * @param folderId the folder ID 2904 * @param fileName the file name 2905 * @return the matching document library file entry 2906 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2907 */ 2908 public static DLFileEntry findByG_F_FN(long groupId, long folderId, 2909 java.lang.String fileName) 2910 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2911 return getPersistence().findByG_F_FN(groupId, folderId, fileName); 2912 } 2913 2914 /** 2915 * 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. 2916 * 2917 * @param groupId the group ID 2918 * @param folderId the folder ID 2919 * @param fileName the file name 2920 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2921 */ 2922 public static DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2923 java.lang.String fileName) { 2924 return getPersistence().fetchByG_F_FN(groupId, folderId, fileName); 2925 } 2926 2927 /** 2928 * 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. 2929 * 2930 * @param groupId the group ID 2931 * @param folderId the folder ID 2932 * @param fileName the file name 2933 * @param retrieveFromCache whether to retrieve from the finder cache 2934 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2935 */ 2936 public static DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2937 java.lang.String fileName, boolean retrieveFromCache) { 2938 return getPersistence() 2939 .fetchByG_F_FN(groupId, folderId, fileName, retrieveFromCache); 2940 } 2941 2942 /** 2943 * Removes the document library file entry where groupId = ? and folderId = ? and fileName = ? from the database. 2944 * 2945 * @param groupId the group ID 2946 * @param folderId the folder ID 2947 * @param fileName the file name 2948 * @return the document library file entry that was removed 2949 */ 2950 public static DLFileEntry removeByG_F_FN(long groupId, long folderId, 2951 java.lang.String fileName) 2952 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2953 return getPersistence().removeByG_F_FN(groupId, folderId, fileName); 2954 } 2955 2956 /** 2957 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileName = ?. 2958 * 2959 * @param groupId the group ID 2960 * @param folderId the folder ID 2961 * @param fileName the file name 2962 * @return the number of matching document library file entries 2963 */ 2964 public static int countByG_F_FN(long groupId, long folderId, 2965 java.lang.String fileName) { 2966 return getPersistence().countByG_F_FN(groupId, folderId, fileName); 2967 } 2968 2969 /** 2970 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2971 * 2972 * @param groupId the group ID 2973 * @param folderId the folder ID 2974 * @param title the title 2975 * @return the matching document library file entry 2976 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2977 */ 2978 public static DLFileEntry findByG_F_T(long groupId, long folderId, 2979 java.lang.String title) 2980 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 2981 return getPersistence().findByG_F_T(groupId, folderId, title); 2982 } 2983 2984 /** 2985 * 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. 2986 * 2987 * @param groupId the group ID 2988 * @param folderId the folder ID 2989 * @param title the title 2990 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2991 */ 2992 public static DLFileEntry fetchByG_F_T(long groupId, long folderId, 2993 java.lang.String title) { 2994 return getPersistence().fetchByG_F_T(groupId, folderId, title); 2995 } 2996 2997 /** 2998 * 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. 2999 * 3000 * @param groupId the group ID 3001 * @param folderId the folder ID 3002 * @param title the title 3003 * @param retrieveFromCache whether to retrieve from the finder cache 3004 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 3005 */ 3006 public static DLFileEntry fetchByG_F_T(long groupId, long folderId, 3007 java.lang.String title, boolean retrieveFromCache) { 3008 return getPersistence() 3009 .fetchByG_F_T(groupId, folderId, title, retrieveFromCache); 3010 } 3011 3012 /** 3013 * Removes the document library file entry where groupId = ? and folderId = ? and title = ? from the database. 3014 * 3015 * @param groupId the group ID 3016 * @param folderId the folder ID 3017 * @param title the title 3018 * @return the document library file entry that was removed 3019 */ 3020 public static DLFileEntry removeByG_F_T(long groupId, long folderId, 3021 java.lang.String title) 3022 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3023 return getPersistence().removeByG_F_T(groupId, folderId, title); 3024 } 3025 3026 /** 3027 * Returns the number of document library file entries where groupId = ? and folderId = ? and title = ?. 3028 * 3029 * @param groupId the group ID 3030 * @param folderId the folder ID 3031 * @param title the title 3032 * @return the number of matching document library file entries 3033 */ 3034 public static int countByG_F_T(long groupId, long folderId, 3035 java.lang.String title) { 3036 return getPersistence().countByG_F_T(groupId, folderId, title); 3037 } 3038 3039 /** 3040 * Returns all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3041 * 3042 * @param groupId the group ID 3043 * @param folderId the folder ID 3044 * @param fileEntryTypeId the file entry type ID 3045 * @return the matching document library file entries 3046 */ 3047 public static List<DLFileEntry> findByG_F_F(long groupId, long folderId, 3048 long fileEntryTypeId) { 3049 return getPersistence().findByG_F_F(groupId, folderId, fileEntryTypeId); 3050 } 3051 3052 /** 3053 * Returns a range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3054 * 3055 * <p> 3056 * 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. 3057 * </p> 3058 * 3059 * @param groupId the group ID 3060 * @param folderId the folder ID 3061 * @param fileEntryTypeId the file entry type ID 3062 * @param start the lower bound of the range of document library file entries 3063 * @param end the upper bound of the range of document library file entries (not inclusive) 3064 * @return the range of matching document library file entries 3065 */ 3066 public static List<DLFileEntry> findByG_F_F(long groupId, long folderId, 3067 long fileEntryTypeId, int start, int end) { 3068 return getPersistence() 3069 .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end); 3070 } 3071 3072 /** 3073 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3074 * 3075 * <p> 3076 * 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. 3077 * </p> 3078 * 3079 * @param groupId the group ID 3080 * @param folderId the folder ID 3081 * @param fileEntryTypeId the file entry type ID 3082 * @param start the lower bound of the range of document library file entries 3083 * @param end the upper bound of the range of document library file entries (not inclusive) 3084 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3085 * @return the ordered range of matching document library file entries 3086 */ 3087 public static List<DLFileEntry> findByG_F_F(long groupId, long folderId, 3088 long fileEntryTypeId, int start, int end, 3089 OrderByComparator<DLFileEntry> orderByComparator) { 3090 return getPersistence() 3091 .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end, 3092 orderByComparator); 3093 } 3094 3095 /** 3096 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3097 * 3098 * <p> 3099 * 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. 3100 * </p> 3101 * 3102 * @param groupId the group ID 3103 * @param folderId the folder ID 3104 * @param fileEntryTypeId the file entry type ID 3105 * @param start the lower bound of the range of document library file entries 3106 * @param end the upper bound of the range of document library file entries (not inclusive) 3107 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3108 * @param retrieveFromCache whether to retrieve from the finder cache 3109 * @return the ordered range of matching document library file entries 3110 */ 3111 public static List<DLFileEntry> findByG_F_F(long groupId, long folderId, 3112 long fileEntryTypeId, int start, int end, 3113 OrderByComparator<DLFileEntry> orderByComparator, 3114 boolean retrieveFromCache) { 3115 return getPersistence() 3116 .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end, 3117 orderByComparator, retrieveFromCache); 3118 } 3119 3120 /** 3121 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3122 * 3123 * @param groupId the group ID 3124 * @param folderId the folder ID 3125 * @param fileEntryTypeId the file entry type ID 3126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3127 * @return the first matching document library file entry 3128 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 3129 */ 3130 public static DLFileEntry findByG_F_F_First(long groupId, long folderId, 3131 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) 3132 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3133 return getPersistence() 3134 .findByG_F_F_First(groupId, folderId, fileEntryTypeId, 3135 orderByComparator); 3136 } 3137 3138 /** 3139 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3140 * 3141 * @param groupId the group ID 3142 * @param folderId the folder ID 3143 * @param fileEntryTypeId the file entry type ID 3144 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3145 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 3146 */ 3147 public static DLFileEntry fetchByG_F_F_First(long groupId, long folderId, 3148 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) { 3149 return getPersistence() 3150 .fetchByG_F_F_First(groupId, folderId, fileEntryTypeId, 3151 orderByComparator); 3152 } 3153 3154 /** 3155 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3156 * 3157 * @param groupId the group ID 3158 * @param folderId the folder ID 3159 * @param fileEntryTypeId the file entry type ID 3160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3161 * @return the last matching document library file entry 3162 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 3163 */ 3164 public static DLFileEntry findByG_F_F_Last(long groupId, long folderId, 3165 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) 3166 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3167 return getPersistence() 3168 .findByG_F_F_Last(groupId, folderId, fileEntryTypeId, 3169 orderByComparator); 3170 } 3171 3172 /** 3173 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3174 * 3175 * @param groupId the group ID 3176 * @param folderId the folder ID 3177 * @param fileEntryTypeId the file entry type ID 3178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3179 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 3180 */ 3181 public static DLFileEntry fetchByG_F_F_Last(long groupId, long folderId, 3182 long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) { 3183 return getPersistence() 3184 .fetchByG_F_F_Last(groupId, folderId, fileEntryTypeId, 3185 orderByComparator); 3186 } 3187 3188 /** 3189 * 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 = ?. 3190 * 3191 * @param fileEntryId the primary key of the current document library file entry 3192 * @param groupId the group ID 3193 * @param folderId the folder ID 3194 * @param fileEntryTypeId the file entry type ID 3195 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3196 * @return the previous, current, and next document library file entry 3197 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 3198 */ 3199 public static DLFileEntry[] findByG_F_F_PrevAndNext(long fileEntryId, 3200 long groupId, long folderId, long fileEntryTypeId, 3201 OrderByComparator<DLFileEntry> orderByComparator) 3202 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3203 return getPersistence() 3204 .findByG_F_F_PrevAndNext(fileEntryId, groupId, folderId, 3205 fileEntryTypeId, orderByComparator); 3206 } 3207 3208 /** 3209 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3210 * 3211 * @param groupId the group ID 3212 * @param folderId the folder ID 3213 * @param fileEntryTypeId the file entry type ID 3214 * @return the matching document library file entries that the user has permission to view 3215 */ 3216 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3217 long folderId, long fileEntryTypeId) { 3218 return getPersistence() 3219 .filterFindByG_F_F(groupId, folderId, fileEntryTypeId); 3220 } 3221 3222 /** 3223 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3224 * 3225 * <p> 3226 * 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. 3227 * </p> 3228 * 3229 * @param groupId the group ID 3230 * @param folderId the folder ID 3231 * @param fileEntryTypeId the file entry type ID 3232 * @param start the lower bound of the range of document library file entries 3233 * @param end the upper bound of the range of document library file entries (not inclusive) 3234 * @return the range of matching document library file entries that the user has permission to view 3235 */ 3236 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3237 long folderId, long fileEntryTypeId, int start, int end) { 3238 return getPersistence() 3239 .filterFindByG_F_F(groupId, folderId, fileEntryTypeId, 3240 start, end); 3241 } 3242 3243 /** 3244 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3245 * 3246 * <p> 3247 * 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. 3248 * </p> 3249 * 3250 * @param groupId the group ID 3251 * @param folderId the folder ID 3252 * @param fileEntryTypeId the file entry type ID 3253 * @param start the lower bound of the range of document library file entries 3254 * @param end the upper bound of the range of document library file entries (not inclusive) 3255 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3256 * @return the ordered range of matching document library file entries that the user has permission to view 3257 */ 3258 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3259 long folderId, long fileEntryTypeId, int start, int end, 3260 OrderByComparator<DLFileEntry> orderByComparator) { 3261 return getPersistence() 3262 .filterFindByG_F_F(groupId, folderId, fileEntryTypeId, 3263 start, end, orderByComparator); 3264 } 3265 3266 /** 3267 * 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 = ?. 3268 * 3269 * @param fileEntryId the primary key of the current document library file entry 3270 * @param groupId the group ID 3271 * @param folderId the folder ID 3272 * @param fileEntryTypeId the file entry type ID 3273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3274 * @return the previous, current, and next document library file entry 3275 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 3276 */ 3277 public static DLFileEntry[] filterFindByG_F_F_PrevAndNext( 3278 long fileEntryId, long groupId, long folderId, long fileEntryTypeId, 3279 OrderByComparator<DLFileEntry> orderByComparator) 3280 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3281 return getPersistence() 3282 .filterFindByG_F_F_PrevAndNext(fileEntryId, groupId, 3283 folderId, fileEntryTypeId, orderByComparator); 3284 } 3285 3286 /** 3287 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3288 * 3289 * @param groupId the group ID 3290 * @param folderIds the folder IDs 3291 * @param fileEntryTypeId the file entry type ID 3292 * @return the matching document library file entries that the user has permission to view 3293 */ 3294 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3295 long[] folderIds, long fileEntryTypeId) { 3296 return getPersistence() 3297 .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId); 3298 } 3299 3300 /** 3301 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3302 * 3303 * <p> 3304 * 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. 3305 * </p> 3306 * 3307 * @param groupId the group ID 3308 * @param folderIds the folder IDs 3309 * @param fileEntryTypeId the file entry type ID 3310 * @param start the lower bound of the range of document library file entries 3311 * @param end the upper bound of the range of document library file entries (not inclusive) 3312 * @return the range of matching document library file entries that the user has permission to view 3313 */ 3314 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3315 long[] folderIds, long fileEntryTypeId, int start, int end) { 3316 return getPersistence() 3317 .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId, 3318 start, end); 3319 } 3320 3321 /** 3322 * 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 = ?. 3323 * 3324 * <p> 3325 * 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. 3326 * </p> 3327 * 3328 * @param groupId the group ID 3329 * @param folderIds the folder IDs 3330 * @param fileEntryTypeId the file entry type ID 3331 * @param start the lower bound of the range of document library file entries 3332 * @param end the upper bound of the range of document library file entries (not inclusive) 3333 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3334 * @return the ordered range of matching document library file entries that the user has permission to view 3335 */ 3336 public static List<DLFileEntry> filterFindByG_F_F(long groupId, 3337 long[] folderIds, long fileEntryTypeId, int start, int end, 3338 OrderByComparator<DLFileEntry> orderByComparator) { 3339 return getPersistence() 3340 .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId, 3341 start, end, orderByComparator); 3342 } 3343 3344 /** 3345 * Returns all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3346 * 3347 * <p> 3348 * 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. 3349 * </p> 3350 * 3351 * @param groupId the group ID 3352 * @param folderIds the folder IDs 3353 * @param fileEntryTypeId the file entry type ID 3354 * @return the matching document library file entries 3355 */ 3356 public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds, 3357 long fileEntryTypeId) { 3358 return getPersistence().findByG_F_F(groupId, folderIds, fileEntryTypeId); 3359 } 3360 3361 /** 3362 * Returns a range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3363 * 3364 * <p> 3365 * 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. 3366 * </p> 3367 * 3368 * @param groupId the group ID 3369 * @param folderIds the folder IDs 3370 * @param fileEntryTypeId the file entry type ID 3371 * @param start the lower bound of the range of document library file entries 3372 * @param end the upper bound of the range of document library file entries (not inclusive) 3373 * @return the range of matching document library file entries 3374 */ 3375 public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds, 3376 long fileEntryTypeId, int start, int end) { 3377 return getPersistence() 3378 .findByG_F_F(groupId, folderIds, fileEntryTypeId, start, end); 3379 } 3380 3381 /** 3382 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3383 * 3384 * <p> 3385 * 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. 3386 * </p> 3387 * 3388 * @param groupId the group ID 3389 * @param folderIds the folder IDs 3390 * @param fileEntryTypeId the file entry type ID 3391 * @param start the lower bound of the range of document library file entries 3392 * @param end the upper bound of the range of document library file entries (not inclusive) 3393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3394 * @return the ordered range of matching document library file entries 3395 */ 3396 public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds, 3397 long fileEntryTypeId, int start, int end, 3398 OrderByComparator<DLFileEntry> orderByComparator) { 3399 return getPersistence() 3400 .findByG_F_F(groupId, folderIds, fileEntryTypeId, start, 3401 end, orderByComparator); 3402 } 3403 3404 /** 3405 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?, optionally using the finder cache. 3406 * 3407 * <p> 3408 * 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. 3409 * </p> 3410 * 3411 * @param groupId the group ID 3412 * @param folderId the folder ID 3413 * @param fileEntryTypeId the file entry type ID 3414 * @param start the lower bound of the range of document library file entries 3415 * @param end the upper bound of the range of document library file entries (not inclusive) 3416 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3417 * @param retrieveFromCache whether to retrieve from the finder cache 3418 * @return the ordered range of matching document library file entries 3419 */ 3420 public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds, 3421 long fileEntryTypeId, int start, int end, 3422 OrderByComparator<DLFileEntry> orderByComparator, 3423 boolean retrieveFromCache) { 3424 return getPersistence() 3425 .findByG_F_F(groupId, folderIds, fileEntryTypeId, start, 3426 end, orderByComparator, retrieveFromCache); 3427 } 3428 3429 /** 3430 * Removes all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ? from the database. 3431 * 3432 * @param groupId the group ID 3433 * @param folderId the folder ID 3434 * @param fileEntryTypeId the file entry type ID 3435 */ 3436 public static void removeByG_F_F(long groupId, long folderId, 3437 long fileEntryTypeId) { 3438 getPersistence().removeByG_F_F(groupId, folderId, fileEntryTypeId); 3439 } 3440 3441 /** 3442 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3443 * 3444 * @param groupId the group ID 3445 * @param folderId the folder ID 3446 * @param fileEntryTypeId the file entry type ID 3447 * @return the number of matching document library file entries 3448 */ 3449 public static int countByG_F_F(long groupId, long folderId, 3450 long fileEntryTypeId) { 3451 return getPersistence().countByG_F_F(groupId, folderId, fileEntryTypeId); 3452 } 3453 3454 /** 3455 * Returns the number of document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3456 * 3457 * @param groupId the group ID 3458 * @param folderIds the folder IDs 3459 * @param fileEntryTypeId the file entry type ID 3460 * @return the number of matching document library file entries 3461 */ 3462 public static int countByG_F_F(long groupId, long[] folderIds, 3463 long fileEntryTypeId) { 3464 return getPersistence().countByG_F_F(groupId, folderIds, fileEntryTypeId); 3465 } 3466 3467 /** 3468 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 3469 * 3470 * @param groupId the group ID 3471 * @param folderId the folder ID 3472 * @param fileEntryTypeId the file entry type ID 3473 * @return the number of matching document library file entries that the user has permission to view 3474 */ 3475 public static int filterCountByG_F_F(long groupId, long folderId, 3476 long fileEntryTypeId) { 3477 return getPersistence() 3478 .filterCountByG_F_F(groupId, folderId, fileEntryTypeId); 3479 } 3480 3481 /** 3482 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 3483 * 3484 * @param groupId the group ID 3485 * @param folderIds the folder IDs 3486 * @param fileEntryTypeId the file entry type ID 3487 * @return the number of matching document library file entries that the user has permission to view 3488 */ 3489 public static int filterCountByG_F_F(long groupId, long[] folderIds, 3490 long fileEntryTypeId) { 3491 return getPersistence() 3492 .filterCountByG_F_F(groupId, folderIds, fileEntryTypeId); 3493 } 3494 3495 /** 3496 * Caches the document library file entry in the entity cache if it is enabled. 3497 * 3498 * @param dlFileEntry the document library file entry 3499 */ 3500 public static void cacheResult(DLFileEntry dlFileEntry) { 3501 getPersistence().cacheResult(dlFileEntry); 3502 } 3503 3504 /** 3505 * Caches the document library file entries in the entity cache if it is enabled. 3506 * 3507 * @param dlFileEntries the document library file entries 3508 */ 3509 public static void cacheResult(List<DLFileEntry> dlFileEntries) { 3510 getPersistence().cacheResult(dlFileEntries); 3511 } 3512 3513 /** 3514 * Creates a new document library file entry with the primary key. Does not add the document library file entry to the database. 3515 * 3516 * @param fileEntryId the primary key for the new document library file entry 3517 * @return the new document library file entry 3518 */ 3519 public static DLFileEntry create(long fileEntryId) { 3520 return getPersistence().create(fileEntryId); 3521 } 3522 3523 /** 3524 * Removes the document library file entry with the primary key from the database. Also notifies the appropriate model listeners. 3525 * 3526 * @param fileEntryId the primary key of the document library file entry 3527 * @return the document library file entry that was removed 3528 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 3529 */ 3530 public static DLFileEntry remove(long fileEntryId) 3531 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3532 return getPersistence().remove(fileEntryId); 3533 } 3534 3535 public static DLFileEntry updateImpl(DLFileEntry dlFileEntry) { 3536 return getPersistence().updateImpl(dlFileEntry); 3537 } 3538 3539 /** 3540 * Returns the document library file entry with the primary key or throws a {@link NoSuchFileEntryException} if it could not be found. 3541 * 3542 * @param fileEntryId the primary key of the document library file entry 3543 * @return the document library file entry 3544 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 3545 */ 3546 public static DLFileEntry findByPrimaryKey(long fileEntryId) 3547 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException { 3548 return getPersistence().findByPrimaryKey(fileEntryId); 3549 } 3550 3551 /** 3552 * Returns the document library file entry with the primary key or returns <code>null</code> if it could not be found. 3553 * 3554 * @param fileEntryId the primary key of the document library file entry 3555 * @return the document library file entry, or <code>null</code> if a document library file entry with the primary key could not be found 3556 */ 3557 public static DLFileEntry fetchByPrimaryKey(long fileEntryId) { 3558 return getPersistence().fetchByPrimaryKey(fileEntryId); 3559 } 3560 3561 public static java.util.Map<java.io.Serializable, DLFileEntry> fetchByPrimaryKeys( 3562 java.util.Set<java.io.Serializable> primaryKeys) { 3563 return getPersistence().fetchByPrimaryKeys(primaryKeys); 3564 } 3565 3566 /** 3567 * Returns all the document library file entries. 3568 * 3569 * @return the document library file entries 3570 */ 3571 public static List<DLFileEntry> findAll() { 3572 return getPersistence().findAll(); 3573 } 3574 3575 /** 3576 * Returns a range of all the document library file entries. 3577 * 3578 * <p> 3579 * 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. 3580 * </p> 3581 * 3582 * @param start the lower bound of the range of document library file entries 3583 * @param end the upper bound of the range of document library file entries (not inclusive) 3584 * @return the range of document library file entries 3585 */ 3586 public static List<DLFileEntry> findAll(int start, int end) { 3587 return getPersistence().findAll(start, end); 3588 } 3589 3590 /** 3591 * Returns an ordered range of all the document library file entries. 3592 * 3593 * <p> 3594 * 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. 3595 * </p> 3596 * 3597 * @param start the lower bound of the range of document library file entries 3598 * @param end the upper bound of the range of document library file entries (not inclusive) 3599 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3600 * @return the ordered range of document library file entries 3601 */ 3602 public static List<DLFileEntry> findAll(int start, int end, 3603 OrderByComparator<DLFileEntry> orderByComparator) { 3604 return getPersistence().findAll(start, end, orderByComparator); 3605 } 3606 3607 /** 3608 * Returns an ordered range of all the document library file entries. 3609 * 3610 * <p> 3611 * 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. 3612 * </p> 3613 * 3614 * @param start the lower bound of the range of document library file entries 3615 * @param end the upper bound of the range of document library file entries (not inclusive) 3616 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3617 * @param retrieveFromCache whether to retrieve from the finder cache 3618 * @return the ordered range of document library file entries 3619 */ 3620 public static List<DLFileEntry> findAll(int start, int end, 3621 OrderByComparator<DLFileEntry> orderByComparator, 3622 boolean retrieveFromCache) { 3623 return getPersistence() 3624 .findAll(start, end, orderByComparator, retrieveFromCache); 3625 } 3626 3627 /** 3628 * Removes all the document library file entries from the database. 3629 */ 3630 public static void removeAll() { 3631 getPersistence().removeAll(); 3632 } 3633 3634 /** 3635 * Returns the number of document library file entries. 3636 * 3637 * @return the number of document library file entries 3638 */ 3639 public static int countAll() { 3640 return getPersistence().countAll(); 3641 } 3642 3643 public static java.util.Set<java.lang.String> getBadColumnNames() { 3644 return getPersistence().getBadColumnNames(); 3645 } 3646 3647 public static DLFileEntryPersistence getPersistence() { 3648 if (_persistence == null) { 3649 _persistence = (DLFileEntryPersistence)PortalBeanLocatorUtil.locate(DLFileEntryPersistence.class.getName()); 3650 3651 ReferenceRegistry.registerReference(DLFileEntryUtil.class, 3652 "_persistence"); 3653 } 3654 3655 return _persistence; 3656 } 3657 3658 private static DLFileEntryPersistence _persistence; 3659 }