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