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