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.DLFileVersion; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the document library file version service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl} 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 DLFileVersionPersistence 038 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DLFileVersionUtil { 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(DLFileVersion dlFileVersion) { 060 getPersistence().clearCache(dlFileVersion); 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<DLFileVersion> 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<DLFileVersion> 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<DLFileVersion> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<DLFileVersion> 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 DLFileVersion update(DLFileVersion dlFileVersion) { 101 return getPersistence().update(dlFileVersion); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static DLFileVersion update(DLFileVersion dlFileVersion, 108 ServiceContext serviceContext) { 109 return getPersistence().update(dlFileVersion, serviceContext); 110 } 111 112 /** 113 * Returns all the document library file versions where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching document library file versions 117 */ 118 public static List<DLFileVersion> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the document library file versions 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 DLFileVersionModelImpl}. 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 versions 131 * @param end the upper bound of the range of document library file versions (not inclusive) 132 * @return the range of matching document library file versions 133 */ 134 public static List<DLFileVersion> 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 versions 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 DLFileVersionModelImpl}. 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 versions 148 * @param end the upper bound of the range of document library file versions (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 versions 151 */ 152 public static List<DLFileVersion> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the document library file versions where uuid = ?. 159 * 160 * <p> 161 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of document library file versions 166 * @param end the upper bound of the range of document library file versions (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching document library file versions 170 */ 171 public static List<DLFileVersion> findByUuid(java.lang.String uuid, 172 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first document library file version in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching document library file version 185 * @throws NoSuchFileVersionException if a matching document library file version could not be found 186 */ 187 public static DLFileVersion findByUuid_First(java.lang.String uuid, 188 OrderByComparator<DLFileVersion> orderByComparator) 189 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first document library file version in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 199 */ 200 public static DLFileVersion fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<DLFileVersion> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last document library file version in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching document library file version 211 * @throws NoSuchFileVersionException if a matching document library file version could not be found 212 */ 213 public static DLFileVersion findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<DLFileVersion> orderByComparator) 215 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last document library file version in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 225 */ 226 public static DLFileVersion fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<DLFileVersion> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = ?. 233 * 234 * @param fileVersionId the primary key of the current document library file version 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next document library file version 238 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 239 */ 240 public static DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId, 241 java.lang.String uuid, 242 OrderByComparator<DLFileVersion> orderByComparator) 243 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(fileVersionId, uuid, 246 orderByComparator); 247 } 248 249 /** 250 * Removes all the document library file versions where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 */ 254 public static void removeByUuid(java.lang.String uuid) { 255 getPersistence().removeByUuid(uuid); 256 } 257 258 /** 259 * Returns the number of document library file versions where uuid = ?. 260 * 261 * @param uuid the uuid 262 * @return the number of matching document library file versions 263 */ 264 public static int countByUuid(java.lang.String uuid) { 265 return getPersistence().countByUuid(uuid); 266 } 267 268 /** 269 * Returns the document library file version where uuid = ? and groupId = ? or throws a {@link NoSuchFileVersionException} if it could not be found. 270 * 271 * @param uuid the uuid 272 * @param groupId the group ID 273 * @return the matching document library file version 274 * @throws NoSuchFileVersionException if a matching document library file version could not be found 275 */ 276 public static DLFileVersion findByUUID_G(java.lang.String uuid, long groupId) 277 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 278 return getPersistence().findByUUID_G(uuid, groupId); 279 } 280 281 /** 282 * Returns the document library file version where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 283 * 284 * @param uuid the uuid 285 * @param groupId the group ID 286 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 287 */ 288 public static DLFileVersion fetchByUUID_G(java.lang.String uuid, 289 long groupId) { 290 return getPersistence().fetchByUUID_G(uuid, groupId); 291 } 292 293 /** 294 * Returns the document library file version where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 295 * 296 * @param uuid the uuid 297 * @param groupId the group ID 298 * @param retrieveFromCache whether to retrieve from the finder cache 299 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 300 */ 301 public static DLFileVersion fetchByUUID_G(java.lang.String uuid, 302 long groupId, boolean retrieveFromCache) { 303 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 304 } 305 306 /** 307 * Removes the document library file version where uuid = ? and groupId = ? from the database. 308 * 309 * @param uuid the uuid 310 * @param groupId the group ID 311 * @return the document library file version that was removed 312 */ 313 public static DLFileVersion removeByUUID_G(java.lang.String uuid, 314 long groupId) 315 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 316 return getPersistence().removeByUUID_G(uuid, groupId); 317 } 318 319 /** 320 * Returns the number of document library file versions where uuid = ? and groupId = ?. 321 * 322 * @param uuid the uuid 323 * @param groupId the group ID 324 * @return the number of matching document library file versions 325 */ 326 public static int countByUUID_G(java.lang.String uuid, long groupId) { 327 return getPersistence().countByUUID_G(uuid, groupId); 328 } 329 330 /** 331 * Returns all the document library file versions where uuid = ? and companyId = ?. 332 * 333 * @param uuid the uuid 334 * @param companyId the company ID 335 * @return the matching document library file versions 336 */ 337 public static List<DLFileVersion> findByUuid_C(java.lang.String uuid, 338 long companyId) { 339 return getPersistence().findByUuid_C(uuid, companyId); 340 } 341 342 /** 343 * Returns a range of all the document library file versions where uuid = ? and companyId = ?. 344 * 345 * <p> 346 * 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 DLFileVersionModelImpl}. 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. 347 * </p> 348 * 349 * @param uuid the uuid 350 * @param companyId the company ID 351 * @param start the lower bound of the range of document library file versions 352 * @param end the upper bound of the range of document library file versions (not inclusive) 353 * @return the range of matching document library file versions 354 */ 355 public static List<DLFileVersion> findByUuid_C(java.lang.String uuid, 356 long companyId, int start, int end) { 357 return getPersistence().findByUuid_C(uuid, companyId, start, end); 358 } 359 360 /** 361 * Returns an ordered range of all the document library file versions where uuid = ? and companyId = ?. 362 * 363 * <p> 364 * 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 DLFileVersionModelImpl}. 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. 365 * </p> 366 * 367 * @param uuid the uuid 368 * @param companyId the company ID 369 * @param start the lower bound of the range of document library file versions 370 * @param end the upper bound of the range of document library file versions (not inclusive) 371 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 372 * @return the ordered range of matching document library file versions 373 */ 374 public static List<DLFileVersion> findByUuid_C(java.lang.String uuid, 375 long companyId, int start, int end, 376 OrderByComparator<DLFileVersion> orderByComparator) { 377 return getPersistence() 378 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 379 } 380 381 /** 382 * Returns an ordered range of all the document library file versions where uuid = ? and companyId = ?. 383 * 384 * <p> 385 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 386 * </p> 387 * 388 * @param uuid the uuid 389 * @param companyId the company ID 390 * @param start the lower bound of the range of document library file versions 391 * @param end the upper bound of the range of document library file versions (not inclusive) 392 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 393 * @param retrieveFromCache whether to retrieve from the finder cache 394 * @return the ordered range of matching document library file versions 395 */ 396 public static List<DLFileVersion> findByUuid_C(java.lang.String uuid, 397 long companyId, int start, int end, 398 OrderByComparator<DLFileVersion> orderByComparator, 399 boolean retrieveFromCache) { 400 return getPersistence() 401 .findByUuid_C(uuid, companyId, start, end, 402 orderByComparator, retrieveFromCache); 403 } 404 405 /** 406 * Returns the first document library file version in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the first matching document library file version 412 * @throws NoSuchFileVersionException if a matching document library file version could not be found 413 */ 414 public static DLFileVersion findByUuid_C_First(java.lang.String uuid, 415 long companyId, OrderByComparator<DLFileVersion> orderByComparator) 416 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first document library file version in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 428 */ 429 public static DLFileVersion fetchByUuid_C_First(java.lang.String uuid, 430 long companyId, OrderByComparator<DLFileVersion> orderByComparator) { 431 return getPersistence() 432 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 433 } 434 435 /** 436 * Returns the last document library file version in the ordered set where uuid = ? and companyId = ?. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 441 * @return the last matching document library file version 442 * @throws NoSuchFileVersionException if a matching document library file version could not be found 443 */ 444 public static DLFileVersion findByUuid_C_Last(java.lang.String uuid, 445 long companyId, OrderByComparator<DLFileVersion> orderByComparator) 446 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 447 return getPersistence() 448 .findByUuid_C_Last(uuid, companyId, orderByComparator); 449 } 450 451 /** 452 * Returns the last document library file version in the ordered set where uuid = ? and companyId = ?. 453 * 454 * @param uuid the uuid 455 * @param companyId the company ID 456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 457 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 458 */ 459 public static DLFileVersion fetchByUuid_C_Last(java.lang.String uuid, 460 long companyId, OrderByComparator<DLFileVersion> orderByComparator) { 461 return getPersistence() 462 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 463 } 464 465 /** 466 * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = ? and companyId = ?. 467 * 468 * @param fileVersionId the primary key of the current document library file version 469 * @param uuid the uuid 470 * @param companyId the company ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the previous, current, and next document library file version 473 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 474 */ 475 public static DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId, 476 java.lang.String uuid, long companyId, 477 OrderByComparator<DLFileVersion> orderByComparator) 478 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 479 return getPersistence() 480 .findByUuid_C_PrevAndNext(fileVersionId, uuid, companyId, 481 orderByComparator); 482 } 483 484 /** 485 * Removes all the document library file versions where uuid = ? and companyId = ? from the database. 486 * 487 * @param uuid the uuid 488 * @param companyId the company ID 489 */ 490 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 491 getPersistence().removeByUuid_C(uuid, companyId); 492 } 493 494 /** 495 * Returns the number of document library file versions where uuid = ? and companyId = ?. 496 * 497 * @param uuid the uuid 498 * @param companyId the company ID 499 * @return the number of matching document library file versions 500 */ 501 public static int countByUuid_C(java.lang.String uuid, long companyId) { 502 return getPersistence().countByUuid_C(uuid, companyId); 503 } 504 505 /** 506 * Returns all the document library file versions where companyId = ?. 507 * 508 * @param companyId the company ID 509 * @return the matching document library file versions 510 */ 511 public static List<DLFileVersion> findByCompanyId(long companyId) { 512 return getPersistence().findByCompanyId(companyId); 513 } 514 515 /** 516 * Returns a range of all the document library file versions where companyId = ?. 517 * 518 * <p> 519 * 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 DLFileVersionModelImpl}. 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. 520 * </p> 521 * 522 * @param companyId the company ID 523 * @param start the lower bound of the range of document library file versions 524 * @param end the upper bound of the range of document library file versions (not inclusive) 525 * @return the range of matching document library file versions 526 */ 527 public static List<DLFileVersion> findByCompanyId(long companyId, 528 int start, int end) { 529 return getPersistence().findByCompanyId(companyId, start, end); 530 } 531 532 /** 533 * Returns an ordered range of all the document library file versions where companyId = ?. 534 * 535 * <p> 536 * 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 DLFileVersionModelImpl}. 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. 537 * </p> 538 * 539 * @param companyId the company ID 540 * @param start the lower bound of the range of document library file versions 541 * @param end the upper bound of the range of document library file versions (not inclusive) 542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 543 * @return the ordered range of matching document library file versions 544 */ 545 public static List<DLFileVersion> findByCompanyId(long companyId, 546 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 547 return getPersistence() 548 .findByCompanyId(companyId, start, end, orderByComparator); 549 } 550 551 /** 552 * Returns an ordered range of all the document library file versions where companyId = ?. 553 * 554 * <p> 555 * 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 DLFileVersionModelImpl}. 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. 556 * </p> 557 * 558 * @param companyId the company ID 559 * @param start the lower bound of the range of document library file versions 560 * @param end the upper bound of the range of document library file versions (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @param retrieveFromCache whether to retrieve from the finder cache 563 * @return the ordered range of matching document library file versions 564 */ 565 public static List<DLFileVersion> findByCompanyId(long companyId, 566 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 567 boolean retrieveFromCache) { 568 return getPersistence() 569 .findByCompanyId(companyId, start, end, orderByComparator, 570 retrieveFromCache); 571 } 572 573 /** 574 * Returns the first document library file version in the ordered set where companyId = ?. 575 * 576 * @param companyId the company ID 577 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 578 * @return the first matching document library file version 579 * @throws NoSuchFileVersionException if a matching document library file version could not be found 580 */ 581 public static DLFileVersion findByCompanyId_First(long companyId, 582 OrderByComparator<DLFileVersion> orderByComparator) 583 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 584 return getPersistence() 585 .findByCompanyId_First(companyId, orderByComparator); 586 } 587 588 /** 589 * Returns the first document library file version in the ordered set where companyId = ?. 590 * 591 * @param companyId the company ID 592 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 593 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 594 */ 595 public static DLFileVersion fetchByCompanyId_First(long companyId, 596 OrderByComparator<DLFileVersion> orderByComparator) { 597 return getPersistence() 598 .fetchByCompanyId_First(companyId, orderByComparator); 599 } 600 601 /** 602 * Returns the last document library file version in the ordered set where companyId = ?. 603 * 604 * @param companyId the company ID 605 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 606 * @return the last matching document library file version 607 * @throws NoSuchFileVersionException if a matching document library file version could not be found 608 */ 609 public static DLFileVersion findByCompanyId_Last(long companyId, 610 OrderByComparator<DLFileVersion> orderByComparator) 611 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 612 return getPersistence() 613 .findByCompanyId_Last(companyId, orderByComparator); 614 } 615 616 /** 617 * Returns the last document library file version in the ordered set where companyId = ?. 618 * 619 * @param companyId the company ID 620 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 621 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 622 */ 623 public static DLFileVersion fetchByCompanyId_Last(long companyId, 624 OrderByComparator<DLFileVersion> orderByComparator) { 625 return getPersistence() 626 .fetchByCompanyId_Last(companyId, orderByComparator); 627 } 628 629 /** 630 * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = ?. 631 * 632 * @param fileVersionId the primary key of the current document library file version 633 * @param companyId the company ID 634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 635 * @return the previous, current, and next document library file version 636 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 637 */ 638 public static DLFileVersion[] findByCompanyId_PrevAndNext( 639 long fileVersionId, long companyId, 640 OrderByComparator<DLFileVersion> orderByComparator) 641 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 642 return getPersistence() 643 .findByCompanyId_PrevAndNext(fileVersionId, companyId, 644 orderByComparator); 645 } 646 647 /** 648 * Removes all the document library file versions where companyId = ? from the database. 649 * 650 * @param companyId the company ID 651 */ 652 public static void removeByCompanyId(long companyId) { 653 getPersistence().removeByCompanyId(companyId); 654 } 655 656 /** 657 * Returns the number of document library file versions where companyId = ?. 658 * 659 * @param companyId the company ID 660 * @return the number of matching document library file versions 661 */ 662 public static int countByCompanyId(long companyId) { 663 return getPersistence().countByCompanyId(companyId); 664 } 665 666 /** 667 * Returns all the document library file versions where fileEntryId = ?. 668 * 669 * @param fileEntryId the file entry ID 670 * @return the matching document library file versions 671 */ 672 public static List<DLFileVersion> findByFileEntryId(long fileEntryId) { 673 return getPersistence().findByFileEntryId(fileEntryId); 674 } 675 676 /** 677 * Returns a range of all the document library file versions where fileEntryId = ?. 678 * 679 * <p> 680 * 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 DLFileVersionModelImpl}. 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. 681 * </p> 682 * 683 * @param fileEntryId the file entry ID 684 * @param start the lower bound of the range of document library file versions 685 * @param end the upper bound of the range of document library file versions (not inclusive) 686 * @return the range of matching document library file versions 687 */ 688 public static List<DLFileVersion> findByFileEntryId(long fileEntryId, 689 int start, int end) { 690 return getPersistence().findByFileEntryId(fileEntryId, start, end); 691 } 692 693 /** 694 * Returns an ordered range of all the document library file versions where fileEntryId = ?. 695 * 696 * <p> 697 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 698 * </p> 699 * 700 * @param fileEntryId the file entry ID 701 * @param start the lower bound of the range of document library file versions 702 * @param end the upper bound of the range of document library file versions (not inclusive) 703 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 704 * @return the ordered range of matching document library file versions 705 */ 706 public static List<DLFileVersion> findByFileEntryId(long fileEntryId, 707 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 708 return getPersistence() 709 .findByFileEntryId(fileEntryId, start, end, orderByComparator); 710 } 711 712 /** 713 * Returns an ordered range of all the document library file versions where fileEntryId = ?. 714 * 715 * <p> 716 * 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 DLFileVersionModelImpl}. 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. 717 * </p> 718 * 719 * @param fileEntryId the file entry ID 720 * @param start the lower bound of the range of document library file versions 721 * @param end the upper bound of the range of document library file versions (not inclusive) 722 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 723 * @param retrieveFromCache whether to retrieve from the finder cache 724 * @return the ordered range of matching document library file versions 725 */ 726 public static List<DLFileVersion> findByFileEntryId(long fileEntryId, 727 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 728 boolean retrieveFromCache) { 729 return getPersistence() 730 .findByFileEntryId(fileEntryId, start, end, 731 orderByComparator, retrieveFromCache); 732 } 733 734 /** 735 * Returns the first document library file version in the ordered set where fileEntryId = ?. 736 * 737 * @param fileEntryId the file entry ID 738 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 739 * @return the first matching document library file version 740 * @throws NoSuchFileVersionException if a matching document library file version could not be found 741 */ 742 public static DLFileVersion findByFileEntryId_First(long fileEntryId, 743 OrderByComparator<DLFileVersion> orderByComparator) 744 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 745 return getPersistence() 746 .findByFileEntryId_First(fileEntryId, orderByComparator); 747 } 748 749 /** 750 * Returns the first document library file version in the ordered set where fileEntryId = ?. 751 * 752 * @param fileEntryId the file entry ID 753 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 754 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 755 */ 756 public static DLFileVersion fetchByFileEntryId_First(long fileEntryId, 757 OrderByComparator<DLFileVersion> orderByComparator) { 758 return getPersistence() 759 .fetchByFileEntryId_First(fileEntryId, orderByComparator); 760 } 761 762 /** 763 * Returns the last document library file version in the ordered set where fileEntryId = ?. 764 * 765 * @param fileEntryId the file entry ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the last matching document library file version 768 * @throws NoSuchFileVersionException if a matching document library file version could not be found 769 */ 770 public static DLFileVersion findByFileEntryId_Last(long fileEntryId, 771 OrderByComparator<DLFileVersion> orderByComparator) 772 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 773 return getPersistence() 774 .findByFileEntryId_Last(fileEntryId, orderByComparator); 775 } 776 777 /** 778 * Returns the last document library file version in the ordered set where fileEntryId = ?. 779 * 780 * @param fileEntryId the file entry ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 783 */ 784 public static DLFileVersion fetchByFileEntryId_Last(long fileEntryId, 785 OrderByComparator<DLFileVersion> orderByComparator) { 786 return getPersistence() 787 .fetchByFileEntryId_Last(fileEntryId, orderByComparator); 788 } 789 790 /** 791 * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = ?. 792 * 793 * @param fileVersionId the primary key of the current document library file version 794 * @param fileEntryId the file entry ID 795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 796 * @return the previous, current, and next document library file version 797 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 798 */ 799 public static DLFileVersion[] findByFileEntryId_PrevAndNext( 800 long fileVersionId, long fileEntryId, 801 OrderByComparator<DLFileVersion> orderByComparator) 802 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 803 return getPersistence() 804 .findByFileEntryId_PrevAndNext(fileVersionId, fileEntryId, 805 orderByComparator); 806 } 807 808 /** 809 * Removes all the document library file versions where fileEntryId = ? from the database. 810 * 811 * @param fileEntryId the file entry ID 812 */ 813 public static void removeByFileEntryId(long fileEntryId) { 814 getPersistence().removeByFileEntryId(fileEntryId); 815 } 816 817 /** 818 * Returns the number of document library file versions where fileEntryId = ?. 819 * 820 * @param fileEntryId the file entry ID 821 * @return the number of matching document library file versions 822 */ 823 public static int countByFileEntryId(long fileEntryId) { 824 return getPersistence().countByFileEntryId(fileEntryId); 825 } 826 827 /** 828 * Returns all the document library file versions where mimeType = ?. 829 * 830 * @param mimeType the mime type 831 * @return the matching document library file versions 832 */ 833 public static List<DLFileVersion> findByMimeType(java.lang.String mimeType) { 834 return getPersistence().findByMimeType(mimeType); 835 } 836 837 /** 838 * Returns a range of all the document library file versions where mimeType = ?. 839 * 840 * <p> 841 * 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 DLFileVersionModelImpl}. 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. 842 * </p> 843 * 844 * @param mimeType the mime type 845 * @param start the lower bound of the range of document library file versions 846 * @param end the upper bound of the range of document library file versions (not inclusive) 847 * @return the range of matching document library file versions 848 */ 849 public static List<DLFileVersion> findByMimeType( 850 java.lang.String mimeType, int start, int end) { 851 return getPersistence().findByMimeType(mimeType, start, end); 852 } 853 854 /** 855 * Returns an ordered range of all the document library file versions where mimeType = ?. 856 * 857 * <p> 858 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 859 * </p> 860 * 861 * @param mimeType the mime type 862 * @param start the lower bound of the range of document library file versions 863 * @param end the upper bound of the range of document library file versions (not inclusive) 864 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 865 * @return the ordered range of matching document library file versions 866 */ 867 public static List<DLFileVersion> findByMimeType( 868 java.lang.String mimeType, int start, int end, 869 OrderByComparator<DLFileVersion> orderByComparator) { 870 return getPersistence() 871 .findByMimeType(mimeType, start, end, orderByComparator); 872 } 873 874 /** 875 * Returns an ordered range of all the document library file versions where mimeType = ?. 876 * 877 * <p> 878 * 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 DLFileVersionModelImpl}. 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. 879 * </p> 880 * 881 * @param mimeType the mime type 882 * @param start the lower bound of the range of document library file versions 883 * @param end the upper bound of the range of document library file versions (not inclusive) 884 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 885 * @param retrieveFromCache whether to retrieve from the finder cache 886 * @return the ordered range of matching document library file versions 887 */ 888 public static List<DLFileVersion> findByMimeType( 889 java.lang.String mimeType, int start, int end, 890 OrderByComparator<DLFileVersion> orderByComparator, 891 boolean retrieveFromCache) { 892 return getPersistence() 893 .findByMimeType(mimeType, start, end, orderByComparator, 894 retrieveFromCache); 895 } 896 897 /** 898 * Returns the first document library file version in the ordered set where mimeType = ?. 899 * 900 * @param mimeType the mime type 901 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 902 * @return the first matching document library file version 903 * @throws NoSuchFileVersionException if a matching document library file version could not be found 904 */ 905 public static DLFileVersion findByMimeType_First( 906 java.lang.String mimeType, 907 OrderByComparator<DLFileVersion> orderByComparator) 908 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 909 return getPersistence().findByMimeType_First(mimeType, orderByComparator); 910 } 911 912 /** 913 * Returns the first document library file version in the ordered set where mimeType = ?. 914 * 915 * @param mimeType the mime type 916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 917 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 918 */ 919 public static DLFileVersion fetchByMimeType_First( 920 java.lang.String mimeType, 921 OrderByComparator<DLFileVersion> orderByComparator) { 922 return getPersistence() 923 .fetchByMimeType_First(mimeType, orderByComparator); 924 } 925 926 /** 927 * Returns the last document library file version in the ordered set where mimeType = ?. 928 * 929 * @param mimeType the mime type 930 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 931 * @return the last matching document library file version 932 * @throws NoSuchFileVersionException if a matching document library file version could not be found 933 */ 934 public static DLFileVersion findByMimeType_Last(java.lang.String mimeType, 935 OrderByComparator<DLFileVersion> orderByComparator) 936 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 937 return getPersistence().findByMimeType_Last(mimeType, orderByComparator); 938 } 939 940 /** 941 * Returns the last document library file version in the ordered set where mimeType = ?. 942 * 943 * @param mimeType the mime type 944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 945 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 946 */ 947 public static DLFileVersion fetchByMimeType_Last( 948 java.lang.String mimeType, 949 OrderByComparator<DLFileVersion> orderByComparator) { 950 return getPersistence().fetchByMimeType_Last(mimeType, orderByComparator); 951 } 952 953 /** 954 * Returns the document library file versions before and after the current document library file version in the ordered set where mimeType = ?. 955 * 956 * @param fileVersionId the primary key of the current document library file version 957 * @param mimeType the mime type 958 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 959 * @return the previous, current, and next document library file version 960 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 961 */ 962 public static DLFileVersion[] findByMimeType_PrevAndNext( 963 long fileVersionId, java.lang.String mimeType, 964 OrderByComparator<DLFileVersion> orderByComparator) 965 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 966 return getPersistence() 967 .findByMimeType_PrevAndNext(fileVersionId, mimeType, 968 orderByComparator); 969 } 970 971 /** 972 * Removes all the document library file versions where mimeType = ? from the database. 973 * 974 * @param mimeType the mime type 975 */ 976 public static void removeByMimeType(java.lang.String mimeType) { 977 getPersistence().removeByMimeType(mimeType); 978 } 979 980 /** 981 * Returns the number of document library file versions where mimeType = ?. 982 * 983 * @param mimeType the mime type 984 * @return the number of matching document library file versions 985 */ 986 public static int countByMimeType(java.lang.String mimeType) { 987 return getPersistence().countByMimeType(mimeType); 988 } 989 990 /** 991 * Returns all the document library file versions where companyId = ? and status ≠ ?. 992 * 993 * @param companyId the company ID 994 * @param status the status 995 * @return the matching document library file versions 996 */ 997 public static List<DLFileVersion> findByC_NotS(long companyId, int status) { 998 return getPersistence().findByC_NotS(companyId, status); 999 } 1000 1001 /** 1002 * Returns a range of all the document library file versions where companyId = ? and status ≠ ?. 1003 * 1004 * <p> 1005 * 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 DLFileVersionModelImpl}. 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. 1006 * </p> 1007 * 1008 * @param companyId the company ID 1009 * @param status the status 1010 * @param start the lower bound of the range of document library file versions 1011 * @param end the upper bound of the range of document library file versions (not inclusive) 1012 * @return the range of matching document library file versions 1013 */ 1014 public static List<DLFileVersion> findByC_NotS(long companyId, int status, 1015 int start, int end) { 1016 return getPersistence().findByC_NotS(companyId, status, start, end); 1017 } 1018 1019 /** 1020 * Returns an ordered range of all the document library file versions where companyId = ? and status ≠ ?. 1021 * 1022 * <p> 1023 * 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 DLFileVersionModelImpl}. 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. 1024 * </p> 1025 * 1026 * @param companyId the company ID 1027 * @param status the status 1028 * @param start the lower bound of the range of document library file versions 1029 * @param end the upper bound of the range of document library file versions (not inclusive) 1030 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1031 * @return the ordered range of matching document library file versions 1032 */ 1033 public static List<DLFileVersion> findByC_NotS(long companyId, int status, 1034 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 1035 return getPersistence() 1036 .findByC_NotS(companyId, status, start, end, 1037 orderByComparator); 1038 } 1039 1040 /** 1041 * Returns an ordered range of all the document library file versions where companyId = ? and status ≠ ?. 1042 * 1043 * <p> 1044 * 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 DLFileVersionModelImpl}. 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. 1045 * </p> 1046 * 1047 * @param companyId the company ID 1048 * @param status the status 1049 * @param start the lower bound of the range of document library file versions 1050 * @param end the upper bound of the range of document library file versions (not inclusive) 1051 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1052 * @param retrieveFromCache whether to retrieve from the finder cache 1053 * @return the ordered range of matching document library file versions 1054 */ 1055 public static List<DLFileVersion> findByC_NotS(long companyId, int status, 1056 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 1057 boolean retrieveFromCache) { 1058 return getPersistence() 1059 .findByC_NotS(companyId, status, start, end, 1060 orderByComparator, retrieveFromCache); 1061 } 1062 1063 /** 1064 * Returns the first document library file version in the ordered set where companyId = ? and status ≠ ?. 1065 * 1066 * @param companyId the company ID 1067 * @param status the status 1068 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1069 * @return the first matching document library file version 1070 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1071 */ 1072 public static DLFileVersion findByC_NotS_First(long companyId, int status, 1073 OrderByComparator<DLFileVersion> orderByComparator) 1074 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1075 return getPersistence() 1076 .findByC_NotS_First(companyId, status, orderByComparator); 1077 } 1078 1079 /** 1080 * Returns the first document library file version in the ordered set where companyId = ? and status ≠ ?. 1081 * 1082 * @param companyId the company ID 1083 * @param status the status 1084 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1085 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1086 */ 1087 public static DLFileVersion fetchByC_NotS_First(long companyId, int status, 1088 OrderByComparator<DLFileVersion> orderByComparator) { 1089 return getPersistence() 1090 .fetchByC_NotS_First(companyId, status, orderByComparator); 1091 } 1092 1093 /** 1094 * Returns the last document library file version in the ordered set where companyId = ? and status ≠ ?. 1095 * 1096 * @param companyId the company ID 1097 * @param status the status 1098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1099 * @return the last matching document library file version 1100 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1101 */ 1102 public static DLFileVersion findByC_NotS_Last(long companyId, int status, 1103 OrderByComparator<DLFileVersion> orderByComparator) 1104 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1105 return getPersistence() 1106 .findByC_NotS_Last(companyId, status, orderByComparator); 1107 } 1108 1109 /** 1110 * Returns the last document library file version in the ordered set where companyId = ? and status ≠ ?. 1111 * 1112 * @param companyId the company ID 1113 * @param status the status 1114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1115 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1116 */ 1117 public static DLFileVersion fetchByC_NotS_Last(long companyId, int status, 1118 OrderByComparator<DLFileVersion> orderByComparator) { 1119 return getPersistence() 1120 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1121 } 1122 1123 /** 1124 * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = ? and status ≠ ?. 1125 * 1126 * @param fileVersionId the primary key of the current document library file version 1127 * @param companyId the company ID 1128 * @param status the status 1129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1130 * @return the previous, current, and next document library file version 1131 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1132 */ 1133 public static DLFileVersion[] findByC_NotS_PrevAndNext(long fileVersionId, 1134 long companyId, int status, 1135 OrderByComparator<DLFileVersion> orderByComparator) 1136 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1137 return getPersistence() 1138 .findByC_NotS_PrevAndNext(fileVersionId, companyId, status, 1139 orderByComparator); 1140 } 1141 1142 /** 1143 * Removes all the document library file versions where companyId = ? and status ≠ ? from the database. 1144 * 1145 * @param companyId the company ID 1146 * @param status the status 1147 */ 1148 public static void removeByC_NotS(long companyId, int status) { 1149 getPersistence().removeByC_NotS(companyId, status); 1150 } 1151 1152 /** 1153 * Returns the number of document library file versions where companyId = ? and status ≠ ?. 1154 * 1155 * @param companyId the company ID 1156 * @param status the status 1157 * @return the number of matching document library file versions 1158 */ 1159 public static int countByC_NotS(long companyId, int status) { 1160 return getPersistence().countByC_NotS(companyId, status); 1161 } 1162 1163 /** 1164 * Returns the document library file version where fileEntryId = ? and version = ? or throws a {@link NoSuchFileVersionException} if it could not be found. 1165 * 1166 * @param fileEntryId the file entry ID 1167 * @param version the version 1168 * @return the matching document library file version 1169 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1170 */ 1171 public static DLFileVersion findByF_V(long fileEntryId, 1172 java.lang.String version) 1173 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1174 return getPersistence().findByF_V(fileEntryId, version); 1175 } 1176 1177 /** 1178 * Returns the document library file version where fileEntryId = ? and version = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1179 * 1180 * @param fileEntryId the file entry ID 1181 * @param version the version 1182 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 1183 */ 1184 public static DLFileVersion fetchByF_V(long fileEntryId, 1185 java.lang.String version) { 1186 return getPersistence().fetchByF_V(fileEntryId, version); 1187 } 1188 1189 /** 1190 * Returns the document library file version where fileEntryId = ? and version = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1191 * 1192 * @param fileEntryId the file entry ID 1193 * @param version the version 1194 * @param retrieveFromCache whether to retrieve from the finder cache 1195 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 1196 */ 1197 public static DLFileVersion fetchByF_V(long fileEntryId, 1198 java.lang.String version, boolean retrieveFromCache) { 1199 return getPersistence() 1200 .fetchByF_V(fileEntryId, version, retrieveFromCache); 1201 } 1202 1203 /** 1204 * Removes the document library file version where fileEntryId = ? and version = ? from the database. 1205 * 1206 * @param fileEntryId the file entry ID 1207 * @param version the version 1208 * @return the document library file version that was removed 1209 */ 1210 public static DLFileVersion removeByF_V(long fileEntryId, 1211 java.lang.String version) 1212 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1213 return getPersistence().removeByF_V(fileEntryId, version); 1214 } 1215 1216 /** 1217 * Returns the number of document library file versions where fileEntryId = ? and version = ?. 1218 * 1219 * @param fileEntryId the file entry ID 1220 * @param version the version 1221 * @return the number of matching document library file versions 1222 */ 1223 public static int countByF_V(long fileEntryId, java.lang.String version) { 1224 return getPersistence().countByF_V(fileEntryId, version); 1225 } 1226 1227 /** 1228 * Returns all the document library file versions where fileEntryId = ? and status = ?. 1229 * 1230 * @param fileEntryId the file entry ID 1231 * @param status the status 1232 * @return the matching document library file versions 1233 */ 1234 public static List<DLFileVersion> findByF_S(long fileEntryId, int status) { 1235 return getPersistence().findByF_S(fileEntryId, status); 1236 } 1237 1238 /** 1239 * Returns a range of all the document library file versions where fileEntryId = ? and status = ?. 1240 * 1241 * <p> 1242 * 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 DLFileVersionModelImpl}. 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. 1243 * </p> 1244 * 1245 * @param fileEntryId the file entry ID 1246 * @param status the status 1247 * @param start the lower bound of the range of document library file versions 1248 * @param end the upper bound of the range of document library file versions (not inclusive) 1249 * @return the range of matching document library file versions 1250 */ 1251 public static List<DLFileVersion> findByF_S(long fileEntryId, int status, 1252 int start, int end) { 1253 return getPersistence().findByF_S(fileEntryId, status, start, end); 1254 } 1255 1256 /** 1257 * Returns an ordered range of all the document library file versions where fileEntryId = ? and status = ?. 1258 * 1259 * <p> 1260 * 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 DLFileVersionModelImpl}. 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. 1261 * </p> 1262 * 1263 * @param fileEntryId the file entry ID 1264 * @param status the status 1265 * @param start the lower bound of the range of document library file versions 1266 * @param end the upper bound of the range of document library file versions (not inclusive) 1267 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1268 * @return the ordered range of matching document library file versions 1269 */ 1270 public static List<DLFileVersion> findByF_S(long fileEntryId, int status, 1271 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 1272 return getPersistence() 1273 .findByF_S(fileEntryId, status, start, end, orderByComparator); 1274 } 1275 1276 /** 1277 * Returns an ordered range of all the document library file versions where fileEntryId = ? and status = ?. 1278 * 1279 * <p> 1280 * 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 DLFileVersionModelImpl}. 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. 1281 * </p> 1282 * 1283 * @param fileEntryId the file entry ID 1284 * @param status the status 1285 * @param start the lower bound of the range of document library file versions 1286 * @param end the upper bound of the range of document library file versions (not inclusive) 1287 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1288 * @param retrieveFromCache whether to retrieve from the finder cache 1289 * @return the ordered range of matching document library file versions 1290 */ 1291 public static List<DLFileVersion> findByF_S(long fileEntryId, int status, 1292 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 1293 boolean retrieveFromCache) { 1294 return getPersistence() 1295 .findByF_S(fileEntryId, status, start, end, 1296 orderByComparator, retrieveFromCache); 1297 } 1298 1299 /** 1300 * Returns the first document library file version in the ordered set where fileEntryId = ? and status = ?. 1301 * 1302 * @param fileEntryId the file entry ID 1303 * @param status the status 1304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1305 * @return the first matching document library file version 1306 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1307 */ 1308 public static DLFileVersion findByF_S_First(long fileEntryId, int status, 1309 OrderByComparator<DLFileVersion> orderByComparator) 1310 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1311 return getPersistence() 1312 .findByF_S_First(fileEntryId, status, orderByComparator); 1313 } 1314 1315 /** 1316 * Returns the first document library file version in the ordered set where fileEntryId = ? and status = ?. 1317 * 1318 * @param fileEntryId the file entry ID 1319 * @param status the status 1320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1321 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1322 */ 1323 public static DLFileVersion fetchByF_S_First(long fileEntryId, int status, 1324 OrderByComparator<DLFileVersion> orderByComparator) { 1325 return getPersistence() 1326 .fetchByF_S_First(fileEntryId, status, orderByComparator); 1327 } 1328 1329 /** 1330 * Returns the last document library file version in the ordered set where fileEntryId = ? and status = ?. 1331 * 1332 * @param fileEntryId the file entry ID 1333 * @param status the status 1334 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1335 * @return the last matching document library file version 1336 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1337 */ 1338 public static DLFileVersion findByF_S_Last(long fileEntryId, int status, 1339 OrderByComparator<DLFileVersion> orderByComparator) 1340 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1341 return getPersistence() 1342 .findByF_S_Last(fileEntryId, status, orderByComparator); 1343 } 1344 1345 /** 1346 * Returns the last document library file version in the ordered set where fileEntryId = ? and status = ?. 1347 * 1348 * @param fileEntryId the file entry ID 1349 * @param status the status 1350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1351 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1352 */ 1353 public static DLFileVersion fetchByF_S_Last(long fileEntryId, int status, 1354 OrderByComparator<DLFileVersion> orderByComparator) { 1355 return getPersistence() 1356 .fetchByF_S_Last(fileEntryId, status, orderByComparator); 1357 } 1358 1359 /** 1360 * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = ? and status = ?. 1361 * 1362 * @param fileVersionId the primary key of the current document library file version 1363 * @param fileEntryId the file entry ID 1364 * @param status the status 1365 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1366 * @return the previous, current, and next document library file version 1367 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1368 */ 1369 public static DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId, 1370 long fileEntryId, int status, 1371 OrderByComparator<DLFileVersion> orderByComparator) 1372 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1373 return getPersistence() 1374 .findByF_S_PrevAndNext(fileVersionId, fileEntryId, status, 1375 orderByComparator); 1376 } 1377 1378 /** 1379 * Removes all the document library file versions where fileEntryId = ? and status = ? from the database. 1380 * 1381 * @param fileEntryId the file entry ID 1382 * @param status the status 1383 */ 1384 public static void removeByF_S(long fileEntryId, int status) { 1385 getPersistence().removeByF_S(fileEntryId, status); 1386 } 1387 1388 /** 1389 * Returns the number of document library file versions where fileEntryId = ? and status = ?. 1390 * 1391 * @param fileEntryId the file entry ID 1392 * @param status the status 1393 * @return the number of matching document library file versions 1394 */ 1395 public static int countByF_S(long fileEntryId, int status) { 1396 return getPersistence().countByF_S(fileEntryId, status); 1397 } 1398 1399 /** 1400 * Returns all the document library file versions where groupId = ? and folderId = ? and status = ?. 1401 * 1402 * @param groupId the group ID 1403 * @param folderId the folder ID 1404 * @param status the status 1405 * @return the matching document library file versions 1406 */ 1407 public static List<DLFileVersion> findByG_F_S(long groupId, long folderId, 1408 int status) { 1409 return getPersistence().findByG_F_S(groupId, folderId, status); 1410 } 1411 1412 /** 1413 * Returns a range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1414 * 1415 * <p> 1416 * 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 DLFileVersionModelImpl}. 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. 1417 * </p> 1418 * 1419 * @param groupId the group ID 1420 * @param folderId the folder ID 1421 * @param status the status 1422 * @param start the lower bound of the range of document library file versions 1423 * @param end the upper bound of the range of document library file versions (not inclusive) 1424 * @return the range of matching document library file versions 1425 */ 1426 public static List<DLFileVersion> findByG_F_S(long groupId, long folderId, 1427 int status, int start, int end) { 1428 return getPersistence() 1429 .findByG_F_S(groupId, folderId, status, start, end); 1430 } 1431 1432 /** 1433 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1434 * 1435 * <p> 1436 * 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 DLFileVersionModelImpl}. 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. 1437 * </p> 1438 * 1439 * @param groupId the group ID 1440 * @param folderId the folder ID 1441 * @param status the status 1442 * @param start the lower bound of the range of document library file versions 1443 * @param end the upper bound of the range of document library file versions (not inclusive) 1444 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1445 * @return the ordered range of matching document library file versions 1446 */ 1447 public static List<DLFileVersion> findByG_F_S(long groupId, long folderId, 1448 int status, int start, int end, 1449 OrderByComparator<DLFileVersion> orderByComparator) { 1450 return getPersistence() 1451 .findByG_F_S(groupId, folderId, status, start, end, 1452 orderByComparator); 1453 } 1454 1455 /** 1456 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1457 * 1458 * <p> 1459 * 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 DLFileVersionModelImpl}. 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. 1460 * </p> 1461 * 1462 * @param groupId the group ID 1463 * @param folderId the folder ID 1464 * @param status the status 1465 * @param start the lower bound of the range of document library file versions 1466 * @param end the upper bound of the range of document library file versions (not inclusive) 1467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1468 * @param retrieveFromCache whether to retrieve from the finder cache 1469 * @return the ordered range of matching document library file versions 1470 */ 1471 public static List<DLFileVersion> findByG_F_S(long groupId, long folderId, 1472 int status, int start, int end, 1473 OrderByComparator<DLFileVersion> orderByComparator, 1474 boolean retrieveFromCache) { 1475 return getPersistence() 1476 .findByG_F_S(groupId, folderId, status, start, end, 1477 orderByComparator, retrieveFromCache); 1478 } 1479 1480 /** 1481 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1482 * 1483 * @param groupId the group ID 1484 * @param folderId the folder ID 1485 * @param status the status 1486 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1487 * @return the first matching document library file version 1488 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1489 */ 1490 public static DLFileVersion findByG_F_S_First(long groupId, long folderId, 1491 int status, OrderByComparator<DLFileVersion> orderByComparator) 1492 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1493 return getPersistence() 1494 .findByG_F_S_First(groupId, folderId, status, 1495 orderByComparator); 1496 } 1497 1498 /** 1499 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1500 * 1501 * @param groupId the group ID 1502 * @param folderId the folder ID 1503 * @param status the status 1504 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1505 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1506 */ 1507 public static DLFileVersion fetchByG_F_S_First(long groupId, long folderId, 1508 int status, OrderByComparator<DLFileVersion> orderByComparator) { 1509 return getPersistence() 1510 .fetchByG_F_S_First(groupId, folderId, status, 1511 orderByComparator); 1512 } 1513 1514 /** 1515 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1516 * 1517 * @param groupId the group ID 1518 * @param folderId the folder ID 1519 * @param status the status 1520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1521 * @return the last matching document library file version 1522 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1523 */ 1524 public static DLFileVersion findByG_F_S_Last(long groupId, long folderId, 1525 int status, OrderByComparator<DLFileVersion> orderByComparator) 1526 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1527 return getPersistence() 1528 .findByG_F_S_Last(groupId, folderId, status, 1529 orderByComparator); 1530 } 1531 1532 /** 1533 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1534 * 1535 * @param groupId the group ID 1536 * @param folderId the folder ID 1537 * @param status the status 1538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1539 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1540 */ 1541 public static DLFileVersion fetchByG_F_S_Last(long groupId, long folderId, 1542 int status, OrderByComparator<DLFileVersion> orderByComparator) { 1543 return getPersistence() 1544 .fetchByG_F_S_Last(groupId, folderId, status, 1545 orderByComparator); 1546 } 1547 1548 /** 1549 * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1550 * 1551 * @param fileVersionId the primary key of the current document library file version 1552 * @param groupId the group ID 1553 * @param folderId the folder ID 1554 * @param status the status 1555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1556 * @return the previous, current, and next document library file version 1557 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1558 */ 1559 public static DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId, 1560 long groupId, long folderId, int status, 1561 OrderByComparator<DLFileVersion> orderByComparator) 1562 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1563 return getPersistence() 1564 .findByG_F_S_PrevAndNext(fileVersionId, groupId, folderId, 1565 status, orderByComparator); 1566 } 1567 1568 /** 1569 * Removes all the document library file versions where groupId = ? and folderId = ? and status = ? from the database. 1570 * 1571 * @param groupId the group ID 1572 * @param folderId the folder ID 1573 * @param status the status 1574 */ 1575 public static void removeByG_F_S(long groupId, long folderId, int status) { 1576 getPersistence().removeByG_F_S(groupId, folderId, status); 1577 } 1578 1579 /** 1580 * Returns the number of document library file versions where groupId = ? and folderId = ? and status = ?. 1581 * 1582 * @param groupId the group ID 1583 * @param folderId the folder ID 1584 * @param status the status 1585 * @return the number of matching document library file versions 1586 */ 1587 public static int countByG_F_S(long groupId, long folderId, int status) { 1588 return getPersistence().countByG_F_S(groupId, folderId, status); 1589 } 1590 1591 /** 1592 * Returns all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1593 * 1594 * @param groupId the group ID 1595 * @param folderId the folder ID 1596 * @param title the title 1597 * @param version the version 1598 * @return the matching document library file versions 1599 */ 1600 public static List<DLFileVersion> findByG_F_T_V(long groupId, 1601 long folderId, java.lang.String title, java.lang.String version) { 1602 return getPersistence().findByG_F_T_V(groupId, folderId, title, version); 1603 } 1604 1605 /** 1606 * Returns a range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1607 * 1608 * <p> 1609 * 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 DLFileVersionModelImpl}. 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. 1610 * </p> 1611 * 1612 * @param groupId the group ID 1613 * @param folderId the folder ID 1614 * @param title the title 1615 * @param version the version 1616 * @param start the lower bound of the range of document library file versions 1617 * @param end the upper bound of the range of document library file versions (not inclusive) 1618 * @return the range of matching document library file versions 1619 */ 1620 public static List<DLFileVersion> findByG_F_T_V(long groupId, 1621 long folderId, java.lang.String title, java.lang.String version, 1622 int start, int end) { 1623 return getPersistence() 1624 .findByG_F_T_V(groupId, folderId, title, version, start, end); 1625 } 1626 1627 /** 1628 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1629 * 1630 * <p> 1631 * 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 DLFileVersionModelImpl}. 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. 1632 * </p> 1633 * 1634 * @param groupId the group ID 1635 * @param folderId the folder ID 1636 * @param title the title 1637 * @param version the version 1638 * @param start the lower bound of the range of document library file versions 1639 * @param end the upper bound of the range of document library file versions (not inclusive) 1640 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1641 * @return the ordered range of matching document library file versions 1642 */ 1643 public static List<DLFileVersion> findByG_F_T_V(long groupId, 1644 long folderId, java.lang.String title, java.lang.String version, 1645 int start, int end, OrderByComparator<DLFileVersion> orderByComparator) { 1646 return getPersistence() 1647 .findByG_F_T_V(groupId, folderId, title, version, start, 1648 end, orderByComparator); 1649 } 1650 1651 /** 1652 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1653 * 1654 * <p> 1655 * 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 DLFileVersionModelImpl}. 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. 1656 * </p> 1657 * 1658 * @param groupId the group ID 1659 * @param folderId the folder ID 1660 * @param title the title 1661 * @param version the version 1662 * @param start the lower bound of the range of document library file versions 1663 * @param end the upper bound of the range of document library file versions (not inclusive) 1664 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1665 * @param retrieveFromCache whether to retrieve from the finder cache 1666 * @return the ordered range of matching document library file versions 1667 */ 1668 public static List<DLFileVersion> findByG_F_T_V(long groupId, 1669 long folderId, java.lang.String title, java.lang.String version, 1670 int start, int end, OrderByComparator<DLFileVersion> orderByComparator, 1671 boolean retrieveFromCache) { 1672 return getPersistence() 1673 .findByG_F_T_V(groupId, folderId, title, version, start, 1674 end, orderByComparator, retrieveFromCache); 1675 } 1676 1677 /** 1678 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1679 * 1680 * @param groupId the group ID 1681 * @param folderId the folder ID 1682 * @param title the title 1683 * @param version the version 1684 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1685 * @return the first matching document library file version 1686 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1687 */ 1688 public static DLFileVersion findByG_F_T_V_First(long groupId, 1689 long folderId, java.lang.String title, java.lang.String version, 1690 OrderByComparator<DLFileVersion> orderByComparator) 1691 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1692 return getPersistence() 1693 .findByG_F_T_V_First(groupId, folderId, title, version, 1694 orderByComparator); 1695 } 1696 1697 /** 1698 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1699 * 1700 * @param groupId the group ID 1701 * @param folderId the folder ID 1702 * @param title the title 1703 * @param version the version 1704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1705 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1706 */ 1707 public static DLFileVersion fetchByG_F_T_V_First(long groupId, 1708 long folderId, java.lang.String title, java.lang.String version, 1709 OrderByComparator<DLFileVersion> orderByComparator) { 1710 return getPersistence() 1711 .fetchByG_F_T_V_First(groupId, folderId, title, version, 1712 orderByComparator); 1713 } 1714 1715 /** 1716 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1717 * 1718 * @param groupId the group ID 1719 * @param folderId the folder ID 1720 * @param title the title 1721 * @param version the version 1722 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1723 * @return the last matching document library file version 1724 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1725 */ 1726 public static DLFileVersion findByG_F_T_V_Last(long groupId, long folderId, 1727 java.lang.String title, java.lang.String version, 1728 OrderByComparator<DLFileVersion> orderByComparator) 1729 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1730 return getPersistence() 1731 .findByG_F_T_V_Last(groupId, folderId, title, version, 1732 orderByComparator); 1733 } 1734 1735 /** 1736 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1737 * 1738 * @param groupId the group ID 1739 * @param folderId the folder ID 1740 * @param title the title 1741 * @param version the version 1742 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1743 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1744 */ 1745 public static DLFileVersion fetchByG_F_T_V_Last(long groupId, 1746 long folderId, java.lang.String title, java.lang.String version, 1747 OrderByComparator<DLFileVersion> orderByComparator) { 1748 return getPersistence() 1749 .fetchByG_F_T_V_Last(groupId, folderId, title, version, 1750 orderByComparator); 1751 } 1752 1753 /** 1754 * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1755 * 1756 * @param fileVersionId the primary key of the current document library file version 1757 * @param groupId the group ID 1758 * @param folderId the folder ID 1759 * @param title the title 1760 * @param version the version 1761 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1762 * @return the previous, current, and next document library file version 1763 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1764 */ 1765 public static DLFileVersion[] findByG_F_T_V_PrevAndNext( 1766 long fileVersionId, long groupId, long folderId, 1767 java.lang.String title, java.lang.String version, 1768 OrderByComparator<DLFileVersion> orderByComparator) 1769 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1770 return getPersistence() 1771 .findByG_F_T_V_PrevAndNext(fileVersionId, groupId, folderId, 1772 title, version, orderByComparator); 1773 } 1774 1775 /** 1776 * Removes all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ? from the database. 1777 * 1778 * @param groupId the group ID 1779 * @param folderId the folder ID 1780 * @param title the title 1781 * @param version the version 1782 */ 1783 public static void removeByG_F_T_V(long groupId, long folderId, 1784 java.lang.String title, java.lang.String version) { 1785 getPersistence().removeByG_F_T_V(groupId, folderId, title, version); 1786 } 1787 1788 /** 1789 * Returns the number of document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1790 * 1791 * @param groupId the group ID 1792 * @param folderId the folder ID 1793 * @param title the title 1794 * @param version the version 1795 * @return the number of matching document library file versions 1796 */ 1797 public static int countByG_F_T_V(long groupId, long folderId, 1798 java.lang.String title, java.lang.String version) { 1799 return getPersistence().countByG_F_T_V(groupId, folderId, title, version); 1800 } 1801 1802 /** 1803 * Caches the document library file version in the entity cache if it is enabled. 1804 * 1805 * @param dlFileVersion the document library file version 1806 */ 1807 public static void cacheResult(DLFileVersion dlFileVersion) { 1808 getPersistence().cacheResult(dlFileVersion); 1809 } 1810 1811 /** 1812 * Caches the document library file versions in the entity cache if it is enabled. 1813 * 1814 * @param dlFileVersions the document library file versions 1815 */ 1816 public static void cacheResult(List<DLFileVersion> dlFileVersions) { 1817 getPersistence().cacheResult(dlFileVersions); 1818 } 1819 1820 /** 1821 * Creates a new document library file version with the primary key. Does not add the document library file version to the database. 1822 * 1823 * @param fileVersionId the primary key for the new document library file version 1824 * @return the new document library file version 1825 */ 1826 public static DLFileVersion create(long fileVersionId) { 1827 return getPersistence().create(fileVersionId); 1828 } 1829 1830 /** 1831 * Removes the document library file version with the primary key from the database. Also notifies the appropriate model listeners. 1832 * 1833 * @param fileVersionId the primary key of the document library file version 1834 * @return the document library file version that was removed 1835 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1836 */ 1837 public static DLFileVersion remove(long fileVersionId) 1838 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1839 return getPersistence().remove(fileVersionId); 1840 } 1841 1842 public static DLFileVersion updateImpl(DLFileVersion dlFileVersion) { 1843 return getPersistence().updateImpl(dlFileVersion); 1844 } 1845 1846 /** 1847 * Returns the document library file version with the primary key or throws a {@link NoSuchFileVersionException} if it could not be found. 1848 * 1849 * @param fileVersionId the primary key of the document library file version 1850 * @return the document library file version 1851 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1852 */ 1853 public static DLFileVersion findByPrimaryKey(long fileVersionId) 1854 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException { 1855 return getPersistence().findByPrimaryKey(fileVersionId); 1856 } 1857 1858 /** 1859 * Returns the document library file version with the primary key or returns <code>null</code> if it could not be found. 1860 * 1861 * @param fileVersionId the primary key of the document library file version 1862 * @return the document library file version, or <code>null</code> if a document library file version with the primary key could not be found 1863 */ 1864 public static DLFileVersion fetchByPrimaryKey(long fileVersionId) { 1865 return getPersistence().fetchByPrimaryKey(fileVersionId); 1866 } 1867 1868 public static java.util.Map<java.io.Serializable, DLFileVersion> fetchByPrimaryKeys( 1869 java.util.Set<java.io.Serializable> primaryKeys) { 1870 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1871 } 1872 1873 /** 1874 * Returns all the document library file versions. 1875 * 1876 * @return the document library file versions 1877 */ 1878 public static List<DLFileVersion> findAll() { 1879 return getPersistence().findAll(); 1880 } 1881 1882 /** 1883 * Returns a range of all the document library file versions. 1884 * 1885 * <p> 1886 * 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 DLFileVersionModelImpl}. 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. 1887 * </p> 1888 * 1889 * @param start the lower bound of the range of document library file versions 1890 * @param end the upper bound of the range of document library file versions (not inclusive) 1891 * @return the range of document library file versions 1892 */ 1893 public static List<DLFileVersion> findAll(int start, int end) { 1894 return getPersistence().findAll(start, end); 1895 } 1896 1897 /** 1898 * Returns an ordered range of all the document library file versions. 1899 * 1900 * <p> 1901 * 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 DLFileVersionModelImpl}. 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. 1902 * </p> 1903 * 1904 * @param start the lower bound of the range of document library file versions 1905 * @param end the upper bound of the range of document library file versions (not inclusive) 1906 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1907 * @return the ordered range of document library file versions 1908 */ 1909 public static List<DLFileVersion> findAll(int start, int end, 1910 OrderByComparator<DLFileVersion> orderByComparator) { 1911 return getPersistence().findAll(start, end, orderByComparator); 1912 } 1913 1914 /** 1915 * Returns an ordered range of all the document library file versions. 1916 * 1917 * <p> 1918 * 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 DLFileVersionModelImpl}. 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. 1919 * </p> 1920 * 1921 * @param start the lower bound of the range of document library file versions 1922 * @param end the upper bound of the range of document library file versions (not inclusive) 1923 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1924 * @param retrieveFromCache whether to retrieve from the finder cache 1925 * @return the ordered range of document library file versions 1926 */ 1927 public static List<DLFileVersion> findAll(int start, int end, 1928 OrderByComparator<DLFileVersion> orderByComparator, 1929 boolean retrieveFromCache) { 1930 return getPersistence() 1931 .findAll(start, end, orderByComparator, retrieveFromCache); 1932 } 1933 1934 /** 1935 * Removes all the document library file versions from the database. 1936 */ 1937 public static void removeAll() { 1938 getPersistence().removeAll(); 1939 } 1940 1941 /** 1942 * Returns the number of document library file versions. 1943 * 1944 * @return the number of document library file versions 1945 */ 1946 public static int countAll() { 1947 return getPersistence().countAll(); 1948 } 1949 1950 public static java.util.Set<java.lang.String> getBadColumnNames() { 1951 return getPersistence().getBadColumnNames(); 1952 } 1953 1954 public static DLFileVersionPersistence getPersistence() { 1955 if (_persistence == null) { 1956 _persistence = (DLFileVersionPersistence)PortalBeanLocatorUtil.locate(DLFileVersionPersistence.class.getName()); 1957 1958 ReferenceRegistry.registerReference(DLFileVersionUtil.class, 1959 "_persistence"); 1960 } 1961 1962 return _persistence; 1963 } 1964 1965 private static DLFileVersionPersistence _persistence; 1966 }