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