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.AssetEntry; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset entry service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl} 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 AssetEntryPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetEntryUtil { 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(AssetEntry assetEntry) { 060 getPersistence().clearCache(assetEntry); 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<AssetEntry> 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<AssetEntry> 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<AssetEntry> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetEntry> 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 AssetEntry update(AssetEntry assetEntry) { 101 return getPersistence().update(assetEntry); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static AssetEntry update(AssetEntry assetEntry, 108 ServiceContext serviceContext) { 109 return getPersistence().update(assetEntry, serviceContext); 110 } 111 112 /** 113 * Returns all the asset entries where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching asset entries 117 */ 118 public static List<AssetEntry> findByGroupId(long groupId) { 119 return getPersistence().findByGroupId(groupId); 120 } 121 122 /** 123 * Returns a range of all the asset entries where groupId = ?. 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 AssetEntryModelImpl}. 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 groupId the group ID 130 * @param start the lower bound of the range of asset entries 131 * @param end the upper bound of the range of asset entries (not inclusive) 132 * @return the range of matching asset entries 133 */ 134 public static List<AssetEntry> findByGroupId(long groupId, int start, 135 int end) { 136 return getPersistence().findByGroupId(groupId, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the asset entries where groupId = ?. 141 * 142 * <p> 143 * 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 AssetEntryModelImpl}. 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. 144 * </p> 145 * 146 * @param groupId the group ID 147 * @param start the lower bound of the range of asset entries 148 * @param end the upper bound of the range of asset entries (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching asset entries 151 */ 152 public static List<AssetEntry> findByGroupId(long groupId, int start, 153 int end, OrderByComparator<AssetEntry> orderByComparator) { 154 return getPersistence() 155 .findByGroupId(groupId, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns the first asset entry in the ordered set where groupId = ?. 160 * 161 * @param groupId the group ID 162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 163 * @return the first matching asset entry 164 * @throws NoSuchEntryException if a matching asset entry could not be found 165 */ 166 public static AssetEntry findByGroupId_First(long groupId, 167 OrderByComparator<AssetEntry> orderByComparator) 168 throws com.liferay.portlet.asset.NoSuchEntryException { 169 return getPersistence().findByGroupId_First(groupId, orderByComparator); 170 } 171 172 /** 173 * Returns the first asset entry in the ordered set where groupId = ?. 174 * 175 * @param groupId the group ID 176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 177 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 178 */ 179 public static AssetEntry fetchByGroupId_First(long groupId, 180 OrderByComparator<AssetEntry> orderByComparator) { 181 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 182 } 183 184 /** 185 * Returns the last asset entry in the ordered set where groupId = ?. 186 * 187 * @param groupId the group ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the last matching asset entry 190 * @throws NoSuchEntryException if a matching asset entry could not be found 191 */ 192 public static AssetEntry findByGroupId_Last(long groupId, 193 OrderByComparator<AssetEntry> orderByComparator) 194 throws com.liferay.portlet.asset.NoSuchEntryException { 195 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 196 } 197 198 /** 199 * Returns the last asset entry in the ordered set where groupId = ?. 200 * 201 * @param groupId the group ID 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 204 */ 205 public static AssetEntry fetchByGroupId_Last(long groupId, 206 OrderByComparator<AssetEntry> orderByComparator) { 207 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 208 } 209 210 /** 211 * Returns the asset entries before and after the current asset entry in the ordered set where groupId = ?. 212 * 213 * @param entryId the primary key of the current asset entry 214 * @param groupId the group ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the previous, current, and next asset entry 217 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 218 */ 219 public static AssetEntry[] findByGroupId_PrevAndNext(long entryId, 220 long groupId, OrderByComparator<AssetEntry> orderByComparator) 221 throws com.liferay.portlet.asset.NoSuchEntryException { 222 return getPersistence() 223 .findByGroupId_PrevAndNext(entryId, groupId, 224 orderByComparator); 225 } 226 227 /** 228 * Removes all the asset entries where groupId = ? from the database. 229 * 230 * @param groupId the group ID 231 */ 232 public static void removeByGroupId(long groupId) { 233 getPersistence().removeByGroupId(groupId); 234 } 235 236 /** 237 * Returns the number of asset entries where groupId = ?. 238 * 239 * @param groupId the group ID 240 * @return the number of matching asset entries 241 */ 242 public static int countByGroupId(long groupId) { 243 return getPersistence().countByGroupId(groupId); 244 } 245 246 /** 247 * Returns all the asset entries where companyId = ?. 248 * 249 * @param companyId the company ID 250 * @return the matching asset entries 251 */ 252 public static List<AssetEntry> findByCompanyId(long companyId) { 253 return getPersistence().findByCompanyId(companyId); 254 } 255 256 /** 257 * Returns a range of all the asset entries where companyId = ?. 258 * 259 * <p> 260 * 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 AssetEntryModelImpl}. 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. 261 * </p> 262 * 263 * @param companyId the company ID 264 * @param start the lower bound of the range of asset entries 265 * @param end the upper bound of the range of asset entries (not inclusive) 266 * @return the range of matching asset entries 267 */ 268 public static List<AssetEntry> findByCompanyId(long companyId, int start, 269 int end) { 270 return getPersistence().findByCompanyId(companyId, start, end); 271 } 272 273 /** 274 * Returns an ordered range of all the asset entries where companyId = ?. 275 * 276 * <p> 277 * 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 AssetEntryModelImpl}. 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. 278 * </p> 279 * 280 * @param companyId the company ID 281 * @param start the lower bound of the range of asset entries 282 * @param end the upper bound of the range of asset entries (not inclusive) 283 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 284 * @return the ordered range of matching asset entries 285 */ 286 public static List<AssetEntry> findByCompanyId(long companyId, int start, 287 int end, OrderByComparator<AssetEntry> orderByComparator) { 288 return getPersistence() 289 .findByCompanyId(companyId, start, end, orderByComparator); 290 } 291 292 /** 293 * Returns the first asset entry in the ordered set where companyId = ?. 294 * 295 * @param companyId the company ID 296 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 297 * @return the first matching asset entry 298 * @throws NoSuchEntryException if a matching asset entry could not be found 299 */ 300 public static AssetEntry findByCompanyId_First(long companyId, 301 OrderByComparator<AssetEntry> orderByComparator) 302 throws com.liferay.portlet.asset.NoSuchEntryException { 303 return getPersistence() 304 .findByCompanyId_First(companyId, orderByComparator); 305 } 306 307 /** 308 * Returns the first asset entry in the ordered set where companyId = ?. 309 * 310 * @param companyId the company ID 311 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 312 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 313 */ 314 public static AssetEntry fetchByCompanyId_First(long companyId, 315 OrderByComparator<AssetEntry> orderByComparator) { 316 return getPersistence() 317 .fetchByCompanyId_First(companyId, orderByComparator); 318 } 319 320 /** 321 * Returns the last asset entry in the ordered set where companyId = ?. 322 * 323 * @param companyId the company ID 324 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 325 * @return the last matching asset entry 326 * @throws NoSuchEntryException if a matching asset entry could not be found 327 */ 328 public static AssetEntry findByCompanyId_Last(long companyId, 329 OrderByComparator<AssetEntry> orderByComparator) 330 throws com.liferay.portlet.asset.NoSuchEntryException { 331 return getPersistence() 332 .findByCompanyId_Last(companyId, orderByComparator); 333 } 334 335 /** 336 * Returns the last asset entry in the ordered set where companyId = ?. 337 * 338 * @param companyId the company ID 339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 340 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 341 */ 342 public static AssetEntry fetchByCompanyId_Last(long companyId, 343 OrderByComparator<AssetEntry> orderByComparator) { 344 return getPersistence() 345 .fetchByCompanyId_Last(companyId, orderByComparator); 346 } 347 348 /** 349 * Returns the asset entries before and after the current asset entry in the ordered set where companyId = ?. 350 * 351 * @param entryId the primary key of the current asset entry 352 * @param companyId the company ID 353 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 354 * @return the previous, current, and next asset entry 355 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 356 */ 357 public static AssetEntry[] findByCompanyId_PrevAndNext(long entryId, 358 long companyId, OrderByComparator<AssetEntry> orderByComparator) 359 throws com.liferay.portlet.asset.NoSuchEntryException { 360 return getPersistence() 361 .findByCompanyId_PrevAndNext(entryId, companyId, 362 orderByComparator); 363 } 364 365 /** 366 * Removes all the asset entries where companyId = ? from the database. 367 * 368 * @param companyId the company ID 369 */ 370 public static void removeByCompanyId(long companyId) { 371 getPersistence().removeByCompanyId(companyId); 372 } 373 374 /** 375 * Returns the number of asset entries where companyId = ?. 376 * 377 * @param companyId the company ID 378 * @return the number of matching asset entries 379 */ 380 public static int countByCompanyId(long companyId) { 381 return getPersistence().countByCompanyId(companyId); 382 } 383 384 /** 385 * Returns all the asset entries where visible = ?. 386 * 387 * @param visible the visible 388 * @return the matching asset entries 389 */ 390 public static List<AssetEntry> findByVisible(boolean visible) { 391 return getPersistence().findByVisible(visible); 392 } 393 394 /** 395 * Returns a range of all the asset entries where visible = ?. 396 * 397 * <p> 398 * 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 AssetEntryModelImpl}. 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. 399 * </p> 400 * 401 * @param visible the visible 402 * @param start the lower bound of the range of asset entries 403 * @param end the upper bound of the range of asset entries (not inclusive) 404 * @return the range of matching asset entries 405 */ 406 public static List<AssetEntry> findByVisible(boolean visible, int start, 407 int end) { 408 return getPersistence().findByVisible(visible, start, end); 409 } 410 411 /** 412 * Returns an ordered range of all the asset entries where visible = ?. 413 * 414 * <p> 415 * 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 AssetEntryModelImpl}. 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. 416 * </p> 417 * 418 * @param visible the visible 419 * @param start the lower bound of the range of asset entries 420 * @param end the upper bound of the range of asset entries (not inclusive) 421 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 422 * @return the ordered range of matching asset entries 423 */ 424 public static List<AssetEntry> findByVisible(boolean visible, int start, 425 int end, OrderByComparator<AssetEntry> orderByComparator) { 426 return getPersistence() 427 .findByVisible(visible, start, end, orderByComparator); 428 } 429 430 /** 431 * Returns the first asset entry in the ordered set where visible = ?. 432 * 433 * @param visible the visible 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the first matching asset entry 436 * @throws NoSuchEntryException if a matching asset entry could not be found 437 */ 438 public static AssetEntry findByVisible_First(boolean visible, 439 OrderByComparator<AssetEntry> orderByComparator) 440 throws com.liferay.portlet.asset.NoSuchEntryException { 441 return getPersistence().findByVisible_First(visible, orderByComparator); 442 } 443 444 /** 445 * Returns the first asset entry in the ordered set where visible = ?. 446 * 447 * @param visible the visible 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 450 */ 451 public static AssetEntry fetchByVisible_First(boolean visible, 452 OrderByComparator<AssetEntry> orderByComparator) { 453 return getPersistence().fetchByVisible_First(visible, orderByComparator); 454 } 455 456 /** 457 * Returns the last asset entry in the ordered set where visible = ?. 458 * 459 * @param visible the visible 460 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 461 * @return the last matching asset entry 462 * @throws NoSuchEntryException if a matching asset entry could not be found 463 */ 464 public static AssetEntry findByVisible_Last(boolean visible, 465 OrderByComparator<AssetEntry> orderByComparator) 466 throws com.liferay.portlet.asset.NoSuchEntryException { 467 return getPersistence().findByVisible_Last(visible, orderByComparator); 468 } 469 470 /** 471 * Returns the last asset entry in the ordered set where visible = ?. 472 * 473 * @param visible the visible 474 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 475 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 476 */ 477 public static AssetEntry fetchByVisible_Last(boolean visible, 478 OrderByComparator<AssetEntry> orderByComparator) { 479 return getPersistence().fetchByVisible_Last(visible, orderByComparator); 480 } 481 482 /** 483 * Returns the asset entries before and after the current asset entry in the ordered set where visible = ?. 484 * 485 * @param entryId the primary key of the current asset entry 486 * @param visible the visible 487 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 488 * @return the previous, current, and next asset entry 489 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 490 */ 491 public static AssetEntry[] findByVisible_PrevAndNext(long entryId, 492 boolean visible, OrderByComparator<AssetEntry> orderByComparator) 493 throws com.liferay.portlet.asset.NoSuchEntryException { 494 return getPersistence() 495 .findByVisible_PrevAndNext(entryId, visible, 496 orderByComparator); 497 } 498 499 /** 500 * Removes all the asset entries where visible = ? from the database. 501 * 502 * @param visible the visible 503 */ 504 public static void removeByVisible(boolean visible) { 505 getPersistence().removeByVisible(visible); 506 } 507 508 /** 509 * Returns the number of asset entries where visible = ?. 510 * 511 * @param visible the visible 512 * @return the number of matching asset entries 513 */ 514 public static int countByVisible(boolean visible) { 515 return getPersistence().countByVisible(visible); 516 } 517 518 /** 519 * Returns all the asset entries where publishDate = ?. 520 * 521 * @param publishDate the publish date 522 * @return the matching asset entries 523 */ 524 public static List<AssetEntry> findByPublishDate(java.util.Date publishDate) { 525 return getPersistence().findByPublishDate(publishDate); 526 } 527 528 /** 529 * Returns a range of all the asset entries where publishDate = ?. 530 * 531 * <p> 532 * 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 AssetEntryModelImpl}. 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. 533 * </p> 534 * 535 * @param publishDate the publish date 536 * @param start the lower bound of the range of asset entries 537 * @param end the upper bound of the range of asset entries (not inclusive) 538 * @return the range of matching asset entries 539 */ 540 public static List<AssetEntry> findByPublishDate( 541 java.util.Date publishDate, int start, int end) { 542 return getPersistence().findByPublishDate(publishDate, start, end); 543 } 544 545 /** 546 * Returns an ordered range of all the asset entries where publishDate = ?. 547 * 548 * <p> 549 * 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 AssetEntryModelImpl}. 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. 550 * </p> 551 * 552 * @param publishDate the publish date 553 * @param start the lower bound of the range of asset entries 554 * @param end the upper bound of the range of asset entries (not inclusive) 555 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 556 * @return the ordered range of matching asset entries 557 */ 558 public static List<AssetEntry> findByPublishDate( 559 java.util.Date publishDate, int start, int end, 560 OrderByComparator<AssetEntry> orderByComparator) { 561 return getPersistence() 562 .findByPublishDate(publishDate, start, end, orderByComparator); 563 } 564 565 /** 566 * Returns the first asset entry in the ordered set where publishDate = ?. 567 * 568 * @param publishDate the publish date 569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 570 * @return the first matching asset entry 571 * @throws NoSuchEntryException if a matching asset entry could not be found 572 */ 573 public static AssetEntry findByPublishDate_First( 574 java.util.Date publishDate, 575 OrderByComparator<AssetEntry> orderByComparator) 576 throws com.liferay.portlet.asset.NoSuchEntryException { 577 return getPersistence() 578 .findByPublishDate_First(publishDate, orderByComparator); 579 } 580 581 /** 582 * Returns the first asset entry in the ordered set where publishDate = ?. 583 * 584 * @param publishDate the publish date 585 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 586 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 587 */ 588 public static AssetEntry fetchByPublishDate_First( 589 java.util.Date publishDate, 590 OrderByComparator<AssetEntry> orderByComparator) { 591 return getPersistence() 592 .fetchByPublishDate_First(publishDate, orderByComparator); 593 } 594 595 /** 596 * Returns the last asset entry in the ordered set where publishDate = ?. 597 * 598 * @param publishDate the publish date 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the last matching asset entry 601 * @throws NoSuchEntryException if a matching asset entry could not be found 602 */ 603 public static AssetEntry findByPublishDate_Last( 604 java.util.Date publishDate, 605 OrderByComparator<AssetEntry> orderByComparator) 606 throws com.liferay.portlet.asset.NoSuchEntryException { 607 return getPersistence() 608 .findByPublishDate_Last(publishDate, orderByComparator); 609 } 610 611 /** 612 * Returns the last asset entry in the ordered set where publishDate = ?. 613 * 614 * @param publishDate the publish date 615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 616 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 617 */ 618 public static AssetEntry fetchByPublishDate_Last( 619 java.util.Date publishDate, 620 OrderByComparator<AssetEntry> orderByComparator) { 621 return getPersistence() 622 .fetchByPublishDate_Last(publishDate, orderByComparator); 623 } 624 625 /** 626 * Returns the asset entries before and after the current asset entry in the ordered set where publishDate = ?. 627 * 628 * @param entryId the primary key of the current asset entry 629 * @param publishDate the publish date 630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 631 * @return the previous, current, and next asset entry 632 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 633 */ 634 public static AssetEntry[] findByPublishDate_PrevAndNext(long entryId, 635 java.util.Date publishDate, 636 OrderByComparator<AssetEntry> orderByComparator) 637 throws com.liferay.portlet.asset.NoSuchEntryException { 638 return getPersistence() 639 .findByPublishDate_PrevAndNext(entryId, publishDate, 640 orderByComparator); 641 } 642 643 /** 644 * Removes all the asset entries where publishDate = ? from the database. 645 * 646 * @param publishDate the publish date 647 */ 648 public static void removeByPublishDate(java.util.Date publishDate) { 649 getPersistence().removeByPublishDate(publishDate); 650 } 651 652 /** 653 * Returns the number of asset entries where publishDate = ?. 654 * 655 * @param publishDate the publish date 656 * @return the number of matching asset entries 657 */ 658 public static int countByPublishDate(java.util.Date publishDate) { 659 return getPersistence().countByPublishDate(publishDate); 660 } 661 662 /** 663 * Returns all the asset entries where expirationDate = ?. 664 * 665 * @param expirationDate the expiration date 666 * @return the matching asset entries 667 */ 668 public static List<AssetEntry> findByExpirationDate( 669 java.util.Date expirationDate) { 670 return getPersistence().findByExpirationDate(expirationDate); 671 } 672 673 /** 674 * Returns a range of all the asset entries where expirationDate = ?. 675 * 676 * <p> 677 * 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 AssetEntryModelImpl}. 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. 678 * </p> 679 * 680 * @param expirationDate the expiration date 681 * @param start the lower bound of the range of asset entries 682 * @param end the upper bound of the range of asset entries (not inclusive) 683 * @return the range of matching asset entries 684 */ 685 public static List<AssetEntry> findByExpirationDate( 686 java.util.Date expirationDate, int start, int end) { 687 return getPersistence().findByExpirationDate(expirationDate, start, end); 688 } 689 690 /** 691 * Returns an ordered range of all the asset entries where expirationDate = ?. 692 * 693 * <p> 694 * 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 AssetEntryModelImpl}. 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. 695 * </p> 696 * 697 * @param expirationDate the expiration date 698 * @param start the lower bound of the range of asset entries 699 * @param end the upper bound of the range of asset entries (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @return the ordered range of matching asset entries 702 */ 703 public static List<AssetEntry> findByExpirationDate( 704 java.util.Date expirationDate, int start, int end, 705 OrderByComparator<AssetEntry> orderByComparator) { 706 return getPersistence() 707 .findByExpirationDate(expirationDate, start, end, 708 orderByComparator); 709 } 710 711 /** 712 * Returns the first asset entry in the ordered set where expirationDate = ?. 713 * 714 * @param expirationDate the expiration date 715 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 716 * @return the first matching asset entry 717 * @throws NoSuchEntryException if a matching asset entry could not be found 718 */ 719 public static AssetEntry findByExpirationDate_First( 720 java.util.Date expirationDate, 721 OrderByComparator<AssetEntry> orderByComparator) 722 throws com.liferay.portlet.asset.NoSuchEntryException { 723 return getPersistence() 724 .findByExpirationDate_First(expirationDate, orderByComparator); 725 } 726 727 /** 728 * Returns the first asset entry in the ordered set where expirationDate = ?. 729 * 730 * @param expirationDate the expiration date 731 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 732 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 733 */ 734 public static AssetEntry fetchByExpirationDate_First( 735 java.util.Date expirationDate, 736 OrderByComparator<AssetEntry> orderByComparator) { 737 return getPersistence() 738 .fetchByExpirationDate_First(expirationDate, 739 orderByComparator); 740 } 741 742 /** 743 * Returns the last asset entry in the ordered set where expirationDate = ?. 744 * 745 * @param expirationDate the expiration date 746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 747 * @return the last matching asset entry 748 * @throws NoSuchEntryException if a matching asset entry could not be found 749 */ 750 public static AssetEntry findByExpirationDate_Last( 751 java.util.Date expirationDate, 752 OrderByComparator<AssetEntry> orderByComparator) 753 throws com.liferay.portlet.asset.NoSuchEntryException { 754 return getPersistence() 755 .findByExpirationDate_Last(expirationDate, orderByComparator); 756 } 757 758 /** 759 * Returns the last asset entry in the ordered set where expirationDate = ?. 760 * 761 * @param expirationDate the expiration date 762 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 763 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 764 */ 765 public static AssetEntry fetchByExpirationDate_Last( 766 java.util.Date expirationDate, 767 OrderByComparator<AssetEntry> orderByComparator) { 768 return getPersistence() 769 .fetchByExpirationDate_Last(expirationDate, orderByComparator); 770 } 771 772 /** 773 * Returns the asset entries before and after the current asset entry in the ordered set where expirationDate = ?. 774 * 775 * @param entryId the primary key of the current asset entry 776 * @param expirationDate the expiration date 777 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 778 * @return the previous, current, and next asset entry 779 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 780 */ 781 public static AssetEntry[] findByExpirationDate_PrevAndNext(long entryId, 782 java.util.Date expirationDate, 783 OrderByComparator<AssetEntry> orderByComparator) 784 throws com.liferay.portlet.asset.NoSuchEntryException { 785 return getPersistence() 786 .findByExpirationDate_PrevAndNext(entryId, expirationDate, 787 orderByComparator); 788 } 789 790 /** 791 * Removes all the asset entries where expirationDate = ? from the database. 792 * 793 * @param expirationDate the expiration date 794 */ 795 public static void removeByExpirationDate(java.util.Date expirationDate) { 796 getPersistence().removeByExpirationDate(expirationDate); 797 } 798 799 /** 800 * Returns the number of asset entries where expirationDate = ?. 801 * 802 * @param expirationDate the expiration date 803 * @return the number of matching asset entries 804 */ 805 public static int countByExpirationDate(java.util.Date expirationDate) { 806 return getPersistence().countByExpirationDate(expirationDate); 807 } 808 809 /** 810 * Returns all the asset entries where layoutUuid = ?. 811 * 812 * @param layoutUuid the layout uuid 813 * @return the matching asset entries 814 */ 815 public static List<AssetEntry> findByLayoutUuid(java.lang.String layoutUuid) { 816 return getPersistence().findByLayoutUuid(layoutUuid); 817 } 818 819 /** 820 * Returns a range of all the asset entries where layoutUuid = ?. 821 * 822 * <p> 823 * 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 AssetEntryModelImpl}. 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. 824 * </p> 825 * 826 * @param layoutUuid the layout uuid 827 * @param start the lower bound of the range of asset entries 828 * @param end the upper bound of the range of asset entries (not inclusive) 829 * @return the range of matching asset entries 830 */ 831 public static List<AssetEntry> findByLayoutUuid( 832 java.lang.String layoutUuid, int start, int end) { 833 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 834 } 835 836 /** 837 * Returns an ordered range of all the asset entries where layoutUuid = ?. 838 * 839 * <p> 840 * 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 AssetEntryModelImpl}. 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. 841 * </p> 842 * 843 * @param layoutUuid the layout uuid 844 * @param start the lower bound of the range of asset entries 845 * @param end the upper bound of the range of asset entries (not inclusive) 846 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 847 * @return the ordered range of matching asset entries 848 */ 849 public static List<AssetEntry> findByLayoutUuid( 850 java.lang.String layoutUuid, int start, int end, 851 OrderByComparator<AssetEntry> orderByComparator) { 852 return getPersistence() 853 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 854 } 855 856 /** 857 * Returns the first asset entry in the ordered set where layoutUuid = ?. 858 * 859 * @param layoutUuid the layout uuid 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the first matching asset entry 862 * @throws NoSuchEntryException if a matching asset entry could not be found 863 */ 864 public static AssetEntry findByLayoutUuid_First( 865 java.lang.String layoutUuid, 866 OrderByComparator<AssetEntry> orderByComparator) 867 throws com.liferay.portlet.asset.NoSuchEntryException { 868 return getPersistence() 869 .findByLayoutUuid_First(layoutUuid, orderByComparator); 870 } 871 872 /** 873 * Returns the first asset entry in the ordered set where layoutUuid = ?. 874 * 875 * @param layoutUuid the layout uuid 876 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 877 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 878 */ 879 public static AssetEntry fetchByLayoutUuid_First( 880 java.lang.String layoutUuid, 881 OrderByComparator<AssetEntry> orderByComparator) { 882 return getPersistence() 883 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 884 } 885 886 /** 887 * Returns the last asset entry in the ordered set where layoutUuid = ?. 888 * 889 * @param layoutUuid the layout uuid 890 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 891 * @return the last matching asset entry 892 * @throws NoSuchEntryException if a matching asset entry could not be found 893 */ 894 public static AssetEntry findByLayoutUuid_Last( 895 java.lang.String layoutUuid, 896 OrderByComparator<AssetEntry> orderByComparator) 897 throws com.liferay.portlet.asset.NoSuchEntryException { 898 return getPersistence() 899 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 900 } 901 902 /** 903 * Returns the last asset entry in the ordered set where layoutUuid = ?. 904 * 905 * @param layoutUuid the layout uuid 906 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 907 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 908 */ 909 public static AssetEntry fetchByLayoutUuid_Last( 910 java.lang.String layoutUuid, 911 OrderByComparator<AssetEntry> orderByComparator) { 912 return getPersistence() 913 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 914 } 915 916 /** 917 * Returns the asset entries before and after the current asset entry in the ordered set where layoutUuid = ?. 918 * 919 * @param entryId the primary key of the current asset entry 920 * @param layoutUuid the layout uuid 921 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 922 * @return the previous, current, and next asset entry 923 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 924 */ 925 public static AssetEntry[] findByLayoutUuid_PrevAndNext(long entryId, 926 java.lang.String layoutUuid, 927 OrderByComparator<AssetEntry> orderByComparator) 928 throws com.liferay.portlet.asset.NoSuchEntryException { 929 return getPersistence() 930 .findByLayoutUuid_PrevAndNext(entryId, layoutUuid, 931 orderByComparator); 932 } 933 934 /** 935 * Removes all the asset entries where layoutUuid = ? from the database. 936 * 937 * @param layoutUuid the layout uuid 938 */ 939 public static void removeByLayoutUuid(java.lang.String layoutUuid) { 940 getPersistence().removeByLayoutUuid(layoutUuid); 941 } 942 943 /** 944 * Returns the number of asset entries where layoutUuid = ?. 945 * 946 * @param layoutUuid the layout uuid 947 * @return the number of matching asset entries 948 */ 949 public static int countByLayoutUuid(java.lang.String layoutUuid) { 950 return getPersistence().countByLayoutUuid(layoutUuid); 951 } 952 953 /** 954 * Returns the asset entry where groupId = ? and classUuid = ? or throws a {@link NoSuchEntryException} if it could not be found. 955 * 956 * @param groupId the group ID 957 * @param classUuid the class uuid 958 * @return the matching asset entry 959 * @throws NoSuchEntryException if a matching asset entry could not be found 960 */ 961 public static AssetEntry findByG_CU(long groupId, java.lang.String classUuid) 962 throws com.liferay.portlet.asset.NoSuchEntryException { 963 return getPersistence().findByG_CU(groupId, classUuid); 964 } 965 966 /** 967 * Returns the asset entry where groupId = ? and classUuid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 968 * 969 * @param groupId the group ID 970 * @param classUuid the class uuid 971 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 972 */ 973 public static AssetEntry fetchByG_CU(long groupId, 974 java.lang.String classUuid) { 975 return getPersistence().fetchByG_CU(groupId, classUuid); 976 } 977 978 /** 979 * Returns the asset entry where groupId = ? and classUuid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 980 * 981 * @param groupId the group ID 982 * @param classUuid the class uuid 983 * @param retrieveFromCache whether to use the finder cache 984 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 985 */ 986 public static AssetEntry fetchByG_CU(long groupId, 987 java.lang.String classUuid, boolean retrieveFromCache) { 988 return getPersistence() 989 .fetchByG_CU(groupId, classUuid, retrieveFromCache); 990 } 991 992 /** 993 * Removes the asset entry where groupId = ? and classUuid = ? from the database. 994 * 995 * @param groupId the group ID 996 * @param classUuid the class uuid 997 * @return the asset entry that was removed 998 */ 999 public static AssetEntry removeByG_CU(long groupId, 1000 java.lang.String classUuid) 1001 throws com.liferay.portlet.asset.NoSuchEntryException { 1002 return getPersistence().removeByG_CU(groupId, classUuid); 1003 } 1004 1005 /** 1006 * Returns the number of asset entries where groupId = ? and classUuid = ?. 1007 * 1008 * @param groupId the group ID 1009 * @param classUuid the class uuid 1010 * @return the number of matching asset entries 1011 */ 1012 public static int countByG_CU(long groupId, java.lang.String classUuid) { 1013 return getPersistence().countByG_CU(groupId, classUuid); 1014 } 1015 1016 /** 1017 * Returns the asset entry where classNameId = ? and classPK = ? or throws a {@link NoSuchEntryException} if it could not be found. 1018 * 1019 * @param classNameId the class name ID 1020 * @param classPK the class p k 1021 * @return the matching asset entry 1022 * @throws NoSuchEntryException if a matching asset entry could not be found 1023 */ 1024 public static AssetEntry findByC_C(long classNameId, long classPK) 1025 throws com.liferay.portlet.asset.NoSuchEntryException { 1026 return getPersistence().findByC_C(classNameId, classPK); 1027 } 1028 1029 /** 1030 * Returns the asset entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1031 * 1032 * @param classNameId the class name ID 1033 * @param classPK the class p k 1034 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1035 */ 1036 public static AssetEntry fetchByC_C(long classNameId, long classPK) { 1037 return getPersistence().fetchByC_C(classNameId, classPK); 1038 } 1039 1040 /** 1041 * Returns the asset entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1042 * 1043 * @param classNameId the class name ID 1044 * @param classPK the class p k 1045 * @param retrieveFromCache whether to use the finder cache 1046 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1047 */ 1048 public static AssetEntry fetchByC_C(long classNameId, long classPK, 1049 boolean retrieveFromCache) { 1050 return getPersistence() 1051 .fetchByC_C(classNameId, classPK, retrieveFromCache); 1052 } 1053 1054 /** 1055 * Removes the asset entry where classNameId = ? and classPK = ? from the database. 1056 * 1057 * @param classNameId the class name ID 1058 * @param classPK the class p k 1059 * @return the asset entry that was removed 1060 */ 1061 public static AssetEntry removeByC_C(long classNameId, long classPK) 1062 throws com.liferay.portlet.asset.NoSuchEntryException { 1063 return getPersistence().removeByC_C(classNameId, classPK); 1064 } 1065 1066 /** 1067 * Returns the number of asset entries where classNameId = ? and classPK = ?. 1068 * 1069 * @param classNameId the class name ID 1070 * @param classPK the class p k 1071 * @return the number of matching asset entries 1072 */ 1073 public static int countByC_C(long classNameId, long classPK) { 1074 return getPersistence().countByC_C(classNameId, classPK); 1075 } 1076 1077 /** 1078 * Caches the asset entry in the entity cache if it is enabled. 1079 * 1080 * @param assetEntry the asset entry 1081 */ 1082 public static void cacheResult(AssetEntry assetEntry) { 1083 getPersistence().cacheResult(assetEntry); 1084 } 1085 1086 /** 1087 * Caches the asset entries in the entity cache if it is enabled. 1088 * 1089 * @param assetEntries the asset entries 1090 */ 1091 public static void cacheResult(List<AssetEntry> assetEntries) { 1092 getPersistence().cacheResult(assetEntries); 1093 } 1094 1095 /** 1096 * Creates a new asset entry with the primary key. Does not add the asset entry to the database. 1097 * 1098 * @param entryId the primary key for the new asset entry 1099 * @return the new asset entry 1100 */ 1101 public static AssetEntry create(long entryId) { 1102 return getPersistence().create(entryId); 1103 } 1104 1105 /** 1106 * Removes the asset entry with the primary key from the database. Also notifies the appropriate model listeners. 1107 * 1108 * @param entryId the primary key of the asset entry 1109 * @return the asset entry that was removed 1110 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 1111 */ 1112 public static AssetEntry remove(long entryId) 1113 throws com.liferay.portlet.asset.NoSuchEntryException { 1114 return getPersistence().remove(entryId); 1115 } 1116 1117 public static AssetEntry updateImpl(AssetEntry assetEntry) { 1118 return getPersistence().updateImpl(assetEntry); 1119 } 1120 1121 /** 1122 * Returns the asset entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 1123 * 1124 * @param entryId the primary key of the asset entry 1125 * @return the asset entry 1126 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 1127 */ 1128 public static AssetEntry findByPrimaryKey(long entryId) 1129 throws com.liferay.portlet.asset.NoSuchEntryException { 1130 return getPersistence().findByPrimaryKey(entryId); 1131 } 1132 1133 /** 1134 * Returns the asset entry with the primary key or returns <code>null</code> if it could not be found. 1135 * 1136 * @param entryId the primary key of the asset entry 1137 * @return the asset entry, or <code>null</code> if a asset entry with the primary key could not be found 1138 */ 1139 public static AssetEntry fetchByPrimaryKey(long entryId) { 1140 return getPersistence().fetchByPrimaryKey(entryId); 1141 } 1142 1143 public static java.util.Map<java.io.Serializable, AssetEntry> fetchByPrimaryKeys( 1144 java.util.Set<java.io.Serializable> primaryKeys) { 1145 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1146 } 1147 1148 /** 1149 * Returns all the asset entries. 1150 * 1151 * @return the asset entries 1152 */ 1153 public static List<AssetEntry> findAll() { 1154 return getPersistence().findAll(); 1155 } 1156 1157 /** 1158 * Returns a range of all the asset entries. 1159 * 1160 * <p> 1161 * 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 AssetEntryModelImpl}. 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. 1162 * </p> 1163 * 1164 * @param start the lower bound of the range of asset entries 1165 * @param end the upper bound of the range of asset entries (not inclusive) 1166 * @return the range of asset entries 1167 */ 1168 public static List<AssetEntry> findAll(int start, int end) { 1169 return getPersistence().findAll(start, end); 1170 } 1171 1172 /** 1173 * Returns an ordered range of all the asset entries. 1174 * 1175 * <p> 1176 * 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 AssetEntryModelImpl}. 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. 1177 * </p> 1178 * 1179 * @param start the lower bound of the range of asset entries 1180 * @param end the upper bound of the range of asset entries (not inclusive) 1181 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1182 * @return the ordered range of asset entries 1183 */ 1184 public static List<AssetEntry> findAll(int start, int end, 1185 OrderByComparator<AssetEntry> orderByComparator) { 1186 return getPersistence().findAll(start, end, orderByComparator); 1187 } 1188 1189 /** 1190 * Removes all the asset entries from the database. 1191 */ 1192 public static void removeAll() { 1193 getPersistence().removeAll(); 1194 } 1195 1196 /** 1197 * Returns the number of asset entries. 1198 * 1199 * @return the number of asset entries 1200 */ 1201 public static int countAll() { 1202 return getPersistence().countAll(); 1203 } 1204 1205 /** 1206 * Returns the primaryKeys of asset categories associated with the asset entry. 1207 * 1208 * @param pk the primary key of the asset entry 1209 * @return long[] of the primaryKeys of asset categories associated with the asset entry 1210 */ 1211 public static long[] getAssetCategoryPrimaryKeys(long pk) { 1212 return getPersistence().getAssetCategoryPrimaryKeys(pk); 1213 } 1214 1215 /** 1216 * Returns all the asset categories associated with the asset entry. 1217 * 1218 * @param pk the primary key of the asset entry 1219 * @return the asset categories associated with the asset entry 1220 */ 1221 public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories( 1222 long pk) { 1223 return getPersistence().getAssetCategories(pk); 1224 } 1225 1226 /** 1227 * Returns a range of all the asset categories associated with the asset entry. 1228 * 1229 * <p> 1230 * 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 AssetEntryModelImpl}. 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. 1231 * </p> 1232 * 1233 * @param pk the primary key of the asset entry 1234 * @param start the lower bound of the range of asset entries 1235 * @param end the upper bound of the range of asset entries (not inclusive) 1236 * @return the range of asset categories associated with the asset entry 1237 */ 1238 public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories( 1239 long pk, int start, int end) { 1240 return getPersistence().getAssetCategories(pk, start, end); 1241 } 1242 1243 /** 1244 * Returns an ordered range of all the asset categories associated with the asset entry. 1245 * 1246 * <p> 1247 * 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 AssetEntryModelImpl}. 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. 1248 * </p> 1249 * 1250 * @param pk the primary key of the asset entry 1251 * @param start the lower bound of the range of asset entries 1252 * @param end the upper bound of the range of asset entries (not inclusive) 1253 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1254 * @return the ordered range of asset categories associated with the asset entry 1255 */ 1256 public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories( 1257 long pk, int start, int end, 1258 OrderByComparator<com.liferay.portlet.asset.model.AssetCategory> orderByComparator) { 1259 return getPersistence() 1260 .getAssetCategories(pk, start, end, orderByComparator); 1261 } 1262 1263 /** 1264 * Returns the number of asset categories associated with the asset entry. 1265 * 1266 * @param pk the primary key of the asset entry 1267 * @return the number of asset categories associated with the asset entry 1268 */ 1269 public static int getAssetCategoriesSize(long pk) { 1270 return getPersistence().getAssetCategoriesSize(pk); 1271 } 1272 1273 /** 1274 * Returns <code>true</code> if the asset category is associated with the asset entry. 1275 * 1276 * @param pk the primary key of the asset entry 1277 * @param assetCategoryPK the primary key of the asset category 1278 * @return <code>true</code> if the asset category is associated with the asset entry; <code>false</code> otherwise 1279 */ 1280 public static boolean containsAssetCategory(long pk, long assetCategoryPK) { 1281 return getPersistence().containsAssetCategory(pk, assetCategoryPK); 1282 } 1283 1284 /** 1285 * Returns <code>true</code> if the asset entry has any asset categories associated with it. 1286 * 1287 * @param pk the primary key of the asset entry to check for associations with asset categories 1288 * @return <code>true</code> if the asset entry has any asset categories associated with it; <code>false</code> otherwise 1289 */ 1290 public static boolean containsAssetCategories(long pk) { 1291 return getPersistence().containsAssetCategories(pk); 1292 } 1293 1294 /** 1295 * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1296 * 1297 * @param pk the primary key of the asset entry 1298 * @param assetCategoryPK the primary key of the asset category 1299 */ 1300 public static void addAssetCategory(long pk, long assetCategoryPK) { 1301 getPersistence().addAssetCategory(pk, assetCategoryPK); 1302 } 1303 1304 /** 1305 * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1306 * 1307 * @param pk the primary key of the asset entry 1308 * @param assetCategory the asset category 1309 */ 1310 public static void addAssetCategory(long pk, 1311 com.liferay.portlet.asset.model.AssetCategory assetCategory) { 1312 getPersistence().addAssetCategory(pk, assetCategory); 1313 } 1314 1315 /** 1316 * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1317 * 1318 * @param pk the primary key of the asset entry 1319 * @param assetCategoryPKs the primary keys of the asset categories 1320 */ 1321 public static void addAssetCategories(long pk, long[] assetCategoryPKs) { 1322 getPersistence().addAssetCategories(pk, assetCategoryPKs); 1323 } 1324 1325 /** 1326 * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1327 * 1328 * @param pk the primary key of the asset entry 1329 * @param assetCategories the asset categories 1330 */ 1331 public static void addAssetCategories(long pk, 1332 List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) { 1333 getPersistence().addAssetCategories(pk, assetCategories); 1334 } 1335 1336 /** 1337 * Clears all associations between the asset entry and its asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1338 * 1339 * @param pk the primary key of the asset entry to clear the associated asset categories from 1340 */ 1341 public static void clearAssetCategories(long pk) { 1342 getPersistence().clearAssetCategories(pk); 1343 } 1344 1345 /** 1346 * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1347 * 1348 * @param pk the primary key of the asset entry 1349 * @param assetCategoryPK the primary key of the asset category 1350 */ 1351 public static void removeAssetCategory(long pk, long assetCategoryPK) { 1352 getPersistence().removeAssetCategory(pk, assetCategoryPK); 1353 } 1354 1355 /** 1356 * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1357 * 1358 * @param pk the primary key of the asset entry 1359 * @param assetCategory the asset category 1360 */ 1361 public static void removeAssetCategory(long pk, 1362 com.liferay.portlet.asset.model.AssetCategory assetCategory) { 1363 getPersistence().removeAssetCategory(pk, assetCategory); 1364 } 1365 1366 /** 1367 * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1368 * 1369 * @param pk the primary key of the asset entry 1370 * @param assetCategoryPKs the primary keys of the asset categories 1371 */ 1372 public static void removeAssetCategories(long pk, long[] assetCategoryPKs) { 1373 getPersistence().removeAssetCategories(pk, assetCategoryPKs); 1374 } 1375 1376 /** 1377 * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1378 * 1379 * @param pk the primary key of the asset entry 1380 * @param assetCategories the asset categories 1381 */ 1382 public static void removeAssetCategories(long pk, 1383 List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) { 1384 getPersistence().removeAssetCategories(pk, assetCategories); 1385 } 1386 1387 /** 1388 * Sets the asset categories associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1389 * 1390 * @param pk the primary key of the asset entry 1391 * @param assetCategoryPKs the primary keys of the asset categories to be associated with the asset entry 1392 */ 1393 public static void setAssetCategories(long pk, long[] assetCategoryPKs) { 1394 getPersistence().setAssetCategories(pk, assetCategoryPKs); 1395 } 1396 1397 /** 1398 * Sets the asset categories associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1399 * 1400 * @param pk the primary key of the asset entry 1401 * @param assetCategories the asset categories to be associated with the asset entry 1402 */ 1403 public static void setAssetCategories(long pk, 1404 List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) { 1405 getPersistence().setAssetCategories(pk, assetCategories); 1406 } 1407 1408 /** 1409 * Returns the primaryKeys of asset tags associated with the asset entry. 1410 * 1411 * @param pk the primary key of the asset entry 1412 * @return long[] of the primaryKeys of asset tags associated with the asset entry 1413 */ 1414 public static long[] getAssetTagPrimaryKeys(long pk) { 1415 return getPersistence().getAssetTagPrimaryKeys(pk); 1416 } 1417 1418 /** 1419 * Returns all the asset tags associated with the asset entry. 1420 * 1421 * @param pk the primary key of the asset entry 1422 * @return the asset tags associated with the asset entry 1423 */ 1424 public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags( 1425 long pk) { 1426 return getPersistence().getAssetTags(pk); 1427 } 1428 1429 /** 1430 * Returns a range of all the asset tags associated with the asset entry. 1431 * 1432 * <p> 1433 * 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 AssetEntryModelImpl}. 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. 1434 * </p> 1435 * 1436 * @param pk the primary key of the asset entry 1437 * @param start the lower bound of the range of asset entries 1438 * @param end the upper bound of the range of asset entries (not inclusive) 1439 * @return the range of asset tags associated with the asset entry 1440 */ 1441 public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags( 1442 long pk, int start, int end) { 1443 return getPersistence().getAssetTags(pk, start, end); 1444 } 1445 1446 /** 1447 * Returns an ordered range of all the asset tags associated with the asset entry. 1448 * 1449 * <p> 1450 * 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 AssetEntryModelImpl}. 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. 1451 * </p> 1452 * 1453 * @param pk the primary key of the asset entry 1454 * @param start the lower bound of the range of asset entries 1455 * @param end the upper bound of the range of asset entries (not inclusive) 1456 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1457 * @return the ordered range of asset tags associated with the asset entry 1458 */ 1459 public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags( 1460 long pk, int start, int end, 1461 OrderByComparator<com.liferay.portlet.asset.model.AssetTag> orderByComparator) { 1462 return getPersistence().getAssetTags(pk, start, end, orderByComparator); 1463 } 1464 1465 /** 1466 * Returns the number of asset tags associated with the asset entry. 1467 * 1468 * @param pk the primary key of the asset entry 1469 * @return the number of asset tags associated with the asset entry 1470 */ 1471 public static int getAssetTagsSize(long pk) { 1472 return getPersistence().getAssetTagsSize(pk); 1473 } 1474 1475 /** 1476 * Returns <code>true</code> if the asset tag is associated with the asset entry. 1477 * 1478 * @param pk the primary key of the asset entry 1479 * @param assetTagPK the primary key of the asset tag 1480 * @return <code>true</code> if the asset tag is associated with the asset entry; <code>false</code> otherwise 1481 */ 1482 public static boolean containsAssetTag(long pk, long assetTagPK) { 1483 return getPersistence().containsAssetTag(pk, assetTagPK); 1484 } 1485 1486 /** 1487 * Returns <code>true</code> if the asset entry has any asset tags associated with it. 1488 * 1489 * @param pk the primary key of the asset entry to check for associations with asset tags 1490 * @return <code>true</code> if the asset entry has any asset tags associated with it; <code>false</code> otherwise 1491 */ 1492 public static boolean containsAssetTags(long pk) { 1493 return getPersistence().containsAssetTags(pk); 1494 } 1495 1496 /** 1497 * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1498 * 1499 * @param pk the primary key of the asset entry 1500 * @param assetTagPK the primary key of the asset tag 1501 */ 1502 public static void addAssetTag(long pk, long assetTagPK) { 1503 getPersistence().addAssetTag(pk, assetTagPK); 1504 } 1505 1506 /** 1507 * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1508 * 1509 * @param pk the primary key of the asset entry 1510 * @param assetTag the asset tag 1511 */ 1512 public static void addAssetTag(long pk, 1513 com.liferay.portlet.asset.model.AssetTag assetTag) { 1514 getPersistence().addAssetTag(pk, assetTag); 1515 } 1516 1517 /** 1518 * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1519 * 1520 * @param pk the primary key of the asset entry 1521 * @param assetTagPKs the primary keys of the asset tags 1522 */ 1523 public static void addAssetTags(long pk, long[] assetTagPKs) { 1524 getPersistence().addAssetTags(pk, assetTagPKs); 1525 } 1526 1527 /** 1528 * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1529 * 1530 * @param pk the primary key of the asset entry 1531 * @param assetTags the asset tags 1532 */ 1533 public static void addAssetTags(long pk, 1534 List<com.liferay.portlet.asset.model.AssetTag> assetTags) { 1535 getPersistence().addAssetTags(pk, assetTags); 1536 } 1537 1538 /** 1539 * Clears all associations between the asset entry and its asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1540 * 1541 * @param pk the primary key of the asset entry to clear the associated asset tags from 1542 */ 1543 public static void clearAssetTags(long pk) { 1544 getPersistence().clearAssetTags(pk); 1545 } 1546 1547 /** 1548 * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1549 * 1550 * @param pk the primary key of the asset entry 1551 * @param assetTagPK the primary key of the asset tag 1552 */ 1553 public static void removeAssetTag(long pk, long assetTagPK) { 1554 getPersistence().removeAssetTag(pk, assetTagPK); 1555 } 1556 1557 /** 1558 * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1559 * 1560 * @param pk the primary key of the asset entry 1561 * @param assetTag the asset tag 1562 */ 1563 public static void removeAssetTag(long pk, 1564 com.liferay.portlet.asset.model.AssetTag assetTag) { 1565 getPersistence().removeAssetTag(pk, assetTag); 1566 } 1567 1568 /** 1569 * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1570 * 1571 * @param pk the primary key of the asset entry 1572 * @param assetTagPKs the primary keys of the asset tags 1573 */ 1574 public static void removeAssetTags(long pk, long[] assetTagPKs) { 1575 getPersistence().removeAssetTags(pk, assetTagPKs); 1576 } 1577 1578 /** 1579 * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1580 * 1581 * @param pk the primary key of the asset entry 1582 * @param assetTags the asset tags 1583 */ 1584 public static void removeAssetTags(long pk, 1585 List<com.liferay.portlet.asset.model.AssetTag> assetTags) { 1586 getPersistence().removeAssetTags(pk, assetTags); 1587 } 1588 1589 /** 1590 * Sets the asset tags associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1591 * 1592 * @param pk the primary key of the asset entry 1593 * @param assetTagPKs the primary keys of the asset tags to be associated with the asset entry 1594 */ 1595 public static void setAssetTags(long pk, long[] assetTagPKs) { 1596 getPersistence().setAssetTags(pk, assetTagPKs); 1597 } 1598 1599 /** 1600 * Sets the asset tags associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1601 * 1602 * @param pk the primary key of the asset entry 1603 * @param assetTags the asset tags to be associated with the asset entry 1604 */ 1605 public static void setAssetTags(long pk, 1606 List<com.liferay.portlet.asset.model.AssetTag> assetTags) { 1607 getPersistence().setAssetTags(pk, assetTags); 1608 } 1609 1610 public static AssetEntryPersistence getPersistence() { 1611 if (_persistence == null) { 1612 _persistence = (AssetEntryPersistence)PortalBeanLocatorUtil.locate(AssetEntryPersistence.class.getName()); 1613 1614 ReferenceRegistry.registerReference(AssetEntryUtil.class, 1615 "_persistence"); 1616 } 1617 1618 return _persistence; 1619 } 1620 1621 /** 1622 * @deprecated As of 6.2.0 1623 */ 1624 @Deprecated 1625 public void setPersistence(AssetEntryPersistence persistence) { 1626 } 1627 1628 private static AssetEntryPersistence _persistence; 1629 }