001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.asset.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.asset.model.AssetLink; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset link service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetLinkPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see AssetLinkPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetLinkPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetLinkUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(AssetLink assetLink) { 060 getPersistence().clearCache(assetLink); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<AssetLink> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<AssetLink> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AssetLink> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetLink> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AssetLink update(AssetLink assetLink) { 101 return getPersistence().update(assetLink); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static AssetLink update(AssetLink assetLink, 108 ServiceContext serviceContext) { 109 return getPersistence().update(assetLink, serviceContext); 110 } 111 112 /** 113 * Returns all the asset links where entryId1 = ?. 114 * 115 * @param entryId1 the entry id1 116 * @return the matching asset links 117 */ 118 public static List<AssetLink> findByE1(long entryId1) { 119 return getPersistence().findByE1(entryId1); 120 } 121 122 /** 123 * Returns a range of all the asset links where entryId1 = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetLinkModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param entryId1 the entry id1 130 * @param start the lower bound of the range of asset links 131 * @param end the upper bound of the range of asset links (not inclusive) 132 * @return the range of matching asset links 133 */ 134 public static List<AssetLink> findByE1(long entryId1, int start, int end) { 135 return getPersistence().findByE1(entryId1, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the asset links where entryId1 = ?. 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 AssetLinkModelImpl}. 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 entryId1 the entry id1 146 * @param start the lower bound of the range of asset links 147 * @param end the upper bound of the range of asset links (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching asset links 150 */ 151 public static List<AssetLink> findByE1(long entryId1, int start, int end, 152 OrderByComparator<AssetLink> orderByComparator) { 153 return getPersistence().findByE1(entryId1, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns an ordered range of all the asset links where entryId1 = ?. 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 AssetLinkModelImpl}. 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 entryId1 the entry id1 164 * @param start the lower bound of the range of asset links 165 * @param end the upper bound of the range of asset links (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 asset links 169 */ 170 public static List<AssetLink> findByE1(long entryId1, int start, int end, 171 OrderByComparator<AssetLink> orderByComparator, 172 boolean retrieveFromCache) { 173 return getPersistence() 174 .findByE1(entryId1, start, end, orderByComparator, 175 retrieveFromCache); 176 } 177 178 /** 179 * Returns the first asset link in the ordered set where entryId1 = ?. 180 * 181 * @param entryId1 the entry id1 182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 183 * @return the first matching asset link 184 * @throws NoSuchLinkException if a matching asset link could not be found 185 */ 186 public static AssetLink findByE1_First(long entryId1, 187 OrderByComparator<AssetLink> orderByComparator) 188 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 189 return getPersistence().findByE1_First(entryId1, orderByComparator); 190 } 191 192 /** 193 * Returns the first asset link in the ordered set where entryId1 = ?. 194 * 195 * @param entryId1 the entry id1 196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 197 * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found 198 */ 199 public static AssetLink fetchByE1_First(long entryId1, 200 OrderByComparator<AssetLink> orderByComparator) { 201 return getPersistence().fetchByE1_First(entryId1, orderByComparator); 202 } 203 204 /** 205 * Returns the last asset link in the ordered set where entryId1 = ?. 206 * 207 * @param entryId1 the entry id1 208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 209 * @return the last matching asset link 210 * @throws NoSuchLinkException if a matching asset link could not be found 211 */ 212 public static AssetLink findByE1_Last(long entryId1, 213 OrderByComparator<AssetLink> orderByComparator) 214 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 215 return getPersistence().findByE1_Last(entryId1, orderByComparator); 216 } 217 218 /** 219 * Returns the last asset link in the ordered set where entryId1 = ?. 220 * 221 * @param entryId1 the entry id1 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found 224 */ 225 public static AssetLink fetchByE1_Last(long entryId1, 226 OrderByComparator<AssetLink> orderByComparator) { 227 return getPersistence().fetchByE1_Last(entryId1, orderByComparator); 228 } 229 230 /** 231 * Returns the asset links before and after the current asset link in the ordered set where entryId1 = ?. 232 * 233 * @param linkId the primary key of the current asset link 234 * @param entryId1 the entry id1 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next asset link 237 * @throws NoSuchLinkException if a asset link with the primary key could not be found 238 */ 239 public static AssetLink[] findByE1_PrevAndNext(long linkId, long entryId1, 240 OrderByComparator<AssetLink> orderByComparator) 241 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 242 return getPersistence() 243 .findByE1_PrevAndNext(linkId, entryId1, orderByComparator); 244 } 245 246 /** 247 * Removes all the asset links where entryId1 = ? from the database. 248 * 249 * @param entryId1 the entry id1 250 */ 251 public static void removeByE1(long entryId1) { 252 getPersistence().removeByE1(entryId1); 253 } 254 255 /** 256 * Returns the number of asset links where entryId1 = ?. 257 * 258 * @param entryId1 the entry id1 259 * @return the number of matching asset links 260 */ 261 public static int countByE1(long entryId1) { 262 return getPersistence().countByE1(entryId1); 263 } 264 265 /** 266 * Returns all the asset links where entryId2 = ?. 267 * 268 * @param entryId2 the entry id2 269 * @return the matching asset links 270 */ 271 public static List<AssetLink> findByE2(long entryId2) { 272 return getPersistence().findByE2(entryId2); 273 } 274 275 /** 276 * Returns a range of all the asset links where entryId2 = ?. 277 * 278 * <p> 279 * 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 AssetLinkModelImpl}. 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. 280 * </p> 281 * 282 * @param entryId2 the entry id2 283 * @param start the lower bound of the range of asset links 284 * @param end the upper bound of the range of asset links (not inclusive) 285 * @return the range of matching asset links 286 */ 287 public static List<AssetLink> findByE2(long entryId2, int start, int end) { 288 return getPersistence().findByE2(entryId2, start, end); 289 } 290 291 /** 292 * Returns an ordered range of all the asset links where entryId2 = ?. 293 * 294 * <p> 295 * 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 AssetLinkModelImpl}. 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. 296 * </p> 297 * 298 * @param entryId2 the entry id2 299 * @param start the lower bound of the range of asset links 300 * @param end the upper bound of the range of asset links (not inclusive) 301 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 302 * @return the ordered range of matching asset links 303 */ 304 public static List<AssetLink> findByE2(long entryId2, int start, int end, 305 OrderByComparator<AssetLink> orderByComparator) { 306 return getPersistence().findByE2(entryId2, start, end, orderByComparator); 307 } 308 309 /** 310 * Returns an ordered range of all the asset links where entryId2 = ?. 311 * 312 * <p> 313 * 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 AssetLinkModelImpl}. 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. 314 * </p> 315 * 316 * @param entryId2 the entry id2 317 * @param start the lower bound of the range of asset links 318 * @param end the upper bound of the range of asset links (not inclusive) 319 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 320 * @param retrieveFromCache whether to retrieve from the finder cache 321 * @return the ordered range of matching asset links 322 */ 323 public static List<AssetLink> findByE2(long entryId2, int start, int end, 324 OrderByComparator<AssetLink> orderByComparator, 325 boolean retrieveFromCache) { 326 return getPersistence() 327 .findByE2(entryId2, start, end, orderByComparator, 328 retrieveFromCache); 329 } 330 331 /** 332 * Returns the first asset link in the ordered set where entryId2 = ?. 333 * 334 * @param entryId2 the entry id2 335 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 336 * @return the first matching asset link 337 * @throws NoSuchLinkException if a matching asset link could not be found 338 */ 339 public static AssetLink findByE2_First(long entryId2, 340 OrderByComparator<AssetLink> orderByComparator) 341 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 342 return getPersistence().findByE2_First(entryId2, orderByComparator); 343 } 344 345 /** 346 * Returns the first asset link in the ordered set where entryId2 = ?. 347 * 348 * @param entryId2 the entry id2 349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 350 * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found 351 */ 352 public static AssetLink fetchByE2_First(long entryId2, 353 OrderByComparator<AssetLink> orderByComparator) { 354 return getPersistence().fetchByE2_First(entryId2, orderByComparator); 355 } 356 357 /** 358 * Returns the last asset link in the ordered set where entryId2 = ?. 359 * 360 * @param entryId2 the entry id2 361 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 362 * @return the last matching asset link 363 * @throws NoSuchLinkException if a matching asset link could not be found 364 */ 365 public static AssetLink findByE2_Last(long entryId2, 366 OrderByComparator<AssetLink> orderByComparator) 367 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 368 return getPersistence().findByE2_Last(entryId2, orderByComparator); 369 } 370 371 /** 372 * Returns the last asset link in the ordered set where entryId2 = ?. 373 * 374 * @param entryId2 the entry id2 375 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 376 * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found 377 */ 378 public static AssetLink fetchByE2_Last(long entryId2, 379 OrderByComparator<AssetLink> orderByComparator) { 380 return getPersistence().fetchByE2_Last(entryId2, orderByComparator); 381 } 382 383 /** 384 * Returns the asset links before and after the current asset link in the ordered set where entryId2 = ?. 385 * 386 * @param linkId the primary key of the current asset link 387 * @param entryId2 the entry id2 388 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 389 * @return the previous, current, and next asset link 390 * @throws NoSuchLinkException if a asset link with the primary key could not be found 391 */ 392 public static AssetLink[] findByE2_PrevAndNext(long linkId, long entryId2, 393 OrderByComparator<AssetLink> orderByComparator) 394 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 395 return getPersistence() 396 .findByE2_PrevAndNext(linkId, entryId2, orderByComparator); 397 } 398 399 /** 400 * Removes all the asset links where entryId2 = ? from the database. 401 * 402 * @param entryId2 the entry id2 403 */ 404 public static void removeByE2(long entryId2) { 405 getPersistence().removeByE2(entryId2); 406 } 407 408 /** 409 * Returns the number of asset links where entryId2 = ?. 410 * 411 * @param entryId2 the entry id2 412 * @return the number of matching asset links 413 */ 414 public static int countByE2(long entryId2) { 415 return getPersistence().countByE2(entryId2); 416 } 417 418 /** 419 * Returns all the asset links where entryId1 = ? and entryId2 = ?. 420 * 421 * @param entryId1 the entry id1 422 * @param entryId2 the entry id2 423 * @return the matching asset links 424 */ 425 public static List<AssetLink> findByE_E(long entryId1, long entryId2) { 426 return getPersistence().findByE_E(entryId1, entryId2); 427 } 428 429 /** 430 * Returns a range of all the asset links where entryId1 = ? and entryId2 = ?. 431 * 432 * <p> 433 * 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 AssetLinkModelImpl}. 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. 434 * </p> 435 * 436 * @param entryId1 the entry id1 437 * @param entryId2 the entry id2 438 * @param start the lower bound of the range of asset links 439 * @param end the upper bound of the range of asset links (not inclusive) 440 * @return the range of matching asset links 441 */ 442 public static List<AssetLink> findByE_E(long entryId1, long entryId2, 443 int start, int end) { 444 return getPersistence().findByE_E(entryId1, entryId2, start, end); 445 } 446 447 /** 448 * Returns an ordered range of all the asset links where entryId1 = ? and entryId2 = ?. 449 * 450 * <p> 451 * 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 AssetLinkModelImpl}. 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. 452 * </p> 453 * 454 * @param entryId1 the entry id1 455 * @param entryId2 the entry id2 456 * @param start the lower bound of the range of asset links 457 * @param end the upper bound of the range of asset links (not inclusive) 458 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 459 * @return the ordered range of matching asset links 460 */ 461 public static List<AssetLink> findByE_E(long entryId1, long entryId2, 462 int start, int end, OrderByComparator<AssetLink> orderByComparator) { 463 return getPersistence() 464 .findByE_E(entryId1, entryId2, start, end, orderByComparator); 465 } 466 467 /** 468 * Returns an ordered range of all the asset links where entryId1 = ? and entryId2 = ?. 469 * 470 * <p> 471 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetLinkModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 472 * </p> 473 * 474 * @param entryId1 the entry id1 475 * @param entryId2 the entry id2 476 * @param start the lower bound of the range of asset links 477 * @param end the upper bound of the range of asset links (not inclusive) 478 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 479 * @param retrieveFromCache whether to retrieve from the finder cache 480 * @return the ordered range of matching asset links 481 */ 482 public static List<AssetLink> findByE_E(long entryId1, long entryId2, 483 int start, int end, OrderByComparator<AssetLink> orderByComparator, 484 boolean retrieveFromCache) { 485 return getPersistence() 486 .findByE_E(entryId1, entryId2, start, end, 487 orderByComparator, retrieveFromCache); 488 } 489 490 /** 491 * Returns the first asset link in the ordered set where entryId1 = ? and entryId2 = ?. 492 * 493 * @param entryId1 the entry id1 494 * @param entryId2 the entry id2 495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 496 * @return the first matching asset link 497 * @throws NoSuchLinkException if a matching asset link could not be found 498 */ 499 public static AssetLink findByE_E_First(long entryId1, long entryId2, 500 OrderByComparator<AssetLink> orderByComparator) 501 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 502 return getPersistence() 503 .findByE_E_First(entryId1, entryId2, orderByComparator); 504 } 505 506 /** 507 * Returns the first asset link in the ordered set where entryId1 = ? and entryId2 = ?. 508 * 509 * @param entryId1 the entry id1 510 * @param entryId2 the entry id2 511 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 512 * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found 513 */ 514 public static AssetLink fetchByE_E_First(long entryId1, long entryId2, 515 OrderByComparator<AssetLink> orderByComparator) { 516 return getPersistence() 517 .fetchByE_E_First(entryId1, entryId2, orderByComparator); 518 } 519 520 /** 521 * Returns the last asset link in the ordered set where entryId1 = ? and entryId2 = ?. 522 * 523 * @param entryId1 the entry id1 524 * @param entryId2 the entry id2 525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 526 * @return the last matching asset link 527 * @throws NoSuchLinkException if a matching asset link could not be found 528 */ 529 public static AssetLink findByE_E_Last(long entryId1, long entryId2, 530 OrderByComparator<AssetLink> orderByComparator) 531 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 532 return getPersistence() 533 .findByE_E_Last(entryId1, entryId2, orderByComparator); 534 } 535 536 /** 537 * Returns the last asset link in the ordered set where entryId1 = ? and entryId2 = ?. 538 * 539 * @param entryId1 the entry id1 540 * @param entryId2 the entry id2 541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 542 * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found 543 */ 544 public static AssetLink fetchByE_E_Last(long entryId1, long entryId2, 545 OrderByComparator<AssetLink> orderByComparator) { 546 return getPersistence() 547 .fetchByE_E_Last(entryId1, entryId2, orderByComparator); 548 } 549 550 /** 551 * Returns the asset links before and after the current asset link in the ordered set where entryId1 = ? and entryId2 = ?. 552 * 553 * @param linkId the primary key of the current asset link 554 * @param entryId1 the entry id1 555 * @param entryId2 the entry id2 556 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 557 * @return the previous, current, and next asset link 558 * @throws NoSuchLinkException if a asset link with the primary key could not be found 559 */ 560 public static AssetLink[] findByE_E_PrevAndNext(long linkId, long entryId1, 561 long entryId2, OrderByComparator<AssetLink> orderByComparator) 562 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 563 return getPersistence() 564 .findByE_E_PrevAndNext(linkId, entryId1, entryId2, 565 orderByComparator); 566 } 567 568 /** 569 * Removes all the asset links where entryId1 = ? and entryId2 = ? from the database. 570 * 571 * @param entryId1 the entry id1 572 * @param entryId2 the entry id2 573 */ 574 public static void removeByE_E(long entryId1, long entryId2) { 575 getPersistence().removeByE_E(entryId1, entryId2); 576 } 577 578 /** 579 * Returns the number of asset links where entryId1 = ? and entryId2 = ?. 580 * 581 * @param entryId1 the entry id1 582 * @param entryId2 the entry id2 583 * @return the number of matching asset links 584 */ 585 public static int countByE_E(long entryId1, long entryId2) { 586 return getPersistence().countByE_E(entryId1, entryId2); 587 } 588 589 /** 590 * Returns all the asset links where entryId1 = ? and type = ?. 591 * 592 * @param entryId1 the entry id1 593 * @param type the type 594 * @return the matching asset links 595 */ 596 public static List<AssetLink> findByE1_T(long entryId1, int type) { 597 return getPersistence().findByE1_T(entryId1, type); 598 } 599 600 /** 601 * Returns a range of all the asset links where entryId1 = ? and type = ?. 602 * 603 * <p> 604 * 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 AssetLinkModelImpl}. 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. 605 * </p> 606 * 607 * @param entryId1 the entry id1 608 * @param type the type 609 * @param start the lower bound of the range of asset links 610 * @param end the upper bound of the range of asset links (not inclusive) 611 * @return the range of matching asset links 612 */ 613 public static List<AssetLink> findByE1_T(long entryId1, int type, 614 int start, int end) { 615 return getPersistence().findByE1_T(entryId1, type, start, end); 616 } 617 618 /** 619 * Returns an ordered range of all the asset links where entryId1 = ? and type = ?. 620 * 621 * <p> 622 * 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 AssetLinkModelImpl}. 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. 623 * </p> 624 * 625 * @param entryId1 the entry id1 626 * @param type the type 627 * @param start the lower bound of the range of asset links 628 * @param end the upper bound of the range of asset links (not inclusive) 629 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 630 * @return the ordered range of matching asset links 631 */ 632 public static List<AssetLink> findByE1_T(long entryId1, int type, 633 int start, int end, OrderByComparator<AssetLink> orderByComparator) { 634 return getPersistence() 635 .findByE1_T(entryId1, type, start, end, orderByComparator); 636 } 637 638 /** 639 * Returns an ordered range of all the asset links where entryId1 = ? and type = ?. 640 * 641 * <p> 642 * 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 AssetLinkModelImpl}. 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. 643 * </p> 644 * 645 * @param entryId1 the entry id1 646 * @param type the type 647 * @param start the lower bound of the range of asset links 648 * @param end the upper bound of the range of asset links (not inclusive) 649 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 650 * @param retrieveFromCache whether to retrieve from the finder cache 651 * @return the ordered range of matching asset links 652 */ 653 public static List<AssetLink> findByE1_T(long entryId1, int type, 654 int start, int end, OrderByComparator<AssetLink> orderByComparator, 655 boolean retrieveFromCache) { 656 return getPersistence() 657 .findByE1_T(entryId1, type, start, end, orderByComparator, 658 retrieveFromCache); 659 } 660 661 /** 662 * Returns the first asset link in the ordered set where entryId1 = ? and type = ?. 663 * 664 * @param entryId1 the entry id1 665 * @param type the type 666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 667 * @return the first matching asset link 668 * @throws NoSuchLinkException if a matching asset link could not be found 669 */ 670 public static AssetLink findByE1_T_First(long entryId1, int type, 671 OrderByComparator<AssetLink> orderByComparator) 672 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 673 return getPersistence() 674 .findByE1_T_First(entryId1, type, orderByComparator); 675 } 676 677 /** 678 * Returns the first asset link in the ordered set where entryId1 = ? and type = ?. 679 * 680 * @param entryId1 the entry id1 681 * @param type the type 682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 683 * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found 684 */ 685 public static AssetLink fetchByE1_T_First(long entryId1, int type, 686 OrderByComparator<AssetLink> orderByComparator) { 687 return getPersistence() 688 .fetchByE1_T_First(entryId1, type, orderByComparator); 689 } 690 691 /** 692 * Returns the last asset link in the ordered set where entryId1 = ? and type = ?. 693 * 694 * @param entryId1 the entry id1 695 * @param type the type 696 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 697 * @return the last matching asset link 698 * @throws NoSuchLinkException if a matching asset link could not be found 699 */ 700 public static AssetLink findByE1_T_Last(long entryId1, int type, 701 OrderByComparator<AssetLink> orderByComparator) 702 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 703 return getPersistence() 704 .findByE1_T_Last(entryId1, type, orderByComparator); 705 } 706 707 /** 708 * Returns the last asset link in the ordered set where entryId1 = ? and type = ?. 709 * 710 * @param entryId1 the entry id1 711 * @param type the type 712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 713 * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found 714 */ 715 public static AssetLink fetchByE1_T_Last(long entryId1, int type, 716 OrderByComparator<AssetLink> orderByComparator) { 717 return getPersistence() 718 .fetchByE1_T_Last(entryId1, type, orderByComparator); 719 } 720 721 /** 722 * Returns the asset links before and after the current asset link in the ordered set where entryId1 = ? and type = ?. 723 * 724 * @param linkId the primary key of the current asset link 725 * @param entryId1 the entry id1 726 * @param type the type 727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 728 * @return the previous, current, and next asset link 729 * @throws NoSuchLinkException if a asset link with the primary key could not be found 730 */ 731 public static AssetLink[] findByE1_T_PrevAndNext(long linkId, 732 long entryId1, int type, OrderByComparator<AssetLink> orderByComparator) 733 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 734 return getPersistence() 735 .findByE1_T_PrevAndNext(linkId, entryId1, type, 736 orderByComparator); 737 } 738 739 /** 740 * Removes all the asset links where entryId1 = ? and type = ? from the database. 741 * 742 * @param entryId1 the entry id1 743 * @param type the type 744 */ 745 public static void removeByE1_T(long entryId1, int type) { 746 getPersistence().removeByE1_T(entryId1, type); 747 } 748 749 /** 750 * Returns the number of asset links where entryId1 = ? and type = ?. 751 * 752 * @param entryId1 the entry id1 753 * @param type the type 754 * @return the number of matching asset links 755 */ 756 public static int countByE1_T(long entryId1, int type) { 757 return getPersistence().countByE1_T(entryId1, type); 758 } 759 760 /** 761 * Returns all the asset links where entryId2 = ? and type = ?. 762 * 763 * @param entryId2 the entry id2 764 * @param type the type 765 * @return the matching asset links 766 */ 767 public static List<AssetLink> findByE2_T(long entryId2, int type) { 768 return getPersistence().findByE2_T(entryId2, type); 769 } 770 771 /** 772 * Returns a range of all the asset links where entryId2 = ? and type = ?. 773 * 774 * <p> 775 * 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 AssetLinkModelImpl}. 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. 776 * </p> 777 * 778 * @param entryId2 the entry id2 779 * @param type the type 780 * @param start the lower bound of the range of asset links 781 * @param end the upper bound of the range of asset links (not inclusive) 782 * @return the range of matching asset links 783 */ 784 public static List<AssetLink> findByE2_T(long entryId2, int type, 785 int start, int end) { 786 return getPersistence().findByE2_T(entryId2, type, start, end); 787 } 788 789 /** 790 * Returns an ordered range of all the asset links where entryId2 = ? and type = ?. 791 * 792 * <p> 793 * 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 AssetLinkModelImpl}. 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. 794 * </p> 795 * 796 * @param entryId2 the entry id2 797 * @param type the type 798 * @param start the lower bound of the range of asset links 799 * @param end the upper bound of the range of asset links (not inclusive) 800 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 801 * @return the ordered range of matching asset links 802 */ 803 public static List<AssetLink> findByE2_T(long entryId2, int type, 804 int start, int end, OrderByComparator<AssetLink> orderByComparator) { 805 return getPersistence() 806 .findByE2_T(entryId2, type, start, end, orderByComparator); 807 } 808 809 /** 810 * Returns an ordered range of all the asset links where entryId2 = ? and type = ?. 811 * 812 * <p> 813 * 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 AssetLinkModelImpl}. 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. 814 * </p> 815 * 816 * @param entryId2 the entry id2 817 * @param type the type 818 * @param start the lower bound of the range of asset links 819 * @param end the upper bound of the range of asset links (not inclusive) 820 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 821 * @param retrieveFromCache whether to retrieve from the finder cache 822 * @return the ordered range of matching asset links 823 */ 824 public static List<AssetLink> findByE2_T(long entryId2, int type, 825 int start, int end, OrderByComparator<AssetLink> orderByComparator, 826 boolean retrieveFromCache) { 827 return getPersistence() 828 .findByE2_T(entryId2, type, start, end, orderByComparator, 829 retrieveFromCache); 830 } 831 832 /** 833 * Returns the first asset link in the ordered set where entryId2 = ? and type = ?. 834 * 835 * @param entryId2 the entry id2 836 * @param type the type 837 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 838 * @return the first matching asset link 839 * @throws NoSuchLinkException if a matching asset link could not be found 840 */ 841 public static AssetLink findByE2_T_First(long entryId2, int type, 842 OrderByComparator<AssetLink> orderByComparator) 843 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 844 return getPersistence() 845 .findByE2_T_First(entryId2, type, orderByComparator); 846 } 847 848 /** 849 * Returns the first asset link in the ordered set where entryId2 = ? and type = ?. 850 * 851 * @param entryId2 the entry id2 852 * @param type the type 853 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 854 * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found 855 */ 856 public static AssetLink fetchByE2_T_First(long entryId2, int type, 857 OrderByComparator<AssetLink> orderByComparator) { 858 return getPersistence() 859 .fetchByE2_T_First(entryId2, type, orderByComparator); 860 } 861 862 /** 863 * Returns the last asset link in the ordered set where entryId2 = ? and type = ?. 864 * 865 * @param entryId2 the entry id2 866 * @param type the type 867 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 868 * @return the last matching asset link 869 * @throws NoSuchLinkException if a matching asset link could not be found 870 */ 871 public static AssetLink findByE2_T_Last(long entryId2, int type, 872 OrderByComparator<AssetLink> orderByComparator) 873 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 874 return getPersistence() 875 .findByE2_T_Last(entryId2, type, orderByComparator); 876 } 877 878 /** 879 * Returns the last asset link in the ordered set where entryId2 = ? and type = ?. 880 * 881 * @param entryId2 the entry id2 882 * @param type the type 883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 884 * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found 885 */ 886 public static AssetLink fetchByE2_T_Last(long entryId2, int type, 887 OrderByComparator<AssetLink> orderByComparator) { 888 return getPersistence() 889 .fetchByE2_T_Last(entryId2, type, orderByComparator); 890 } 891 892 /** 893 * Returns the asset links before and after the current asset link in the ordered set where entryId2 = ? and type = ?. 894 * 895 * @param linkId the primary key of the current asset link 896 * @param entryId2 the entry id2 897 * @param type the type 898 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 899 * @return the previous, current, and next asset link 900 * @throws NoSuchLinkException if a asset link with the primary key could not be found 901 */ 902 public static AssetLink[] findByE2_T_PrevAndNext(long linkId, 903 long entryId2, int type, OrderByComparator<AssetLink> orderByComparator) 904 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 905 return getPersistence() 906 .findByE2_T_PrevAndNext(linkId, entryId2, type, 907 orderByComparator); 908 } 909 910 /** 911 * Removes all the asset links where entryId2 = ? and type = ? from the database. 912 * 913 * @param entryId2 the entry id2 914 * @param type the type 915 */ 916 public static void removeByE2_T(long entryId2, int type) { 917 getPersistence().removeByE2_T(entryId2, type); 918 } 919 920 /** 921 * Returns the number of asset links where entryId2 = ? and type = ?. 922 * 923 * @param entryId2 the entry id2 924 * @param type the type 925 * @return the number of matching asset links 926 */ 927 public static int countByE2_T(long entryId2, int type) { 928 return getPersistence().countByE2_T(entryId2, type); 929 } 930 931 /** 932 * Returns the asset link where entryId1 = ? and entryId2 = ? and type = ? or throws a {@link NoSuchLinkException} if it could not be found. 933 * 934 * @param entryId1 the entry id1 935 * @param entryId2 the entry id2 936 * @param type the type 937 * @return the matching asset link 938 * @throws NoSuchLinkException if a matching asset link could not be found 939 */ 940 public static AssetLink findByE_E_T(long entryId1, long entryId2, int type) 941 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 942 return getPersistence().findByE_E_T(entryId1, entryId2, type); 943 } 944 945 /** 946 * Returns the asset link where entryId1 = ? and entryId2 = ? and type = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 947 * 948 * @param entryId1 the entry id1 949 * @param entryId2 the entry id2 950 * @param type the type 951 * @return the matching asset link, or <code>null</code> if a matching asset link could not be found 952 */ 953 public static AssetLink fetchByE_E_T(long entryId1, long entryId2, int type) { 954 return getPersistence().fetchByE_E_T(entryId1, entryId2, type); 955 } 956 957 /** 958 * Returns the asset link where entryId1 = ? and entryId2 = ? and type = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 959 * 960 * @param entryId1 the entry id1 961 * @param entryId2 the entry id2 962 * @param type the type 963 * @param retrieveFromCache whether to retrieve from the finder cache 964 * @return the matching asset link, or <code>null</code> if a matching asset link could not be found 965 */ 966 public static AssetLink fetchByE_E_T(long entryId1, long entryId2, 967 int type, boolean retrieveFromCache) { 968 return getPersistence() 969 .fetchByE_E_T(entryId1, entryId2, type, retrieveFromCache); 970 } 971 972 /** 973 * Removes the asset link where entryId1 = ? and entryId2 = ? and type = ? from the database. 974 * 975 * @param entryId1 the entry id1 976 * @param entryId2 the entry id2 977 * @param type the type 978 * @return the asset link that was removed 979 */ 980 public static AssetLink removeByE_E_T(long entryId1, long entryId2, int type) 981 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 982 return getPersistence().removeByE_E_T(entryId1, entryId2, type); 983 } 984 985 /** 986 * Returns the number of asset links where entryId1 = ? and entryId2 = ? and type = ?. 987 * 988 * @param entryId1 the entry id1 989 * @param entryId2 the entry id2 990 * @param type the type 991 * @return the number of matching asset links 992 */ 993 public static int countByE_E_T(long entryId1, long entryId2, int type) { 994 return getPersistence().countByE_E_T(entryId1, entryId2, type); 995 } 996 997 /** 998 * Caches the asset link in the entity cache if it is enabled. 999 * 1000 * @param assetLink the asset link 1001 */ 1002 public static void cacheResult(AssetLink assetLink) { 1003 getPersistence().cacheResult(assetLink); 1004 } 1005 1006 /** 1007 * Caches the asset links in the entity cache if it is enabled. 1008 * 1009 * @param assetLinks the asset links 1010 */ 1011 public static void cacheResult(List<AssetLink> assetLinks) { 1012 getPersistence().cacheResult(assetLinks); 1013 } 1014 1015 /** 1016 * Creates a new asset link with the primary key. Does not add the asset link to the database. 1017 * 1018 * @param linkId the primary key for the new asset link 1019 * @return the new asset link 1020 */ 1021 public static AssetLink create(long linkId) { 1022 return getPersistence().create(linkId); 1023 } 1024 1025 /** 1026 * Removes the asset link with the primary key from the database. Also notifies the appropriate model listeners. 1027 * 1028 * @param linkId the primary key of the asset link 1029 * @return the asset link that was removed 1030 * @throws NoSuchLinkException if a asset link with the primary key could not be found 1031 */ 1032 public static AssetLink remove(long linkId) 1033 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 1034 return getPersistence().remove(linkId); 1035 } 1036 1037 public static AssetLink updateImpl(AssetLink assetLink) { 1038 return getPersistence().updateImpl(assetLink); 1039 } 1040 1041 /** 1042 * Returns the asset link with the primary key or throws a {@link NoSuchLinkException} if it could not be found. 1043 * 1044 * @param linkId the primary key of the asset link 1045 * @return the asset link 1046 * @throws NoSuchLinkException if a asset link with the primary key could not be found 1047 */ 1048 public static AssetLink findByPrimaryKey(long linkId) 1049 throws com.liferay.portlet.asset.exception.NoSuchLinkException { 1050 return getPersistence().findByPrimaryKey(linkId); 1051 } 1052 1053 /** 1054 * Returns the asset link with the primary key or returns <code>null</code> if it could not be found. 1055 * 1056 * @param linkId the primary key of the asset link 1057 * @return the asset link, or <code>null</code> if a asset link with the primary key could not be found 1058 */ 1059 public static AssetLink fetchByPrimaryKey(long linkId) { 1060 return getPersistence().fetchByPrimaryKey(linkId); 1061 } 1062 1063 public static java.util.Map<java.io.Serializable, AssetLink> fetchByPrimaryKeys( 1064 java.util.Set<java.io.Serializable> primaryKeys) { 1065 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1066 } 1067 1068 /** 1069 * Returns all the asset links. 1070 * 1071 * @return the asset links 1072 */ 1073 public static List<AssetLink> findAll() { 1074 return getPersistence().findAll(); 1075 } 1076 1077 /** 1078 * Returns a range of all the asset links. 1079 * 1080 * <p> 1081 * 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 AssetLinkModelImpl}. 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. 1082 * </p> 1083 * 1084 * @param start the lower bound of the range of asset links 1085 * @param end the upper bound of the range of asset links (not inclusive) 1086 * @return the range of asset links 1087 */ 1088 public static List<AssetLink> findAll(int start, int end) { 1089 return getPersistence().findAll(start, end); 1090 } 1091 1092 /** 1093 * Returns an ordered range of all the asset links. 1094 * 1095 * <p> 1096 * 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 AssetLinkModelImpl}. 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. 1097 * </p> 1098 * 1099 * @param start the lower bound of the range of asset links 1100 * @param end the upper bound of the range of asset links (not inclusive) 1101 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1102 * @return the ordered range of asset links 1103 */ 1104 public static List<AssetLink> findAll(int start, int end, 1105 OrderByComparator<AssetLink> orderByComparator) { 1106 return getPersistence().findAll(start, end, orderByComparator); 1107 } 1108 1109 /** 1110 * Returns an ordered range of all the asset links. 1111 * 1112 * <p> 1113 * 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 AssetLinkModelImpl}. 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. 1114 * </p> 1115 * 1116 * @param start the lower bound of the range of asset links 1117 * @param end the upper bound of the range of asset links (not inclusive) 1118 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1119 * @param retrieveFromCache whether to retrieve from the finder cache 1120 * @return the ordered range of asset links 1121 */ 1122 public static List<AssetLink> findAll(int start, int end, 1123 OrderByComparator<AssetLink> orderByComparator, 1124 boolean retrieveFromCache) { 1125 return getPersistence() 1126 .findAll(start, end, orderByComparator, retrieveFromCache); 1127 } 1128 1129 /** 1130 * Removes all the asset links from the database. 1131 */ 1132 public static void removeAll() { 1133 getPersistence().removeAll(); 1134 } 1135 1136 /** 1137 * Returns the number of asset links. 1138 * 1139 * @return the number of asset links 1140 */ 1141 public static int countAll() { 1142 return getPersistence().countAll(); 1143 } 1144 1145 public static java.util.Set<java.lang.String> getBadColumnNames() { 1146 return getPersistence().getBadColumnNames(); 1147 } 1148 1149 public static AssetLinkPersistence getPersistence() { 1150 if (_persistence == null) { 1151 _persistence = (AssetLinkPersistence)PortalBeanLocatorUtil.locate(AssetLinkPersistence.class.getName()); 1152 1153 ReferenceRegistry.registerReference(AssetLinkUtil.class, 1154 "_persistence"); 1155 } 1156 1157 return _persistence; 1158 } 1159 1160 private static AssetLinkPersistence _persistence; 1161 }