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