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