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