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 an ordered range of all the repository entries where uuid = ?. 158 * 159 * <p> 160 * 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. 161 * </p> 162 * 163 * @param uuid the uuid 164 * @param start the lower bound of the range of repository entries 165 * @param end the upper bound of the range of repository entries (not inclusive) 166 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 167 * @param retrieveFromCache whether to retrieve from the finder cache 168 * @return the ordered range of matching repository entries 169 */ 170 public static List<RepositoryEntry> findByUuid(java.lang.String uuid, 171 int start, int end, 172 OrderByComparator<RepositoryEntry> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first repository entry in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching repository entry 185 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 186 */ 187 public static RepositoryEntry findByUuid_First(java.lang.String uuid, 188 OrderByComparator<RepositoryEntry> orderByComparator) 189 throws com.liferay.portal.NoSuchRepositoryEntryException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first repository entry in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 199 */ 200 public static RepositoryEntry fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<RepositoryEntry> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last repository entry in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching repository entry 211 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 212 */ 213 public static RepositoryEntry findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<RepositoryEntry> orderByComparator) 215 throws com.liferay.portal.NoSuchRepositoryEntryException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last repository entry in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 225 */ 226 public static RepositoryEntry fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<RepositoryEntry> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ?. 233 * 234 * @param repositoryEntryId the primary key of the current repository entry 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next repository entry 238 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 239 */ 240 public static RepositoryEntry[] findByUuid_PrevAndNext( 241 long repositoryEntryId, java.lang.String uuid, 242 OrderByComparator<RepositoryEntry> orderByComparator) 243 throws com.liferay.portal.NoSuchRepositoryEntryException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(repositoryEntryId, uuid, 246 orderByComparator); 247 } 248 249 /** 250 * Removes all the repository entries where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 */ 254 public static void removeByUuid(java.lang.String uuid) { 255 getPersistence().removeByUuid(uuid); 256 } 257 258 /** 259 * Returns the number of repository entries where uuid = ?. 260 * 261 * @param uuid the uuid 262 * @return the number of matching repository entries 263 */ 264 public static int countByUuid(java.lang.String uuid) { 265 return getPersistence().countByUuid(uuid); 266 } 267 268 /** 269 * Returns the repository entry where uuid = ? and groupId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 270 * 271 * @param uuid the uuid 272 * @param groupId the group ID 273 * @return the matching repository entry 274 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 275 */ 276 public static RepositoryEntry findByUUID_G(java.lang.String uuid, 277 long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException { 278 return getPersistence().findByUUID_G(uuid, groupId); 279 } 280 281 /** 282 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 283 * 284 * @param uuid the uuid 285 * @param groupId the group ID 286 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 287 */ 288 public static RepositoryEntry fetchByUUID_G(java.lang.String uuid, 289 long groupId) { 290 return getPersistence().fetchByUUID_G(uuid, groupId); 291 } 292 293 /** 294 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 295 * 296 * @param uuid the uuid 297 * @param groupId the group ID 298 * @param retrieveFromCache whether to retrieve from the finder cache 299 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 300 */ 301 public static RepositoryEntry fetchByUUID_G(java.lang.String uuid, 302 long groupId, boolean retrieveFromCache) { 303 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 304 } 305 306 /** 307 * Removes the repository entry where uuid = ? and groupId = ? from the database. 308 * 309 * @param uuid the uuid 310 * @param groupId the group ID 311 * @return the repository entry that was removed 312 */ 313 public static RepositoryEntry removeByUUID_G(java.lang.String uuid, 314 long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException { 315 return getPersistence().removeByUUID_G(uuid, groupId); 316 } 317 318 /** 319 * Returns the number of repository entries where uuid = ? and groupId = ?. 320 * 321 * @param uuid the uuid 322 * @param groupId the group ID 323 * @return the number of matching repository entries 324 */ 325 public static int countByUUID_G(java.lang.String uuid, long groupId) { 326 return getPersistence().countByUUID_G(uuid, groupId); 327 } 328 329 /** 330 * Returns all the repository entries where uuid = ? and companyId = ?. 331 * 332 * @param uuid the uuid 333 * @param companyId the company ID 334 * @return the matching repository entries 335 */ 336 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 337 long companyId) { 338 return getPersistence().findByUuid_C(uuid, companyId); 339 } 340 341 /** 342 * Returns a range of all the repository entries where uuid = ? and companyId = ?. 343 * 344 * <p> 345 * 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. 346 * </p> 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @param start the lower bound of the range of repository entries 351 * @param end the upper bound of the range of repository entries (not inclusive) 352 * @return the range of matching repository entries 353 */ 354 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 355 long companyId, int start, int end) { 356 return getPersistence().findByUuid_C(uuid, companyId, start, end); 357 } 358 359 /** 360 * Returns an ordered range of all the repository entries where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * 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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of repository entries 369 * @param end the upper bound of the range of repository entries (not inclusive) 370 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 371 * @return the ordered range of matching repository entries 372 */ 373 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 374 long companyId, int start, int end, 375 OrderByComparator<RepositoryEntry> orderByComparator) { 376 return getPersistence() 377 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 378 } 379 380 /** 381 * Returns an ordered range of all the repository entries where uuid = ? and companyId = ?. 382 * 383 * <p> 384 * 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. 385 * </p> 386 * 387 * @param uuid the uuid 388 * @param companyId the company ID 389 * @param start the lower bound of the range of repository entries 390 * @param end the upper bound of the range of repository entries (not inclusive) 391 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 392 * @param retrieveFromCache whether to retrieve from the finder cache 393 * @return the ordered range of matching repository entries 394 */ 395 public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 396 long companyId, int start, int end, 397 OrderByComparator<RepositoryEntry> orderByComparator, 398 boolean retrieveFromCache) { 399 return getPersistence() 400 .findByUuid_C(uuid, companyId, start, end, 401 orderByComparator, retrieveFromCache); 402 } 403 404 /** 405 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 406 * 407 * @param uuid the uuid 408 * @param companyId the company ID 409 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 410 * @return the first matching repository entry 411 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 412 */ 413 public static RepositoryEntry findByUuid_C_First(java.lang.String uuid, 414 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) 415 throws com.liferay.portal.NoSuchRepositoryEntryException { 416 return getPersistence() 417 .findByUuid_C_First(uuid, companyId, orderByComparator); 418 } 419 420 /** 421 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 422 * 423 * @param uuid the uuid 424 * @param companyId the company ID 425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 426 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 427 */ 428 public static RepositoryEntry fetchByUuid_C_First(java.lang.String uuid, 429 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) { 430 return getPersistence() 431 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 432 } 433 434 /** 435 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 436 * 437 * @param uuid the uuid 438 * @param companyId the company ID 439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 440 * @return the last matching repository entry 441 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 442 */ 443 public static RepositoryEntry findByUuid_C_Last(java.lang.String uuid, 444 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) 445 throws com.liferay.portal.NoSuchRepositoryEntryException { 446 return getPersistence() 447 .findByUuid_C_Last(uuid, companyId, orderByComparator); 448 } 449 450 /** 451 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 452 * 453 * @param uuid the uuid 454 * @param companyId the company ID 455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 456 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 457 */ 458 public static RepositoryEntry fetchByUuid_C_Last(java.lang.String uuid, 459 long companyId, OrderByComparator<RepositoryEntry> orderByComparator) { 460 return getPersistence() 461 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 462 } 463 464 /** 465 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ? and companyId = ?. 466 * 467 * @param repositoryEntryId the primary key of the current repository entry 468 * @param uuid the uuid 469 * @param companyId the company ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the previous, current, and next repository entry 472 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 473 */ 474 public static RepositoryEntry[] findByUuid_C_PrevAndNext( 475 long repositoryEntryId, java.lang.String uuid, long companyId, 476 OrderByComparator<RepositoryEntry> orderByComparator) 477 throws com.liferay.portal.NoSuchRepositoryEntryException { 478 return getPersistence() 479 .findByUuid_C_PrevAndNext(repositoryEntryId, uuid, 480 companyId, orderByComparator); 481 } 482 483 /** 484 * Removes all the repository entries where uuid = ? and companyId = ? from the database. 485 * 486 * @param uuid the uuid 487 * @param companyId the company ID 488 */ 489 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 490 getPersistence().removeByUuid_C(uuid, companyId); 491 } 492 493 /** 494 * Returns the number of repository entries where uuid = ? and companyId = ?. 495 * 496 * @param uuid the uuid 497 * @param companyId the company ID 498 * @return the number of matching repository entries 499 */ 500 public static int countByUuid_C(java.lang.String uuid, long companyId) { 501 return getPersistence().countByUuid_C(uuid, companyId); 502 } 503 504 /** 505 * Returns all the repository entries where repositoryId = ?. 506 * 507 * @param repositoryId the repository ID 508 * @return the matching repository entries 509 */ 510 public static List<RepositoryEntry> findByRepositoryId(long repositoryId) { 511 return getPersistence().findByRepositoryId(repositoryId); 512 } 513 514 /** 515 * Returns a range of all the repository entries where repositoryId = ?. 516 * 517 * <p> 518 * 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. 519 * </p> 520 * 521 * @param repositoryId the repository ID 522 * @param start the lower bound of the range of repository entries 523 * @param end the upper bound of the range of repository entries (not inclusive) 524 * @return the range of matching repository entries 525 */ 526 public static List<RepositoryEntry> findByRepositoryId(long repositoryId, 527 int start, int end) { 528 return getPersistence().findByRepositoryId(repositoryId, start, end); 529 } 530 531 /** 532 * Returns an ordered range of all the repository entries where repositoryId = ?. 533 * 534 * <p> 535 * 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. 536 * </p> 537 * 538 * @param repositoryId the repository ID 539 * @param start the lower bound of the range of repository entries 540 * @param end the upper bound of the range of repository entries (not inclusive) 541 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 542 * @return the ordered range of matching repository entries 543 */ 544 public static List<RepositoryEntry> findByRepositoryId(long repositoryId, 545 int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) { 546 return getPersistence() 547 .findByRepositoryId(repositoryId, start, end, 548 orderByComparator); 549 } 550 551 /** 552 * Returns an ordered range of all the repository entries where repositoryId = ?. 553 * 554 * <p> 555 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 556 * </p> 557 * 558 * @param repositoryId the repository ID 559 * @param start the lower bound of the range of repository entries 560 * @param end the upper bound of the range of repository entries (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @param retrieveFromCache whether to retrieve from the finder cache 563 * @return the ordered range of matching repository entries 564 */ 565 public static List<RepositoryEntry> findByRepositoryId(long repositoryId, 566 int start, int end, 567 OrderByComparator<RepositoryEntry> orderByComparator, 568 boolean retrieveFromCache) { 569 return getPersistence() 570 .findByRepositoryId(repositoryId, start, end, 571 orderByComparator, retrieveFromCache); 572 } 573 574 /** 575 * Returns the first repository entry in the ordered set where repositoryId = ?. 576 * 577 * @param repositoryId the repository ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching repository entry 580 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 581 */ 582 public static RepositoryEntry findByRepositoryId_First(long repositoryId, 583 OrderByComparator<RepositoryEntry> orderByComparator) 584 throws com.liferay.portal.NoSuchRepositoryEntryException { 585 return getPersistence() 586 .findByRepositoryId_First(repositoryId, orderByComparator); 587 } 588 589 /** 590 * Returns the first repository entry in the ordered set where repositoryId = ?. 591 * 592 * @param repositoryId the repository ID 593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 594 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 595 */ 596 public static RepositoryEntry fetchByRepositoryId_First(long repositoryId, 597 OrderByComparator<RepositoryEntry> orderByComparator) { 598 return getPersistence() 599 .fetchByRepositoryId_First(repositoryId, orderByComparator); 600 } 601 602 /** 603 * Returns the last repository entry in the ordered set where repositoryId = ?. 604 * 605 * @param repositoryId the repository ID 606 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 607 * @return the last matching repository entry 608 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 609 */ 610 public static RepositoryEntry findByRepositoryId_Last(long repositoryId, 611 OrderByComparator<RepositoryEntry> orderByComparator) 612 throws com.liferay.portal.NoSuchRepositoryEntryException { 613 return getPersistence() 614 .findByRepositoryId_Last(repositoryId, orderByComparator); 615 } 616 617 /** 618 * Returns the last repository entry in the ordered set where repositoryId = ?. 619 * 620 * @param repositoryId the repository ID 621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 622 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 623 */ 624 public static RepositoryEntry fetchByRepositoryId_Last(long repositoryId, 625 OrderByComparator<RepositoryEntry> orderByComparator) { 626 return getPersistence() 627 .fetchByRepositoryId_Last(repositoryId, orderByComparator); 628 } 629 630 /** 631 * Returns the repository entries before and after the current repository entry in the ordered set where repositoryId = ?. 632 * 633 * @param repositoryEntryId the primary key of the current repository entry 634 * @param repositoryId the repository ID 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the previous, current, and next repository entry 637 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 638 */ 639 public static RepositoryEntry[] findByRepositoryId_PrevAndNext( 640 long repositoryEntryId, long repositoryId, 641 OrderByComparator<RepositoryEntry> orderByComparator) 642 throws com.liferay.portal.NoSuchRepositoryEntryException { 643 return getPersistence() 644 .findByRepositoryId_PrevAndNext(repositoryEntryId, 645 repositoryId, orderByComparator); 646 } 647 648 /** 649 * Removes all the repository entries where repositoryId = ? from the database. 650 * 651 * @param repositoryId the repository ID 652 */ 653 public static void removeByRepositoryId(long repositoryId) { 654 getPersistence().removeByRepositoryId(repositoryId); 655 } 656 657 /** 658 * Returns the number of repository entries where repositoryId = ?. 659 * 660 * @param repositoryId the repository ID 661 * @return the number of matching repository entries 662 */ 663 public static int countByRepositoryId(long repositoryId) { 664 return getPersistence().countByRepositoryId(repositoryId); 665 } 666 667 /** 668 * Returns the repository entry where repositoryId = ? and mappedId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 669 * 670 * @param repositoryId the repository ID 671 * @param mappedId the mapped ID 672 * @return the matching repository entry 673 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 674 */ 675 public static RepositoryEntry findByR_M(long repositoryId, 676 java.lang.String mappedId) 677 throws com.liferay.portal.NoSuchRepositoryEntryException { 678 return getPersistence().findByR_M(repositoryId, mappedId); 679 } 680 681 /** 682 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 683 * 684 * @param repositoryId the repository ID 685 * @param mappedId the mapped ID 686 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 687 */ 688 public static RepositoryEntry fetchByR_M(long repositoryId, 689 java.lang.String mappedId) { 690 return getPersistence().fetchByR_M(repositoryId, mappedId); 691 } 692 693 /** 694 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 695 * 696 * @param repositoryId the repository ID 697 * @param mappedId the mapped ID 698 * @param retrieveFromCache whether to retrieve from the finder cache 699 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 700 */ 701 public static RepositoryEntry fetchByR_M(long repositoryId, 702 java.lang.String mappedId, boolean retrieveFromCache) { 703 return getPersistence() 704 .fetchByR_M(repositoryId, mappedId, retrieveFromCache); 705 } 706 707 /** 708 * Removes the repository entry where repositoryId = ? and mappedId = ? from the database. 709 * 710 * @param repositoryId the repository ID 711 * @param mappedId the mapped ID 712 * @return the repository entry that was removed 713 */ 714 public static RepositoryEntry removeByR_M(long repositoryId, 715 java.lang.String mappedId) 716 throws com.liferay.portal.NoSuchRepositoryEntryException { 717 return getPersistence().removeByR_M(repositoryId, mappedId); 718 } 719 720 /** 721 * Returns the number of repository entries where repositoryId = ? and mappedId = ?. 722 * 723 * @param repositoryId the repository ID 724 * @param mappedId the mapped ID 725 * @return the number of matching repository entries 726 */ 727 public static int countByR_M(long repositoryId, java.lang.String mappedId) { 728 return getPersistence().countByR_M(repositoryId, mappedId); 729 } 730 731 /** 732 * Caches the repository entry in the entity cache if it is enabled. 733 * 734 * @param repositoryEntry the repository entry 735 */ 736 public static void cacheResult(RepositoryEntry repositoryEntry) { 737 getPersistence().cacheResult(repositoryEntry); 738 } 739 740 /** 741 * Caches the repository entries in the entity cache if it is enabled. 742 * 743 * @param repositoryEntries the repository entries 744 */ 745 public static void cacheResult(List<RepositoryEntry> repositoryEntries) { 746 getPersistence().cacheResult(repositoryEntries); 747 } 748 749 /** 750 * Creates a new repository entry with the primary key. Does not add the repository entry to the database. 751 * 752 * @param repositoryEntryId the primary key for the new repository entry 753 * @return the new repository entry 754 */ 755 public static RepositoryEntry create(long repositoryEntryId) { 756 return getPersistence().create(repositoryEntryId); 757 } 758 759 /** 760 * Removes the repository entry with the primary key from the database. Also notifies the appropriate model listeners. 761 * 762 * @param repositoryEntryId the primary key of the repository entry 763 * @return the repository entry that was removed 764 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 765 */ 766 public static RepositoryEntry remove(long repositoryEntryId) 767 throws com.liferay.portal.NoSuchRepositoryEntryException { 768 return getPersistence().remove(repositoryEntryId); 769 } 770 771 public static RepositoryEntry updateImpl(RepositoryEntry repositoryEntry) { 772 return getPersistence().updateImpl(repositoryEntry); 773 } 774 775 /** 776 * Returns the repository entry with the primary key or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 777 * 778 * @param repositoryEntryId the primary key of the repository entry 779 * @return the repository entry 780 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 781 */ 782 public static RepositoryEntry findByPrimaryKey(long repositoryEntryId) 783 throws com.liferay.portal.NoSuchRepositoryEntryException { 784 return getPersistence().findByPrimaryKey(repositoryEntryId); 785 } 786 787 /** 788 * Returns the repository entry with the primary key or returns <code>null</code> if it could not be found. 789 * 790 * @param repositoryEntryId the primary key of the repository entry 791 * @return the repository entry, or <code>null</code> if a repository entry with the primary key could not be found 792 */ 793 public static RepositoryEntry fetchByPrimaryKey(long repositoryEntryId) { 794 return getPersistence().fetchByPrimaryKey(repositoryEntryId); 795 } 796 797 public static java.util.Map<java.io.Serializable, RepositoryEntry> fetchByPrimaryKeys( 798 java.util.Set<java.io.Serializable> primaryKeys) { 799 return getPersistence().fetchByPrimaryKeys(primaryKeys); 800 } 801 802 /** 803 * Returns all the repository entries. 804 * 805 * @return the repository entries 806 */ 807 public static List<RepositoryEntry> findAll() { 808 return getPersistence().findAll(); 809 } 810 811 /** 812 * Returns a range of all the repository entries. 813 * 814 * <p> 815 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 816 * </p> 817 * 818 * @param start the lower bound of the range of repository entries 819 * @param end the upper bound of the range of repository entries (not inclusive) 820 * @return the range of repository entries 821 */ 822 public static List<RepositoryEntry> findAll(int start, int end) { 823 return getPersistence().findAll(start, end); 824 } 825 826 /** 827 * Returns an ordered range of all the repository entries. 828 * 829 * <p> 830 * 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. 831 * </p> 832 * 833 * @param start the lower bound of the range of repository entries 834 * @param end the upper bound of the range of repository entries (not inclusive) 835 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 836 * @return the ordered range of repository entries 837 */ 838 public static List<RepositoryEntry> findAll(int start, int end, 839 OrderByComparator<RepositoryEntry> orderByComparator) { 840 return getPersistence().findAll(start, end, orderByComparator); 841 } 842 843 /** 844 * Returns an ordered range of all the repository entries. 845 * 846 * <p> 847 * 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. 848 * </p> 849 * 850 * @param start the lower bound of the range of repository entries 851 * @param end the upper bound of the range of repository entries (not inclusive) 852 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 853 * @param retrieveFromCache whether to retrieve from the finder cache 854 * @return the ordered range of repository entries 855 */ 856 public static List<RepositoryEntry> findAll(int start, int end, 857 OrderByComparator<RepositoryEntry> orderByComparator, 858 boolean retrieveFromCache) { 859 return getPersistence() 860 .findAll(start, end, orderByComparator, retrieveFromCache); 861 } 862 863 /** 864 * Removes all the repository entries from the database. 865 */ 866 public static void removeAll() { 867 getPersistence().removeAll(); 868 } 869 870 /** 871 * Returns the number of repository entries. 872 * 873 * @return the number of repository entries 874 */ 875 public static int countAll() { 876 return getPersistence().countAll(); 877 } 878 879 public static java.util.Set<java.lang.String> getBadColumnNames() { 880 return getPersistence().getBadColumnNames(); 881 } 882 883 public static RepositoryEntryPersistence getPersistence() { 884 if (_persistence == null) { 885 _persistence = (RepositoryEntryPersistence)PortalBeanLocatorUtil.locate(RepositoryEntryPersistence.class.getName()); 886 887 ReferenceRegistry.registerReference(RepositoryEntryUtil.class, 888 "_persistence"); 889 } 890 891 return _persistence; 892 } 893 894 private static RepositoryEntryPersistence _persistence; 895 }