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.portal.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.model.RepositoryEntry; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the repository entry service. This utility wraps {@link com.liferay.portal.service.persistence.impl.RepositoryEntryPersistenceImpl} 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. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see RepositoryEntryPersistence 037 * @see com.liferay.portal.service.persistence.impl.RepositoryEntryPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class RepositoryEntryUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(RepositoryEntry repositoryEntry) { 059 getPersistence().clearCache(repositoryEntry); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<RepositoryEntry> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<RepositoryEntry> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<RepositoryEntry> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<RepositoryEntry> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static RepositoryEntry update(RepositoryEntry repositoryEntry) { 100 return getPersistence().update(repositoryEntry); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static RepositoryEntry update(RepositoryEntry repositoryEntry, 107 ServiceContext serviceContext) { 108 return getPersistence().update(repositoryEntry, serviceContext); 109 } 110 111 /** 112 * Returns all the repository entries where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching repository entries 116 */ 117 public static List<RepositoryEntry> findByUuid(java.lang.String uuid) { 118 return getPersistence().findByUuid(uuid); 119 } 120 121 /** 122 * Returns a range of all the repository entries where uuid = ?. 123 * 124 * <p> 125 * 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 RepositoryEntryModelImpl}. 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. 126 * </p> 127 * 128 * @param uuid the uuid 129 * @param start the lower bound of the range of repository entries 130 * @param end the upper bound of the range of repository entries (not inclusive) 131 * @return the range of matching repository entries 132 */ 133 public static List<RepositoryEntry> findByUuid(java.lang.String uuid, 134 int start, int end) { 135 return getPersistence().findByUuid(uuid, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the repository entries where uuid = ?. 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 RepositoryEntryModelImpl}. 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 uuid the uuid 146 * @param start the lower bound of the range of repository entries 147 * @param end the upper bound of the range of repository entries (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching repository entries 150 */ 151 public static List<RepositoryEntry> findByUuid(java.lang.String uuid, 152 int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) { 153 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns the first repository entry in the ordered set where uuid = ?. 158 * 159 * @param uuid the uuid 160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 161 * @return the first matching repository entry 162 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 163 */ 164 public static RepositoryEntry findByUuid_First(java.lang.String uuid, 165 OrderByComparator<RepositoryEntry> orderByComparator) 166 throws com.liferay.portal.NoSuchRepositoryEntryException { 167 return getPersistence().findByUuid_First(uuid, orderByComparator); 168 } 169 170 /** 171 * Returns the first repository entry in the ordered set where uuid = ?. 172 * 173 * @param uuid the uuid 174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 175 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 176 */ 177 public static RepositoryEntry fetchByUuid_First(java.lang.String uuid, 178 OrderByComparator<RepositoryEntry> orderByComparator) { 179 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 180 } 181 182 /** 183 * Returns the last repository entry in the ordered set where uuid = ?. 184 * 185 * @param uuid the uuid 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the last matching repository entry 188 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 189 */ 190 public static RepositoryEntry findByUuid_Last(java.lang.String uuid, 191 OrderByComparator<RepositoryEntry> orderByComparator) 192 throws com.liferay.portal.NoSuchRepositoryEntryException { 193 return getPersistence().findByUuid_Last(uuid, orderByComparator); 194 } 195 196 /** 197 * Returns the last repository entry in the ordered set where uuid = ?. 198 * 199 * @param uuid the uuid 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 202 */ 203 public static RepositoryEntry fetchByUuid_Last(java.lang.String uuid, 204 OrderByComparator<RepositoryEntry> orderByComparator) { 205 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 206 } 207 208 /** 209 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ?. 210 * 211 * @param repositoryEntryId the primary key of the current repository entry 212 * @param uuid the uuid 213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 214 * @return the previous, current, and next repository entry 215 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 216 */ 217 public static RepositoryEntry[] findByUuid_PrevAndNext( 218 long repositoryEntryId, java.lang.String uuid, 219 OrderByComparator<RepositoryEntry> orderByComparator) 220 throws com.liferay.portal.NoSuchRepositoryEntryException { 221 return getPersistence() 222 .findByUuid_PrevAndNext(repositoryEntryId, uuid, 223 orderByComparator); 224 } 225 226 /** 227 * Removes all the repository entries where uuid = ? from the database. 228 * 229 * @param uuid the uuid 230 */ 231 public static void removeByUuid(java.lang.String uuid) { 232 getPersistence().removeByUuid(uuid); 233 } 234 235 /** 236 * Returns the number of repository entries where uuid = ?. 237 * 238 * @param uuid the uuid 239 * @return the number of matching repository entries 240 */ 241 public static int countByUuid(java.lang.String uuid) { 242 return getPersistence().countByUuid(uuid); 243 } 244 245 /** 246 * Returns the repository entry where uuid = ? and groupId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 247 * 248 * @param uuid the uuid 249 * @param groupId the group ID 250 * @return the matching repository entry 251 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 252 */ 253 public static RepositoryEntry findByUUID_G(java.lang.String uuid, 254 long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException { 255 return getPersistence().findByUUID_G(uuid, groupId); 256 } 257 258 /** 259 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 260 * 261 * @param uuid the uuid 262 * @param groupId the group ID 263 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 264 */ 265 public static RepositoryEntry fetchByUUID_G(java.lang.String uuid, 266 long groupId) { 267 return getPersistence().fetchByUUID_G(uuid, groupId); 268 } 269 270 /** 271 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 272 * 273 * @param uuid the uuid 274 * @param groupId the group ID 275 * @param retrieveFromCache whether to use the finder cache 276 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 277 */ 278 public static RepositoryEntry fetchByUUID_G(java.lang.String uuid, 279 long groupId, boolean retrieveFromCache) { 280 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 281 } 282 283 /** 284 * Removes the repository entry where uuid = ? and groupId = ? from the database. 285 * 286 * @param uuid the uuid 287 * @param groupId the group ID 288 * @return the repository entry that was removed 289 */ 290 public static RepositoryEntry removeByUUID_G(java.lang.String uuid, 291 long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException { 292 return getPersistence().removeByUUID_G(uuid, groupId); 293 } 294 295 /** 296 * Returns the number of repository entries where uuid = ? and groupId = ?. 297 * 298 * @param uuid the uuid 299 * @param groupId the group ID 300 * @return the number of matching repository entries 301 */ 302 public static int countByUUID_G(java.lang.String uuid, long groupId) { 303 return getPersistence().countByUUID_G(uuid, groupId); 304 } 305 306 /** 307 * Returns all the repository entries where uuid = ? and companyId = ?. 308 * 309 * @param uuid the uuid 310 * @param companyId the company ID 311 * @return the matching repository entries 312 */ 313 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 314 long companyId) { 315 return getPersistence().findByUuid_C(uuid, companyId); 316 } 317 318 /** 319 * Returns a range of all the repository entries where uuid = ? and companyId = ?. 320 * 321 * <p> 322 * 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 RepositoryEntryModelImpl}. 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. 323 * </p> 324 * 325 * @param uuid the uuid 326 * @param companyId the company ID 327 * @param start the lower bound of the range of repository entries 328 * @param end the upper bound of the range of repository entries (not inclusive) 329 * @return the range of matching repository entries 330 */ 331 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 332 long companyId, int start, int end) { 333 return getPersistence().findByUuid_C(uuid, companyId, start, end); 334 } 335 336 /** 337 * Returns an ordered range of all the repository entries where uuid = ? and companyId = ?. 338 * 339 * <p> 340 * 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 RepositoryEntryModelImpl}. 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. 341 * </p> 342 * 343 * @param uuid the uuid 344 * @param companyId the company ID 345 * @param start the lower bound of the range of repository entries 346 * @param end the upper bound of the range of repository entries (not inclusive) 347 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 348 * @return the ordered range of matching repository entries 349 */ 350 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 351 long companyId, int start, int end, 352 OrderByComparator<RepositoryEntry> orderByComparator) { 353 return getPersistence() 354 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 355 } 356 357 /** 358 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 363 * @return the first matching repository entry 364 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 365 */ 366 public static RepositoryEntry findByUuid_C_First(java.lang.String uuid, 367 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) 368 throws com.liferay.portal.NoSuchRepositoryEntryException { 369 return getPersistence() 370 .findByUuid_C_First(uuid, companyId, orderByComparator); 371 } 372 373 /** 374 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 375 * 376 * @param uuid the uuid 377 * @param companyId the company ID 378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 379 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 380 */ 381 public static RepositoryEntry fetchByUuid_C_First(java.lang.String uuid, 382 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) { 383 return getPersistence() 384 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 385 } 386 387 /** 388 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 389 * 390 * @param uuid the uuid 391 * @param companyId the company ID 392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 393 * @return the last matching repository entry 394 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 395 */ 396 public static RepositoryEntry findByUuid_C_Last(java.lang.String uuid, 397 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) 398 throws com.liferay.portal.NoSuchRepositoryEntryException { 399 return getPersistence() 400 .findByUuid_C_Last(uuid, companyId, orderByComparator); 401 } 402 403 /** 404 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 405 * 406 * @param uuid the uuid 407 * @param companyId the company ID 408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 409 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 410 */ 411 public static RepositoryEntry fetchByUuid_C_Last(java.lang.String uuid, 412 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) { 413 return getPersistence() 414 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 415 } 416 417 /** 418 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ? and companyId = ?. 419 * 420 * @param repositoryEntryId the primary key of the current repository entry 421 * @param uuid the uuid 422 * @param companyId the company ID 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the previous, current, and next repository entry 425 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 426 */ 427 public static RepositoryEntry[] findByUuid_C_PrevAndNext( 428 long repositoryEntryId, java.lang.String uuid, long companyId, 429 OrderByComparator<RepositoryEntry> orderByComparator) 430 throws com.liferay.portal.NoSuchRepositoryEntryException { 431 return getPersistence() 432 .findByUuid_C_PrevAndNext(repositoryEntryId, uuid, 433 companyId, orderByComparator); 434 } 435 436 /** 437 * Removes all the repository entries where uuid = ? and companyId = ? from the database. 438 * 439 * @param uuid the uuid 440 * @param companyId the company ID 441 */ 442 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 443 getPersistence().removeByUuid_C(uuid, companyId); 444 } 445 446 /** 447 * Returns the number of repository entries where uuid = ? and companyId = ?. 448 * 449 * @param uuid the uuid 450 * @param companyId the company ID 451 * @return the number of matching repository entries 452 */ 453 public static int countByUuid_C(java.lang.String uuid, long companyId) { 454 return getPersistence().countByUuid_C(uuid, companyId); 455 } 456 457 /** 458 * Returns all the repository entries where repositoryId = ?. 459 * 460 * @param repositoryId the repository ID 461 * @return the matching repository entries 462 */ 463 public static List<RepositoryEntry> findByRepositoryId(long repositoryId) { 464 return getPersistence().findByRepositoryId(repositoryId); 465 } 466 467 /** 468 * Returns a range of all the repository entries where repositoryId = ?. 469 * 470 * <p> 471 * 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 RepositoryEntryModelImpl}. 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. 472 * </p> 473 * 474 * @param repositoryId the repository ID 475 * @param start the lower bound of the range of repository entries 476 * @param end the upper bound of the range of repository entries (not inclusive) 477 * @return the range of matching repository entries 478 */ 479 public static List<RepositoryEntry> findByRepositoryId(long repositoryId, 480 int start, int end) { 481 return getPersistence().findByRepositoryId(repositoryId, start, end); 482 } 483 484 /** 485 * Returns an ordered range of all the repository entries where repositoryId = ?. 486 * 487 * <p> 488 * 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 RepositoryEntryModelImpl}. 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. 489 * </p> 490 * 491 * @param repositoryId the repository ID 492 * @param start the lower bound of the range of repository entries 493 * @param end the upper bound of the range of repository entries (not inclusive) 494 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 495 * @return the ordered range of matching repository entries 496 */ 497 public static List<RepositoryEntry> findByRepositoryId(long repositoryId, 498 int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) { 499 return getPersistence() 500 .findByRepositoryId(repositoryId, start, end, 501 orderByComparator); 502 } 503 504 /** 505 * Returns the first repository entry in the ordered set where repositoryId = ?. 506 * 507 * @param repositoryId the repository ID 508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 509 * @return the first matching repository entry 510 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 511 */ 512 public static RepositoryEntry findByRepositoryId_First(long repositoryId, 513 OrderByComparator<RepositoryEntry> orderByComparator) 514 throws com.liferay.portal.NoSuchRepositoryEntryException { 515 return getPersistence() 516 .findByRepositoryId_First(repositoryId, orderByComparator); 517 } 518 519 /** 520 * Returns the first repository entry in the ordered set where repositoryId = ?. 521 * 522 * @param repositoryId the repository ID 523 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 524 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 525 */ 526 public static RepositoryEntry fetchByRepositoryId_First(long repositoryId, 527 OrderByComparator<RepositoryEntry> orderByComparator) { 528 return getPersistence() 529 .fetchByRepositoryId_First(repositoryId, orderByComparator); 530 } 531 532 /** 533 * Returns the last repository entry in the ordered set where repositoryId = ?. 534 * 535 * @param repositoryId the repository ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the last matching repository entry 538 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 539 */ 540 public static RepositoryEntry findByRepositoryId_Last(long repositoryId, 541 OrderByComparator<RepositoryEntry> orderByComparator) 542 throws com.liferay.portal.NoSuchRepositoryEntryException { 543 return getPersistence() 544 .findByRepositoryId_Last(repositoryId, orderByComparator); 545 } 546 547 /** 548 * Returns the last repository entry in the ordered set where repositoryId = ?. 549 * 550 * @param repositoryId the repository ID 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 553 */ 554 public static RepositoryEntry fetchByRepositoryId_Last(long repositoryId, 555 OrderByComparator<RepositoryEntry> orderByComparator) { 556 return getPersistence() 557 .fetchByRepositoryId_Last(repositoryId, orderByComparator); 558 } 559 560 /** 561 * Returns the repository entries before and after the current repository entry in the ordered set where repositoryId = ?. 562 * 563 * @param repositoryEntryId the primary key of the current repository entry 564 * @param repositoryId the repository ID 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the previous, current, and next repository entry 567 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 568 */ 569 public static RepositoryEntry[] findByRepositoryId_PrevAndNext( 570 long repositoryEntryId, long repositoryId, 571 OrderByComparator<RepositoryEntry> orderByComparator) 572 throws com.liferay.portal.NoSuchRepositoryEntryException { 573 return getPersistence() 574 .findByRepositoryId_PrevAndNext(repositoryEntryId, 575 repositoryId, orderByComparator); 576 } 577 578 /** 579 * Removes all the repository entries where repositoryId = ? from the database. 580 * 581 * @param repositoryId the repository ID 582 */ 583 public static void removeByRepositoryId(long repositoryId) { 584 getPersistence().removeByRepositoryId(repositoryId); 585 } 586 587 /** 588 * Returns the number of repository entries where repositoryId = ?. 589 * 590 * @param repositoryId the repository ID 591 * @return the number of matching repository entries 592 */ 593 public static int countByRepositoryId(long repositoryId) { 594 return getPersistence().countByRepositoryId(repositoryId); 595 } 596 597 /** 598 * Returns the repository entry where repositoryId = ? and mappedId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 599 * 600 * @param repositoryId the repository ID 601 * @param mappedId the mapped ID 602 * @return the matching repository entry 603 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 604 */ 605 public static RepositoryEntry findByR_M(long repositoryId, 606 java.lang.String mappedId) 607 throws com.liferay.portal.NoSuchRepositoryEntryException { 608 return getPersistence().findByR_M(repositoryId, mappedId); 609 } 610 611 /** 612 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 613 * 614 * @param repositoryId the repository ID 615 * @param mappedId the mapped ID 616 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 617 */ 618 public static RepositoryEntry fetchByR_M(long repositoryId, 619 java.lang.String mappedId) { 620 return getPersistence().fetchByR_M(repositoryId, mappedId); 621 } 622 623 /** 624 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 625 * 626 * @param repositoryId the repository ID 627 * @param mappedId the mapped ID 628 * @param retrieveFromCache whether to use the finder cache 629 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 630 */ 631 public static RepositoryEntry fetchByR_M(long repositoryId, 632 java.lang.String mappedId, boolean retrieveFromCache) { 633 return getPersistence() 634 .fetchByR_M(repositoryId, mappedId, retrieveFromCache); 635 } 636 637 /** 638 * Removes the repository entry where repositoryId = ? and mappedId = ? from the database. 639 * 640 * @param repositoryId the repository ID 641 * @param mappedId the mapped ID 642 * @return the repository entry that was removed 643 */ 644 public static RepositoryEntry removeByR_M(long repositoryId, 645 java.lang.String mappedId) 646 throws com.liferay.portal.NoSuchRepositoryEntryException { 647 return getPersistence().removeByR_M(repositoryId, mappedId); 648 } 649 650 /** 651 * Returns the number of repository entries where repositoryId = ? and mappedId = ?. 652 * 653 * @param repositoryId the repository ID 654 * @param mappedId the mapped ID 655 * @return the number of matching repository entries 656 */ 657 public static int countByR_M(long repositoryId, java.lang.String mappedId) { 658 return getPersistence().countByR_M(repositoryId, mappedId); 659 } 660 661 /** 662 * Caches the repository entry in the entity cache if it is enabled. 663 * 664 * @param repositoryEntry the repository entry 665 */ 666 public static void cacheResult(RepositoryEntry repositoryEntry) { 667 getPersistence().cacheResult(repositoryEntry); 668 } 669 670 /** 671 * Caches the repository entries in the entity cache if it is enabled. 672 * 673 * @param repositoryEntries the repository entries 674 */ 675 public static void cacheResult(List<RepositoryEntry> repositoryEntries) { 676 getPersistence().cacheResult(repositoryEntries); 677 } 678 679 /** 680 * Creates a new repository entry with the primary key. Does not add the repository entry to the database. 681 * 682 * @param repositoryEntryId the primary key for the new repository entry 683 * @return the new repository entry 684 */ 685 public static RepositoryEntry create(long repositoryEntryId) { 686 return getPersistence().create(repositoryEntryId); 687 } 688 689 /** 690 * Removes the repository entry with the primary key from the database. Also notifies the appropriate model listeners. 691 * 692 * @param repositoryEntryId the primary key of the repository entry 693 * @return the repository entry that was removed 694 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 695 */ 696 public static RepositoryEntry remove(long repositoryEntryId) 697 throws com.liferay.portal.NoSuchRepositoryEntryException { 698 return getPersistence().remove(repositoryEntryId); 699 } 700 701 public static RepositoryEntry updateImpl(RepositoryEntry repositoryEntry) { 702 return getPersistence().updateImpl(repositoryEntry); 703 } 704 705 /** 706 * Returns the repository entry with the primary key or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 707 * 708 * @param repositoryEntryId the primary key of the repository entry 709 * @return the repository entry 710 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 711 */ 712 public static RepositoryEntry findByPrimaryKey(long repositoryEntryId) 713 throws com.liferay.portal.NoSuchRepositoryEntryException { 714 return getPersistence().findByPrimaryKey(repositoryEntryId); 715 } 716 717 /** 718 * Returns the repository entry with the primary key or returns <code>null</code> if it could not be found. 719 * 720 * @param repositoryEntryId the primary key of the repository entry 721 * @return the repository entry, or <code>null</code> if a repository entry with the primary key could not be found 722 */ 723 public static RepositoryEntry fetchByPrimaryKey(long repositoryEntryId) { 724 return getPersistence().fetchByPrimaryKey(repositoryEntryId); 725 } 726 727 public static java.util.Map<java.io.Serializable, RepositoryEntry> fetchByPrimaryKeys( 728 java.util.Set<java.io.Serializable> primaryKeys) { 729 return getPersistence().fetchByPrimaryKeys(primaryKeys); 730 } 731 732 /** 733 * Returns all the repository entries. 734 * 735 * @return the repository entries 736 */ 737 public static List<RepositoryEntry> findAll() { 738 return getPersistence().findAll(); 739 } 740 741 /** 742 * Returns a range of all the repository entries. 743 * 744 * <p> 745 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RepositoryEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 746 * </p> 747 * 748 * @param start the lower bound of the range of repository entries 749 * @param end the upper bound of the range of repository entries (not inclusive) 750 * @return the range of repository entries 751 */ 752 public static List<RepositoryEntry> findAll(int start, int end) { 753 return getPersistence().findAll(start, end); 754 } 755 756 /** 757 * Returns an ordered range of all the repository entries. 758 * 759 * <p> 760 * 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 RepositoryEntryModelImpl}. 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. 761 * </p> 762 * 763 * @param start the lower bound of the range of repository entries 764 * @param end the upper bound of the range of repository entries (not inclusive) 765 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 766 * @return the ordered range of repository entries 767 */ 768 public static List<RepositoryEntry> findAll(int start, int end, 769 OrderByComparator<RepositoryEntry> orderByComparator) { 770 return getPersistence().findAll(start, end, orderByComparator); 771 } 772 773 /** 774 * Removes all the repository entries from the database. 775 */ 776 public static void removeAll() { 777 getPersistence().removeAll(); 778 } 779 780 /** 781 * Returns the number of repository entries. 782 * 783 * @return the number of repository entries 784 */ 785 public static int countAll() { 786 return getPersistence().countAll(); 787 } 788 789 public static RepositoryEntryPersistence getPersistence() { 790 if (_persistence == null) { 791 _persistence = (RepositoryEntryPersistence)PortalBeanLocatorUtil.locate(RepositoryEntryPersistence.class.getName()); 792 793 ReferenceRegistry.registerReference(RepositoryEntryUtil.class, 794 "_persistence"); 795 } 796 797 return _persistence; 798 } 799 800 /** 801 * @deprecated As of 6.2.0 802 */ 803 @Deprecated 804 public void setPersistence(RepositoryEntryPersistence persistence) { 805 } 806 807 private static RepositoryEntryPersistence _persistence; 808 }