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.DLFileRank; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the document library file rank service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileRankPersistenceImpl} 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 DLFileRankPersistence 038 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileRankPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DLFileRankUtil { 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(DLFileRank dlFileRank) { 060 getPersistence().clearCache(dlFileRank); 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<DLFileRank> 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<DLFileRank> 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<DLFileRank> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<DLFileRank> 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 DLFileRank update(DLFileRank dlFileRank) { 101 return getPersistence().update(dlFileRank); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static DLFileRank update(DLFileRank dlFileRank, 108 ServiceContext serviceContext) { 109 return getPersistence().update(dlFileRank, serviceContext); 110 } 111 112 /** 113 * Returns all the document library file ranks where userId = ?. 114 * 115 * @param userId the user ID 116 * @return the matching document library file ranks 117 */ 118 public static List<DLFileRank> findByUserId(long userId) { 119 return getPersistence().findByUserId(userId); 120 } 121 122 /** 123 * Returns a range of all the document library file ranks where userId = ?. 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 DLFileRankModelImpl}. 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 userId the user ID 130 * @param start the lower bound of the range of document library file ranks 131 * @param end the upper bound of the range of document library file ranks (not inclusive) 132 * @return the range of matching document library file ranks 133 */ 134 public static List<DLFileRank> findByUserId(long userId, int start, int end) { 135 return getPersistence().findByUserId(userId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the document library file ranks where userId = ?. 140 * 141 * <p> 142 * 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 DLFileRankModelImpl}. 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. 143 * </p> 144 * 145 * @param userId the user ID 146 * @param start the lower bound of the range of document library file ranks 147 * @param end the upper bound of the range of document library file ranks (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching document library file ranks 150 */ 151 public static List<DLFileRank> findByUserId(long userId, int start, 152 int end, OrderByComparator<DLFileRank> orderByComparator) { 153 return getPersistence() 154 .findByUserId(userId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the document library file ranks where userId = ?. 159 * 160 * <p> 161 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileRankModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 162 * </p> 163 * 164 * @param userId the user ID 165 * @param start the lower bound of the range of document library file ranks 166 * @param end the upper bound of the range of document library file ranks (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching document library file ranks 170 */ 171 public static List<DLFileRank> findByUserId(long userId, int start, 172 int end, OrderByComparator<DLFileRank> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUserId(userId, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first document library file rank in the ordered set where userId = ?. 181 * 182 * @param userId the user ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching document library file rank 185 * @throws NoSuchFileRankException if a matching document library file rank could not be found 186 */ 187 public static DLFileRank findByUserId_First(long userId, 188 OrderByComparator<DLFileRank> orderByComparator) 189 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 190 return getPersistence().findByUserId_First(userId, orderByComparator); 191 } 192 193 /** 194 * Returns the first document library file rank in the ordered set where userId = ?. 195 * 196 * @param userId the user ID 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 199 */ 200 public static DLFileRank fetchByUserId_First(long userId, 201 OrderByComparator<DLFileRank> orderByComparator) { 202 return getPersistence().fetchByUserId_First(userId, orderByComparator); 203 } 204 205 /** 206 * Returns the last document library file rank in the ordered set where userId = ?. 207 * 208 * @param userId the user ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching document library file rank 211 * @throws NoSuchFileRankException if a matching document library file rank could not be found 212 */ 213 public static DLFileRank findByUserId_Last(long userId, 214 OrderByComparator<DLFileRank> orderByComparator) 215 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 216 return getPersistence().findByUserId_Last(userId, orderByComparator); 217 } 218 219 /** 220 * Returns the last document library file rank in the ordered set where userId = ?. 221 * 222 * @param userId the user ID 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 225 */ 226 public static DLFileRank fetchByUserId_Last(long userId, 227 OrderByComparator<DLFileRank> orderByComparator) { 228 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 229 } 230 231 /** 232 * Returns the document library file ranks before and after the current document library file rank in the ordered set where userId = ?. 233 * 234 * @param fileRankId the primary key of the current document library file rank 235 * @param userId the user ID 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next document library file rank 238 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 239 */ 240 public static DLFileRank[] findByUserId_PrevAndNext(long fileRankId, 241 long userId, OrderByComparator<DLFileRank> orderByComparator) 242 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 243 return getPersistence() 244 .findByUserId_PrevAndNext(fileRankId, userId, 245 orderByComparator); 246 } 247 248 /** 249 * Removes all the document library file ranks where userId = ? from the database. 250 * 251 * @param userId the user ID 252 */ 253 public static void removeByUserId(long userId) { 254 getPersistence().removeByUserId(userId); 255 } 256 257 /** 258 * Returns the number of document library file ranks where userId = ?. 259 * 260 * @param userId the user ID 261 * @return the number of matching document library file ranks 262 */ 263 public static int countByUserId(long userId) { 264 return getPersistence().countByUserId(userId); 265 } 266 267 /** 268 * Returns all the document library file ranks where fileEntryId = ?. 269 * 270 * @param fileEntryId the file entry ID 271 * @return the matching document library file ranks 272 */ 273 public static List<DLFileRank> findByFileEntryId(long fileEntryId) { 274 return getPersistence().findByFileEntryId(fileEntryId); 275 } 276 277 /** 278 * Returns a range of all the document library file ranks where fileEntryId = ?. 279 * 280 * <p> 281 * 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 DLFileRankModelImpl}. 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. 282 * </p> 283 * 284 * @param fileEntryId the file entry ID 285 * @param start the lower bound of the range of document library file ranks 286 * @param end the upper bound of the range of document library file ranks (not inclusive) 287 * @return the range of matching document library file ranks 288 */ 289 public static List<DLFileRank> findByFileEntryId(long fileEntryId, 290 int start, int end) { 291 return getPersistence().findByFileEntryId(fileEntryId, start, end); 292 } 293 294 /** 295 * Returns an ordered range of all the document library file ranks where fileEntryId = ?. 296 * 297 * <p> 298 * 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 DLFileRankModelImpl}. 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. 299 * </p> 300 * 301 * @param fileEntryId the file entry ID 302 * @param start the lower bound of the range of document library file ranks 303 * @param end the upper bound of the range of document library file ranks (not inclusive) 304 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 305 * @return the ordered range of matching document library file ranks 306 */ 307 public static List<DLFileRank> findByFileEntryId(long fileEntryId, 308 int start, int end, OrderByComparator<DLFileRank> orderByComparator) { 309 return getPersistence() 310 .findByFileEntryId(fileEntryId, start, end, orderByComparator); 311 } 312 313 /** 314 * Returns an ordered range of all the document library file ranks where fileEntryId = ?. 315 * 316 * <p> 317 * 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 DLFileRankModelImpl}. 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. 318 * </p> 319 * 320 * @param fileEntryId the file entry ID 321 * @param start the lower bound of the range of document library file ranks 322 * @param end the upper bound of the range of document library file ranks (not inclusive) 323 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 324 * @param retrieveFromCache whether to retrieve from the finder cache 325 * @return the ordered range of matching document library file ranks 326 */ 327 public static List<DLFileRank> findByFileEntryId(long fileEntryId, 328 int start, int end, OrderByComparator<DLFileRank> orderByComparator, 329 boolean retrieveFromCache) { 330 return getPersistence() 331 .findByFileEntryId(fileEntryId, start, end, 332 orderByComparator, retrieveFromCache); 333 } 334 335 /** 336 * Returns the first document library file rank in the ordered set where fileEntryId = ?. 337 * 338 * @param fileEntryId the file entry ID 339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 340 * @return the first matching document library file rank 341 * @throws NoSuchFileRankException if a matching document library file rank could not be found 342 */ 343 public static DLFileRank findByFileEntryId_First(long fileEntryId, 344 OrderByComparator<DLFileRank> orderByComparator) 345 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 346 return getPersistence() 347 .findByFileEntryId_First(fileEntryId, orderByComparator); 348 } 349 350 /** 351 * Returns the first document library file rank in the ordered set where fileEntryId = ?. 352 * 353 * @param fileEntryId the file entry ID 354 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 355 * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 356 */ 357 public static DLFileRank fetchByFileEntryId_First(long fileEntryId, 358 OrderByComparator<DLFileRank> orderByComparator) { 359 return getPersistence() 360 .fetchByFileEntryId_First(fileEntryId, orderByComparator); 361 } 362 363 /** 364 * Returns the last document library file rank in the ordered set where fileEntryId = ?. 365 * 366 * @param fileEntryId the file entry ID 367 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 368 * @return the last matching document library file rank 369 * @throws NoSuchFileRankException if a matching document library file rank could not be found 370 */ 371 public static DLFileRank findByFileEntryId_Last(long fileEntryId, 372 OrderByComparator<DLFileRank> orderByComparator) 373 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 374 return getPersistence() 375 .findByFileEntryId_Last(fileEntryId, orderByComparator); 376 } 377 378 /** 379 * Returns the last document library file rank in the ordered set where fileEntryId = ?. 380 * 381 * @param fileEntryId the file entry ID 382 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 383 * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 384 */ 385 public static DLFileRank fetchByFileEntryId_Last(long fileEntryId, 386 OrderByComparator<DLFileRank> orderByComparator) { 387 return getPersistence() 388 .fetchByFileEntryId_Last(fileEntryId, orderByComparator); 389 } 390 391 /** 392 * Returns the document library file ranks before and after the current document library file rank in the ordered set where fileEntryId = ?. 393 * 394 * @param fileRankId the primary key of the current document library file rank 395 * @param fileEntryId the file entry ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the previous, current, and next document library file rank 398 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 399 */ 400 public static DLFileRank[] findByFileEntryId_PrevAndNext(long fileRankId, 401 long fileEntryId, OrderByComparator<DLFileRank> orderByComparator) 402 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 403 return getPersistence() 404 .findByFileEntryId_PrevAndNext(fileRankId, fileEntryId, 405 orderByComparator); 406 } 407 408 /** 409 * Removes all the document library file ranks where fileEntryId = ? from the database. 410 * 411 * @param fileEntryId the file entry ID 412 */ 413 public static void removeByFileEntryId(long fileEntryId) { 414 getPersistence().removeByFileEntryId(fileEntryId); 415 } 416 417 /** 418 * Returns the number of document library file ranks where fileEntryId = ?. 419 * 420 * @param fileEntryId the file entry ID 421 * @return the number of matching document library file ranks 422 */ 423 public static int countByFileEntryId(long fileEntryId) { 424 return getPersistence().countByFileEntryId(fileEntryId); 425 } 426 427 /** 428 * Returns all the document library file ranks where groupId = ? and userId = ?. 429 * 430 * @param groupId the group ID 431 * @param userId the user ID 432 * @return the matching document library file ranks 433 */ 434 public static List<DLFileRank> findByG_U(long groupId, long userId) { 435 return getPersistence().findByG_U(groupId, userId); 436 } 437 438 /** 439 * Returns a range of all the document library file ranks where groupId = ? and userId = ?. 440 * 441 * <p> 442 * 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 DLFileRankModelImpl}. 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. 443 * </p> 444 * 445 * @param groupId the group ID 446 * @param userId the user ID 447 * @param start the lower bound of the range of document library file ranks 448 * @param end the upper bound of the range of document library file ranks (not inclusive) 449 * @return the range of matching document library file ranks 450 */ 451 public static List<DLFileRank> findByG_U(long groupId, long userId, 452 int start, int end) { 453 return getPersistence().findByG_U(groupId, userId, start, end); 454 } 455 456 /** 457 * Returns an ordered range of all the document library file ranks where groupId = ? and userId = ?. 458 * 459 * <p> 460 * 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 DLFileRankModelImpl}. 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. 461 * </p> 462 * 463 * @param groupId the group ID 464 * @param userId the user ID 465 * @param start the lower bound of the range of document library file ranks 466 * @param end the upper bound of the range of document library file ranks (not inclusive) 467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 468 * @return the ordered range of matching document library file ranks 469 */ 470 public static List<DLFileRank> findByG_U(long groupId, long userId, 471 int start, int end, OrderByComparator<DLFileRank> orderByComparator) { 472 return getPersistence() 473 .findByG_U(groupId, userId, start, end, orderByComparator); 474 } 475 476 /** 477 * Returns an ordered range of all the document library file ranks where groupId = ? and userId = ?. 478 * 479 * <p> 480 * 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 DLFileRankModelImpl}. 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. 481 * </p> 482 * 483 * @param groupId the group ID 484 * @param userId the user ID 485 * @param start the lower bound of the range of document library file ranks 486 * @param end the upper bound of the range of document library file ranks (not inclusive) 487 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 488 * @param retrieveFromCache whether to retrieve from the finder cache 489 * @return the ordered range of matching document library file ranks 490 */ 491 public static List<DLFileRank> findByG_U(long groupId, long userId, 492 int start, int end, OrderByComparator<DLFileRank> orderByComparator, 493 boolean retrieveFromCache) { 494 return getPersistence() 495 .findByG_U(groupId, userId, start, end, orderByComparator, 496 retrieveFromCache); 497 } 498 499 /** 500 * Returns the first document library file rank in the ordered set where groupId = ? and userId = ?. 501 * 502 * @param groupId the group ID 503 * @param userId the user ID 504 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 505 * @return the first matching document library file rank 506 * @throws NoSuchFileRankException if a matching document library file rank could not be found 507 */ 508 public static DLFileRank findByG_U_First(long groupId, long userId, 509 OrderByComparator<DLFileRank> orderByComparator) 510 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 511 return getPersistence() 512 .findByG_U_First(groupId, userId, orderByComparator); 513 } 514 515 /** 516 * Returns the first document library file rank in the ordered set where groupId = ? and userId = ?. 517 * 518 * @param groupId the group ID 519 * @param userId the user ID 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 522 */ 523 public static DLFileRank fetchByG_U_First(long groupId, long userId, 524 OrderByComparator<DLFileRank> orderByComparator) { 525 return getPersistence() 526 .fetchByG_U_First(groupId, userId, orderByComparator); 527 } 528 529 /** 530 * Returns the last document library file rank in the ordered set where groupId = ? and userId = ?. 531 * 532 * @param groupId the group ID 533 * @param userId the user ID 534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 535 * @return the last matching document library file rank 536 * @throws NoSuchFileRankException if a matching document library file rank could not be found 537 */ 538 public static DLFileRank findByG_U_Last(long groupId, long userId, 539 OrderByComparator<DLFileRank> orderByComparator) 540 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 541 return getPersistence() 542 .findByG_U_Last(groupId, userId, orderByComparator); 543 } 544 545 /** 546 * Returns the last document library file rank in the ordered set where groupId = ? and userId = ?. 547 * 548 * @param groupId the group ID 549 * @param userId the user ID 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 552 */ 553 public static DLFileRank fetchByG_U_Last(long groupId, long userId, 554 OrderByComparator<DLFileRank> orderByComparator) { 555 return getPersistence() 556 .fetchByG_U_Last(groupId, userId, orderByComparator); 557 } 558 559 /** 560 * Returns the document library file ranks before and after the current document library file rank in the ordered set where groupId = ? and userId = ?. 561 * 562 * @param fileRankId the primary key of the current document library file rank 563 * @param groupId the group ID 564 * @param userId the user ID 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the previous, current, and next document library file rank 567 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 568 */ 569 public static DLFileRank[] findByG_U_PrevAndNext(long fileRankId, 570 long groupId, long userId, 571 OrderByComparator<DLFileRank> orderByComparator) 572 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 573 return getPersistence() 574 .findByG_U_PrevAndNext(fileRankId, groupId, userId, 575 orderByComparator); 576 } 577 578 /** 579 * Removes all the document library file ranks where groupId = ? and userId = ? from the database. 580 * 581 * @param groupId the group ID 582 * @param userId the user ID 583 */ 584 public static void removeByG_U(long groupId, long userId) { 585 getPersistence().removeByG_U(groupId, userId); 586 } 587 588 /** 589 * Returns the number of document library file ranks where groupId = ? and userId = ?. 590 * 591 * @param groupId the group ID 592 * @param userId the user ID 593 * @return the number of matching document library file ranks 594 */ 595 public static int countByG_U(long groupId, long userId) { 596 return getPersistence().countByG_U(groupId, userId); 597 } 598 599 /** 600 * Returns all the document library file ranks where groupId = ? and userId = ? and active = ?. 601 * 602 * @param groupId the group ID 603 * @param userId the user ID 604 * @param active the active 605 * @return the matching document library file ranks 606 */ 607 public static List<DLFileRank> findByG_U_A(long groupId, long userId, 608 boolean active) { 609 return getPersistence().findByG_U_A(groupId, userId, active); 610 } 611 612 /** 613 * Returns a range of all the document library file ranks where groupId = ? and userId = ? and active = ?. 614 * 615 * <p> 616 * 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 DLFileRankModelImpl}. 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. 617 * </p> 618 * 619 * @param groupId the group ID 620 * @param userId the user ID 621 * @param active the active 622 * @param start the lower bound of the range of document library file ranks 623 * @param end the upper bound of the range of document library file ranks (not inclusive) 624 * @return the range of matching document library file ranks 625 */ 626 public static List<DLFileRank> findByG_U_A(long groupId, long userId, 627 boolean active, int start, int end) { 628 return getPersistence().findByG_U_A(groupId, userId, active, start, end); 629 } 630 631 /** 632 * Returns an ordered range of all the document library file ranks where groupId = ? and userId = ? and active = ?. 633 * 634 * <p> 635 * 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 DLFileRankModelImpl}. 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. 636 * </p> 637 * 638 * @param groupId the group ID 639 * @param userId the user ID 640 * @param active the active 641 * @param start the lower bound of the range of document library file ranks 642 * @param end the upper bound of the range of document library file ranks (not inclusive) 643 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 644 * @return the ordered range of matching document library file ranks 645 */ 646 public static List<DLFileRank> findByG_U_A(long groupId, long userId, 647 boolean active, int start, int end, 648 OrderByComparator<DLFileRank> orderByComparator) { 649 return getPersistence() 650 .findByG_U_A(groupId, userId, active, start, end, 651 orderByComparator); 652 } 653 654 /** 655 * Returns an ordered range of all the document library file ranks where groupId = ? and userId = ? and active = ?. 656 * 657 * <p> 658 * 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 DLFileRankModelImpl}. 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. 659 * </p> 660 * 661 * @param groupId the group ID 662 * @param userId the user ID 663 * @param active the active 664 * @param start the lower bound of the range of document library file ranks 665 * @param end the upper bound of the range of document library file ranks (not inclusive) 666 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 667 * @param retrieveFromCache whether to retrieve from the finder cache 668 * @return the ordered range of matching document library file ranks 669 */ 670 public static List<DLFileRank> findByG_U_A(long groupId, long userId, 671 boolean active, int start, int end, 672 OrderByComparator<DLFileRank> orderByComparator, 673 boolean retrieveFromCache) { 674 return getPersistence() 675 .findByG_U_A(groupId, userId, active, start, end, 676 orderByComparator, retrieveFromCache); 677 } 678 679 /** 680 * Returns the first document library file rank in the ordered set where groupId = ? and userId = ? and active = ?. 681 * 682 * @param groupId the group ID 683 * @param userId the user ID 684 * @param active the active 685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 686 * @return the first matching document library file rank 687 * @throws NoSuchFileRankException if a matching document library file rank could not be found 688 */ 689 public static DLFileRank findByG_U_A_First(long groupId, long userId, 690 boolean active, OrderByComparator<DLFileRank> orderByComparator) 691 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 692 return getPersistence() 693 .findByG_U_A_First(groupId, userId, active, orderByComparator); 694 } 695 696 /** 697 * Returns the first document library file rank in the ordered set where groupId = ? and userId = ? and active = ?. 698 * 699 * @param groupId the group ID 700 * @param userId the user ID 701 * @param active the active 702 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 703 * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 704 */ 705 public static DLFileRank fetchByG_U_A_First(long groupId, long userId, 706 boolean active, OrderByComparator<DLFileRank> orderByComparator) { 707 return getPersistence() 708 .fetchByG_U_A_First(groupId, userId, active, 709 orderByComparator); 710 } 711 712 /** 713 * Returns the last document library file rank in the ordered set where groupId = ? and userId = ? and active = ?. 714 * 715 * @param groupId the group ID 716 * @param userId the user ID 717 * @param active the active 718 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 719 * @return the last matching document library file rank 720 * @throws NoSuchFileRankException if a matching document library file rank could not be found 721 */ 722 public static DLFileRank findByG_U_A_Last(long groupId, long userId, 723 boolean active, OrderByComparator<DLFileRank> orderByComparator) 724 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 725 return getPersistence() 726 .findByG_U_A_Last(groupId, userId, active, orderByComparator); 727 } 728 729 /** 730 * Returns the last document library file rank in the ordered set where groupId = ? and userId = ? and active = ?. 731 * 732 * @param groupId the group ID 733 * @param userId the user ID 734 * @param active the active 735 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 736 * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 737 */ 738 public static DLFileRank fetchByG_U_A_Last(long groupId, long userId, 739 boolean active, OrderByComparator<DLFileRank> orderByComparator) { 740 return getPersistence() 741 .fetchByG_U_A_Last(groupId, userId, active, orderByComparator); 742 } 743 744 /** 745 * Returns the document library file ranks before and after the current document library file rank in the ordered set where groupId = ? and userId = ? and active = ?. 746 * 747 * @param fileRankId the primary key of the current document library file rank 748 * @param groupId the group ID 749 * @param userId the user ID 750 * @param active the active 751 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 752 * @return the previous, current, and next document library file rank 753 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 754 */ 755 public static DLFileRank[] findByG_U_A_PrevAndNext(long fileRankId, 756 long groupId, long userId, boolean active, 757 OrderByComparator<DLFileRank> orderByComparator) 758 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 759 return getPersistence() 760 .findByG_U_A_PrevAndNext(fileRankId, groupId, userId, 761 active, orderByComparator); 762 } 763 764 /** 765 * Removes all the document library file ranks where groupId = ? and userId = ? and active = ? from the database. 766 * 767 * @param groupId the group ID 768 * @param userId the user ID 769 * @param active the active 770 */ 771 public static void removeByG_U_A(long groupId, long userId, boolean active) { 772 getPersistence().removeByG_U_A(groupId, userId, active); 773 } 774 775 /** 776 * Returns the number of document library file ranks where groupId = ? and userId = ? and active = ?. 777 * 778 * @param groupId the group ID 779 * @param userId the user ID 780 * @param active the active 781 * @return the number of matching document library file ranks 782 */ 783 public static int countByG_U_A(long groupId, long userId, boolean active) { 784 return getPersistence().countByG_U_A(groupId, userId, active); 785 } 786 787 /** 788 * Returns the document library file rank where companyId = ? and userId = ? and fileEntryId = ? or throws a {@link NoSuchFileRankException} if it could not be found. 789 * 790 * @param companyId the company ID 791 * @param userId the user ID 792 * @param fileEntryId the file entry ID 793 * @return the matching document library file rank 794 * @throws NoSuchFileRankException if a matching document library file rank could not be found 795 */ 796 public static DLFileRank findByC_U_F(long companyId, long userId, 797 long fileEntryId) 798 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 799 return getPersistence().findByC_U_F(companyId, userId, fileEntryId); 800 } 801 802 /** 803 * Returns the document library file rank where companyId = ? and userId = ? and fileEntryId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 804 * 805 * @param companyId the company ID 806 * @param userId the user ID 807 * @param fileEntryId the file entry ID 808 * @return the matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 809 */ 810 public static DLFileRank fetchByC_U_F(long companyId, long userId, 811 long fileEntryId) { 812 return getPersistence().fetchByC_U_F(companyId, userId, fileEntryId); 813 } 814 815 /** 816 * Returns the document library file rank where companyId = ? and userId = ? and fileEntryId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 817 * 818 * @param companyId the company ID 819 * @param userId the user ID 820 * @param fileEntryId the file entry ID 821 * @param retrieveFromCache whether to retrieve from the finder cache 822 * @return the matching document library file rank, or <code>null</code> if a matching document library file rank could not be found 823 */ 824 public static DLFileRank fetchByC_U_F(long companyId, long userId, 825 long fileEntryId, boolean retrieveFromCache) { 826 return getPersistence() 827 .fetchByC_U_F(companyId, userId, fileEntryId, 828 retrieveFromCache); 829 } 830 831 /** 832 * Removes the document library file rank where companyId = ? and userId = ? and fileEntryId = ? from the database. 833 * 834 * @param companyId the company ID 835 * @param userId the user ID 836 * @param fileEntryId the file entry ID 837 * @return the document library file rank that was removed 838 */ 839 public static DLFileRank removeByC_U_F(long companyId, long userId, 840 long fileEntryId) 841 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 842 return getPersistence().removeByC_U_F(companyId, userId, fileEntryId); 843 } 844 845 /** 846 * Returns the number of document library file ranks where companyId = ? and userId = ? and fileEntryId = ?. 847 * 848 * @param companyId the company ID 849 * @param userId the user ID 850 * @param fileEntryId the file entry ID 851 * @return the number of matching document library file ranks 852 */ 853 public static int countByC_U_F(long companyId, long userId, long fileEntryId) { 854 return getPersistence().countByC_U_F(companyId, userId, fileEntryId); 855 } 856 857 /** 858 * Caches the document library file rank in the entity cache if it is enabled. 859 * 860 * @param dlFileRank the document library file rank 861 */ 862 public static void cacheResult(DLFileRank dlFileRank) { 863 getPersistence().cacheResult(dlFileRank); 864 } 865 866 /** 867 * Caches the document library file ranks in the entity cache if it is enabled. 868 * 869 * @param dlFileRanks the document library file ranks 870 */ 871 public static void cacheResult(List<DLFileRank> dlFileRanks) { 872 getPersistence().cacheResult(dlFileRanks); 873 } 874 875 /** 876 * Creates a new document library file rank with the primary key. Does not add the document library file rank to the database. 877 * 878 * @param fileRankId the primary key for the new document library file rank 879 * @return the new document library file rank 880 */ 881 public static DLFileRank create(long fileRankId) { 882 return getPersistence().create(fileRankId); 883 } 884 885 /** 886 * Removes the document library file rank with the primary key from the database. Also notifies the appropriate model listeners. 887 * 888 * @param fileRankId the primary key of the document library file rank 889 * @return the document library file rank that was removed 890 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 891 */ 892 public static DLFileRank remove(long fileRankId) 893 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 894 return getPersistence().remove(fileRankId); 895 } 896 897 public static DLFileRank updateImpl(DLFileRank dlFileRank) { 898 return getPersistence().updateImpl(dlFileRank); 899 } 900 901 /** 902 * Returns the document library file rank with the primary key or throws a {@link NoSuchFileRankException} if it could not be found. 903 * 904 * @param fileRankId the primary key of the document library file rank 905 * @return the document library file rank 906 * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found 907 */ 908 public static DLFileRank findByPrimaryKey(long fileRankId) 909 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException { 910 return getPersistence().findByPrimaryKey(fileRankId); 911 } 912 913 /** 914 * Returns the document library file rank with the primary key or returns <code>null</code> if it could not be found. 915 * 916 * @param fileRankId the primary key of the document library file rank 917 * @return the document library file rank, or <code>null</code> if a document library file rank with the primary key could not be found 918 */ 919 public static DLFileRank fetchByPrimaryKey(long fileRankId) { 920 return getPersistence().fetchByPrimaryKey(fileRankId); 921 } 922 923 public static java.util.Map<java.io.Serializable, DLFileRank> fetchByPrimaryKeys( 924 java.util.Set<java.io.Serializable> primaryKeys) { 925 return getPersistence().fetchByPrimaryKeys(primaryKeys); 926 } 927 928 /** 929 * Returns all the document library file ranks. 930 * 931 * @return the document library file ranks 932 */ 933 public static List<DLFileRank> findAll() { 934 return getPersistence().findAll(); 935 } 936 937 /** 938 * Returns a range of all the document library file ranks. 939 * 940 * <p> 941 * 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 DLFileRankModelImpl}. 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. 942 * </p> 943 * 944 * @param start the lower bound of the range of document library file ranks 945 * @param end the upper bound of the range of document library file ranks (not inclusive) 946 * @return the range of document library file ranks 947 */ 948 public static List<DLFileRank> findAll(int start, int end) { 949 return getPersistence().findAll(start, end); 950 } 951 952 /** 953 * Returns an ordered range of all the document library file ranks. 954 * 955 * <p> 956 * 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 DLFileRankModelImpl}. 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. 957 * </p> 958 * 959 * @param start the lower bound of the range of document library file ranks 960 * @param end the upper bound of the range of document library file ranks (not inclusive) 961 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 962 * @return the ordered range of document library file ranks 963 */ 964 public static List<DLFileRank> findAll(int start, int end, 965 OrderByComparator<DLFileRank> orderByComparator) { 966 return getPersistence().findAll(start, end, orderByComparator); 967 } 968 969 /** 970 * Returns an ordered range of all the document library file ranks. 971 * 972 * <p> 973 * 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 DLFileRankModelImpl}. 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. 974 * </p> 975 * 976 * @param start the lower bound of the range of document library file ranks 977 * @param end the upper bound of the range of document library file ranks (not inclusive) 978 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 979 * @param retrieveFromCache whether to retrieve from the finder cache 980 * @return the ordered range of document library file ranks 981 */ 982 public static List<DLFileRank> findAll(int start, int end, 983 OrderByComparator<DLFileRank> orderByComparator, 984 boolean retrieveFromCache) { 985 return getPersistence() 986 .findAll(start, end, orderByComparator, retrieveFromCache); 987 } 988 989 /** 990 * Removes all the document library file ranks from the database. 991 */ 992 public static void removeAll() { 993 getPersistence().removeAll(); 994 } 995 996 /** 997 * Returns the number of document library file ranks. 998 * 999 * @return the number of document library file ranks 1000 */ 1001 public static int countAll() { 1002 return getPersistence().countAll(); 1003 } 1004 1005 public static java.util.Set<java.lang.String> getBadColumnNames() { 1006 return getPersistence().getBadColumnNames(); 1007 } 1008 1009 public static DLFileRankPersistence getPersistence() { 1010 if (_persistence == null) { 1011 _persistence = (DLFileRankPersistence)PortalBeanLocatorUtil.locate(DLFileRankPersistence.class.getName()); 1012 1013 ReferenceRegistry.registerReference(DLFileRankUtil.class, 1014 "_persistence"); 1015 } 1016 1017 return _persistence; 1018 } 1019 1020 private static DLFileRankPersistence _persistence; 1021 }