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