001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.asset.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.asset.model.AssetTag; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset tag service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see AssetTagPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetTagUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(AssetTag assetTag) { 060 getPersistence().clearCache(assetTag); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<AssetTag> findWithDynamicQuery(DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<AssetTag> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<AssetTag> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<AssetTag> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static AssetTag update(AssetTag assetTag) { 100 return getPersistence().update(assetTag); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static AssetTag update(AssetTag assetTag, 107 ServiceContext serviceContext) { 108 return getPersistence().update(assetTag, serviceContext); 109 } 110 111 /** 112 * Returns all the asset tags where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching asset tags 116 */ 117 public static List<AssetTag> findByUuid(java.lang.String uuid) { 118 return getPersistence().findByUuid(uuid); 119 } 120 121 /** 122 * Returns a range of all the asset tags where uuid = ?. 123 * 124 * <p> 125 * 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. 126 * </p> 127 * 128 * @param uuid the uuid 129 * @param start the lower bound of the range of asset tags 130 * @param end the upper bound of the range of asset tags (not inclusive) 131 * @return the range of matching asset tags 132 */ 133 public static List<AssetTag> findByUuid(java.lang.String uuid, int start, 134 int end) { 135 return getPersistence().findByUuid(uuid, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the asset tags where uuid = ?. 140 * 141 * <p> 142 * 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. 143 * </p> 144 * 145 * @param uuid the uuid 146 * @param start the lower bound of the range of asset tags 147 * @param end the upper bound of the range of asset tags (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching asset tags 150 */ 151 public static List<AssetTag> findByUuid(java.lang.String uuid, int start, 152 int end, OrderByComparator<AssetTag> orderByComparator) { 153 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns an ordered range of all the asset tags where uuid = ?. 158 * 159 * <p> 160 * 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. 161 * </p> 162 * 163 * @param uuid the uuid 164 * @param start the lower bound of the range of asset tags 165 * @param end the upper bound of the range of asset tags (not inclusive) 166 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 167 * @param retrieveFromCache whether to retrieve from the finder cache 168 * @return the ordered range of matching asset tags 169 */ 170 public static List<AssetTag> findByUuid(java.lang.String uuid, int start, 171 int end, OrderByComparator<AssetTag> orderByComparator, 172 boolean retrieveFromCache) { 173 return getPersistence() 174 .findByUuid(uuid, start, end, orderByComparator, 175 retrieveFromCache); 176 } 177 178 /** 179 * Returns the first asset tag in the ordered set where uuid = ?. 180 * 181 * @param uuid the uuid 182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 183 * @return the first matching asset tag 184 * @throws NoSuchTagException if a matching asset tag could not be found 185 */ 186 public static AssetTag findByUuid_First(java.lang.String uuid, 187 OrderByComparator<AssetTag> orderByComparator) 188 throws com.liferay.portlet.asset.exception.NoSuchTagException { 189 return getPersistence().findByUuid_First(uuid, orderByComparator); 190 } 191 192 /** 193 * Returns the first asset tag in the ordered set where uuid = ?. 194 * 195 * @param uuid the uuid 196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 197 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 198 */ 199 public static AssetTag fetchByUuid_First(java.lang.String uuid, 200 OrderByComparator<AssetTag> orderByComparator) { 201 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 202 } 203 204 /** 205 * Returns the last asset tag in the ordered set where uuid = ?. 206 * 207 * @param uuid the uuid 208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 209 * @return the last matching asset tag 210 * @throws NoSuchTagException if a matching asset tag could not be found 211 */ 212 public static AssetTag findByUuid_Last(java.lang.String uuid, 213 OrderByComparator<AssetTag> orderByComparator) 214 throws com.liferay.portlet.asset.exception.NoSuchTagException { 215 return getPersistence().findByUuid_Last(uuid, orderByComparator); 216 } 217 218 /** 219 * Returns the last asset tag in the ordered set where uuid = ?. 220 * 221 * @param uuid the uuid 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 224 */ 225 public static AssetTag fetchByUuid_Last(java.lang.String uuid, 226 OrderByComparator<AssetTag> orderByComparator) { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the asset tags before and after the current asset tag in the ordered set where uuid = ?. 232 * 233 * @param tagId the primary key of the current asset tag 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next asset tag 237 * @throws NoSuchTagException if a asset tag with the primary key could not be found 238 */ 239 public static AssetTag[] findByUuid_PrevAndNext(long tagId, 240 java.lang.String uuid, OrderByComparator<AssetTag> orderByComparator) 241 throws com.liferay.portlet.asset.exception.NoSuchTagException { 242 return getPersistence() 243 .findByUuid_PrevAndNext(tagId, uuid, orderByComparator); 244 } 245 246 /** 247 * Removes all the asset tags where uuid = ? from the database. 248 * 249 * @param uuid the uuid 250 */ 251 public static void removeByUuid(java.lang.String uuid) { 252 getPersistence().removeByUuid(uuid); 253 } 254 255 /** 256 * Returns the number of asset tags where uuid = ?. 257 * 258 * @param uuid the uuid 259 * @return the number of matching asset tags 260 */ 261 public static int countByUuid(java.lang.String uuid) { 262 return getPersistence().countByUuid(uuid); 263 } 264 265 /** 266 * Returns the asset tag where uuid = ? and groupId = ? or throws a {@link NoSuchTagException} if it could not be found. 267 * 268 * @param uuid the uuid 269 * @param groupId the group ID 270 * @return the matching asset tag 271 * @throws NoSuchTagException if a matching asset tag could not be found 272 */ 273 public static AssetTag findByUUID_G(java.lang.String uuid, long groupId) 274 throws com.liferay.portlet.asset.exception.NoSuchTagException { 275 return getPersistence().findByUUID_G(uuid, groupId); 276 } 277 278 /** 279 * Returns the asset tag where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 280 * 281 * @param uuid the uuid 282 * @param groupId the group ID 283 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 284 */ 285 public static AssetTag fetchByUUID_G(java.lang.String uuid, long groupId) { 286 return getPersistence().fetchByUUID_G(uuid, groupId); 287 } 288 289 /** 290 * Returns the asset tag where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 291 * 292 * @param uuid the uuid 293 * @param groupId the group ID 294 * @param retrieveFromCache whether to retrieve from the finder cache 295 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 296 */ 297 public static AssetTag fetchByUUID_G(java.lang.String uuid, long groupId, 298 boolean retrieveFromCache) { 299 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 300 } 301 302 /** 303 * Removes the asset tag where uuid = ? and groupId = ? from the database. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @return the asset tag that was removed 308 */ 309 public static AssetTag removeByUUID_G(java.lang.String uuid, long groupId) 310 throws com.liferay.portlet.asset.exception.NoSuchTagException { 311 return getPersistence().removeByUUID_G(uuid, groupId); 312 } 313 314 /** 315 * Returns the number of asset tags where uuid = ? and groupId = ?. 316 * 317 * @param uuid the uuid 318 * @param groupId the group ID 319 * @return the number of matching asset tags 320 */ 321 public static int countByUUID_G(java.lang.String uuid, long groupId) { 322 return getPersistence().countByUUID_G(uuid, groupId); 323 } 324 325 /** 326 * Returns all the asset tags where uuid = ? and companyId = ?. 327 * 328 * @param uuid the uuid 329 * @param companyId the company ID 330 * @return the matching asset tags 331 */ 332 public static List<AssetTag> findByUuid_C(java.lang.String uuid, 333 long companyId) { 334 return getPersistence().findByUuid_C(uuid, companyId); 335 } 336 337 /** 338 * Returns a range of all the asset tags where uuid = ? and companyId = ?. 339 * 340 * <p> 341 * 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. 342 * </p> 343 * 344 * @param uuid the uuid 345 * @param companyId the company ID 346 * @param start the lower bound of the range of asset tags 347 * @param end the upper bound of the range of asset tags (not inclusive) 348 * @return the range of matching asset tags 349 */ 350 public static List<AssetTag> findByUuid_C(java.lang.String uuid, 351 long companyId, int start, int end) { 352 return getPersistence().findByUuid_C(uuid, companyId, start, end); 353 } 354 355 /** 356 * Returns an ordered range of all the asset tags where uuid = ? and companyId = ?. 357 * 358 * <p> 359 * 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. 360 * </p> 361 * 362 * @param uuid the uuid 363 * @param companyId the company ID 364 * @param start the lower bound of the range of asset tags 365 * @param end the upper bound of the range of asset tags (not inclusive) 366 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 367 * @return the ordered range of matching asset tags 368 */ 369 public static List<AssetTag> findByUuid_C(java.lang.String uuid, 370 long companyId, int start, int end, 371 OrderByComparator<AssetTag> orderByComparator) { 372 return getPersistence() 373 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 374 } 375 376 /** 377 * Returns an ordered range of all the asset tags where uuid = ? and companyId = ?. 378 * 379 * <p> 380 * 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. 381 * </p> 382 * 383 * @param uuid the uuid 384 * @param companyId the company 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 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 388 * @param retrieveFromCache whether to retrieve from the finder cache 389 * @return the ordered range of matching asset tags 390 */ 391 public static List<AssetTag> findByUuid_C(java.lang.String uuid, 392 long companyId, int start, int end, 393 OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) { 394 return getPersistence() 395 .findByUuid_C(uuid, companyId, start, end, 396 orderByComparator, retrieveFromCache); 397 } 398 399 /** 400 * Returns the first asset tag in the ordered set where uuid = ? and companyId = ?. 401 * 402 * @param uuid the uuid 403 * @param companyId the company ID 404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 405 * @return the first matching asset tag 406 * @throws NoSuchTagException if a matching asset tag could not be found 407 */ 408 public static AssetTag findByUuid_C_First(java.lang.String uuid, 409 long companyId, OrderByComparator<AssetTag> orderByComparator) 410 throws com.liferay.portlet.asset.exception.NoSuchTagException { 411 return getPersistence() 412 .findByUuid_C_First(uuid, companyId, orderByComparator); 413 } 414 415 /** 416 * Returns the first asset tag in the ordered set where uuid = ? and companyId = ?. 417 * 418 * @param uuid the uuid 419 * @param companyId the company ID 420 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 421 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 422 */ 423 public static AssetTag fetchByUuid_C_First(java.lang.String uuid, 424 long companyId, OrderByComparator<AssetTag> orderByComparator) { 425 return getPersistence() 426 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 427 } 428 429 /** 430 * Returns the last asset tag in the ordered set where uuid = ? and companyId = ?. 431 * 432 * @param uuid the uuid 433 * @param companyId the company ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the last matching asset tag 436 * @throws NoSuchTagException if a matching asset tag could not be found 437 */ 438 public static AssetTag findByUuid_C_Last(java.lang.String uuid, 439 long companyId, OrderByComparator<AssetTag> orderByComparator) 440 throws com.liferay.portlet.asset.exception.NoSuchTagException { 441 return getPersistence() 442 .findByUuid_C_Last(uuid, companyId, orderByComparator); 443 } 444 445 /** 446 * Returns the last asset tag in the ordered set where uuid = ? and companyId = ?. 447 * 448 * @param uuid the uuid 449 * @param companyId the company ID 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 452 */ 453 public static AssetTag fetchByUuid_C_Last(java.lang.String uuid, 454 long companyId, OrderByComparator<AssetTag> orderByComparator) { 455 return getPersistence() 456 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 457 } 458 459 /** 460 * Returns the asset tags before and after the current asset tag in the ordered set where uuid = ? and companyId = ?. 461 * 462 * @param tagId the primary key of the current asset tag 463 * @param uuid the uuid 464 * @param companyId the company ID 465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 466 * @return the previous, current, and next asset tag 467 * @throws NoSuchTagException if a asset tag with the primary key could not be found 468 */ 469 public static AssetTag[] findByUuid_C_PrevAndNext(long tagId, 470 java.lang.String uuid, long companyId, 471 OrderByComparator<AssetTag> orderByComparator) 472 throws com.liferay.portlet.asset.exception.NoSuchTagException { 473 return getPersistence() 474 .findByUuid_C_PrevAndNext(tagId, uuid, companyId, 475 orderByComparator); 476 } 477 478 /** 479 * Removes all the asset tags where uuid = ? and companyId = ? from the database. 480 * 481 * @param uuid the uuid 482 * @param companyId the company ID 483 */ 484 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 485 getPersistence().removeByUuid_C(uuid, companyId); 486 } 487 488 /** 489 * Returns the number of asset tags where uuid = ? and companyId = ?. 490 * 491 * @param uuid the uuid 492 * @param companyId the company ID 493 * @return the number of matching asset tags 494 */ 495 public static int countByUuid_C(java.lang.String uuid, long companyId) { 496 return getPersistence().countByUuid_C(uuid, companyId); 497 } 498 499 /** 500 * Returns all the asset tags where groupId = ?. 501 * 502 * @param groupId the group ID 503 * @return the matching asset tags 504 */ 505 public static List<AssetTag> findByGroupId(long groupId) { 506 return getPersistence().findByGroupId(groupId); 507 } 508 509 /** 510 * Returns a range of all the asset tags where groupId = ?. 511 * 512 * <p> 513 * 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. 514 * </p> 515 * 516 * @param groupId the group ID 517 * @param start the lower bound of the range of asset tags 518 * @param end the upper bound of the range of asset tags (not inclusive) 519 * @return the range of matching asset tags 520 */ 521 public static List<AssetTag> findByGroupId(long groupId, int start, int end) { 522 return getPersistence().findByGroupId(groupId, start, end); 523 } 524 525 /** 526 * Returns an ordered range of all the asset tags where groupId = ?. 527 * 528 * <p> 529 * 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. 530 * </p> 531 * 532 * @param groupId the group ID 533 * @param start the lower bound of the range of asset tags 534 * @param end the upper bound of the range of asset tags (not inclusive) 535 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 536 * @return the ordered range of matching asset tags 537 */ 538 public static List<AssetTag> findByGroupId(long groupId, int start, 539 int end, OrderByComparator<AssetTag> orderByComparator) { 540 return getPersistence() 541 .findByGroupId(groupId, start, end, orderByComparator); 542 } 543 544 /** 545 * Returns an ordered range of all the asset tags where groupId = ?. 546 * 547 * <p> 548 * 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. 549 * </p> 550 * 551 * @param groupId the group ID 552 * @param start the lower bound of the range of asset tags 553 * @param end the upper bound of the range of asset tags (not inclusive) 554 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 555 * @param retrieveFromCache whether to retrieve from the finder cache 556 * @return the ordered range of matching asset tags 557 */ 558 public static List<AssetTag> findByGroupId(long groupId, int start, 559 int end, OrderByComparator<AssetTag> orderByComparator, 560 boolean retrieveFromCache) { 561 return getPersistence() 562 .findByGroupId(groupId, start, end, orderByComparator, 563 retrieveFromCache); 564 } 565 566 /** 567 * Returns the first asset tag in the ordered set where groupId = ?. 568 * 569 * @param groupId the group ID 570 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 571 * @return the first matching asset tag 572 * @throws NoSuchTagException if a matching asset tag could not be found 573 */ 574 public static AssetTag findByGroupId_First(long groupId, 575 OrderByComparator<AssetTag> orderByComparator) 576 throws com.liferay.portlet.asset.exception.NoSuchTagException { 577 return getPersistence().findByGroupId_First(groupId, orderByComparator); 578 } 579 580 /** 581 * Returns the first asset tag in the ordered set where groupId = ?. 582 * 583 * @param groupId the group ID 584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 585 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 586 */ 587 public static AssetTag fetchByGroupId_First(long groupId, 588 OrderByComparator<AssetTag> orderByComparator) { 589 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 590 } 591 592 /** 593 * Returns the last asset tag in the ordered set where groupId = ?. 594 * 595 * @param groupId the group ID 596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 597 * @return the last matching asset tag 598 * @throws NoSuchTagException if a matching asset tag could not be found 599 */ 600 public static AssetTag findByGroupId_Last(long groupId, 601 OrderByComparator<AssetTag> orderByComparator) 602 throws com.liferay.portlet.asset.exception.NoSuchTagException { 603 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last asset tag in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 612 */ 613 public static AssetTag fetchByGroupId_Last(long groupId, 614 OrderByComparator<AssetTag> orderByComparator) { 615 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 616 } 617 618 /** 619 * Returns the asset tags before and after the current asset tag in the ordered set where groupId = ?. 620 * 621 * @param tagId the primary key of the current asset tag 622 * @param groupId the group ID 623 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 624 * @return the previous, current, and next asset tag 625 * @throws NoSuchTagException if a asset tag with the primary key could not be found 626 */ 627 public static AssetTag[] findByGroupId_PrevAndNext(long tagId, 628 long groupId, OrderByComparator<AssetTag> orderByComparator) 629 throws com.liferay.portlet.asset.exception.NoSuchTagException { 630 return getPersistence() 631 .findByGroupId_PrevAndNext(tagId, groupId, orderByComparator); 632 } 633 634 /** 635 * Returns all the asset tags that the user has permission to view where groupId = ?. 636 * 637 * @param groupId the group ID 638 * @return the matching asset tags that the user has permission to view 639 */ 640 public static List<AssetTag> filterFindByGroupId(long groupId) { 641 return getPersistence().filterFindByGroupId(groupId); 642 } 643 644 /** 645 * Returns a range of all the asset tags that the user has permission to view where groupId = ?. 646 * 647 * <p> 648 * 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. 649 * </p> 650 * 651 * @param groupId the group ID 652 * @param start the lower bound of the range of asset tags 653 * @param end the upper bound of the range of asset tags (not inclusive) 654 * @return the range of matching asset tags that the user has permission to view 655 */ 656 public static List<AssetTag> filterFindByGroupId(long groupId, int start, 657 int end) { 658 return getPersistence().filterFindByGroupId(groupId, start, end); 659 } 660 661 /** 662 * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = ?. 663 * 664 * <p> 665 * 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. 666 * </p> 667 * 668 * @param groupId the group ID 669 * @param start the lower bound of the range of asset tags 670 * @param end the upper bound of the range of asset tags (not inclusive) 671 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 672 * @return the ordered range of matching asset tags that the user has permission to view 673 */ 674 public static List<AssetTag> filterFindByGroupId(long groupId, int start, 675 int end, OrderByComparator<AssetTag> orderByComparator) { 676 return getPersistence() 677 .filterFindByGroupId(groupId, start, end, orderByComparator); 678 } 679 680 /** 681 * 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 = ?. 682 * 683 * @param tagId the primary key of the current asset tag 684 * @param groupId the group ID 685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 686 * @return the previous, current, and next asset tag 687 * @throws NoSuchTagException if a asset tag with the primary key could not be found 688 */ 689 public static AssetTag[] filterFindByGroupId_PrevAndNext(long tagId, 690 long groupId, OrderByComparator<AssetTag> orderByComparator) 691 throws com.liferay.portlet.asset.exception.NoSuchTagException { 692 return getPersistence() 693 .filterFindByGroupId_PrevAndNext(tagId, groupId, 694 orderByComparator); 695 } 696 697 /** 698 * Returns all the asset tags that the user has permission to view where groupId = any ?. 699 * 700 * @param groupIds the group IDs 701 * @return the matching asset tags that the user has permission to view 702 */ 703 public static List<AssetTag> filterFindByGroupId(long[] groupIds) { 704 return getPersistence().filterFindByGroupId(groupIds); 705 } 706 707 /** 708 * Returns a range of all the asset tags that the user has permission to view where groupId = any ?. 709 * 710 * <p> 711 * 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. 712 * </p> 713 * 714 * @param groupIds the group IDs 715 * @param start the lower bound of the range of asset tags 716 * @param end the upper bound of the range of asset tags (not inclusive) 717 * @return the range of matching asset tags that the user has permission to view 718 */ 719 public static List<AssetTag> filterFindByGroupId(long[] groupIds, 720 int start, int end) { 721 return getPersistence().filterFindByGroupId(groupIds, start, end); 722 } 723 724 /** 725 * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any ?. 726 * 727 * <p> 728 * 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. 729 * </p> 730 * 731 * @param groupIds the group IDs 732 * @param start the lower bound of the range of asset tags 733 * @param end the upper bound of the range of asset tags (not inclusive) 734 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 735 * @return the ordered range of matching asset tags that the user has permission to view 736 */ 737 public static List<AssetTag> filterFindByGroupId(long[] groupIds, 738 int start, int end, OrderByComparator<AssetTag> orderByComparator) { 739 return getPersistence() 740 .filterFindByGroupId(groupIds, start, end, orderByComparator); 741 } 742 743 /** 744 * Returns all the asset tags where groupId = any ?. 745 * 746 * <p> 747 * 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. 748 * </p> 749 * 750 * @param groupIds the group IDs 751 * @return the matching asset tags 752 */ 753 public static List<AssetTag> findByGroupId(long[] groupIds) { 754 return getPersistence().findByGroupId(groupIds); 755 } 756 757 /** 758 * Returns a range of all the asset tags where groupId = any ?. 759 * 760 * <p> 761 * 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. 762 * </p> 763 * 764 * @param groupIds the group IDs 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 * @return the range of matching asset tags 768 */ 769 public static List<AssetTag> findByGroupId(long[] groupIds, int start, 770 int end) { 771 return getPersistence().findByGroupId(groupIds, start, end); 772 } 773 774 /** 775 * Returns an ordered range of all the asset tags where groupId = any ?. 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 groupIds the group IDs 782 * @param start the lower bound of the range of asset tags 783 * @param end the upper bound of the range of asset tags (not inclusive) 784 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 785 * @return the ordered range of matching asset tags 786 */ 787 public static List<AssetTag> findByGroupId(long[] groupIds, int start, 788 int end, OrderByComparator<AssetTag> orderByComparator) { 789 return getPersistence() 790 .findByGroupId(groupIds, start, end, orderByComparator); 791 } 792 793 /** 794 * Returns an ordered range of all the asset tags where groupId = ?, optionally using the finder cache. 795 * 796 * <p> 797 * 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. 798 * </p> 799 * 800 * @param groupId the group ID 801 * @param start the lower bound of the range of asset tags 802 * @param end the upper bound of the range of asset tags (not inclusive) 803 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 804 * @param retrieveFromCache whether to retrieve from the finder cache 805 * @return the ordered range of matching asset tags 806 */ 807 public static List<AssetTag> findByGroupId(long[] groupIds, int start, 808 int end, OrderByComparator<AssetTag> orderByComparator, 809 boolean retrieveFromCache) { 810 return getPersistence() 811 .findByGroupId(groupIds, start, end, orderByComparator, 812 retrieveFromCache); 813 } 814 815 /** 816 * Removes all the asset tags where groupId = ? from the database. 817 * 818 * @param groupId the group ID 819 */ 820 public static void removeByGroupId(long groupId) { 821 getPersistence().removeByGroupId(groupId); 822 } 823 824 /** 825 * Returns the number of asset tags where groupId = ?. 826 * 827 * @param groupId the group ID 828 * @return the number of matching asset tags 829 */ 830 public static int countByGroupId(long groupId) { 831 return getPersistence().countByGroupId(groupId); 832 } 833 834 /** 835 * Returns the number of asset tags where groupId = any ?. 836 * 837 * @param groupIds the group IDs 838 * @return the number of matching asset tags 839 */ 840 public static int countByGroupId(long[] groupIds) { 841 return getPersistence().countByGroupId(groupIds); 842 } 843 844 /** 845 * Returns the number of asset tags that the user has permission to view where groupId = ?. 846 * 847 * @param groupId the group ID 848 * @return the number of matching asset tags that the user has permission to view 849 */ 850 public static int filterCountByGroupId(long groupId) { 851 return getPersistence().filterCountByGroupId(groupId); 852 } 853 854 /** 855 * Returns the number of asset tags that the user has permission to view where groupId = any ?. 856 * 857 * @param groupIds the group IDs 858 * @return the number of matching asset tags that the user has permission to view 859 */ 860 public static int filterCountByGroupId(long[] groupIds) { 861 return getPersistence().filterCountByGroupId(groupIds); 862 } 863 864 /** 865 * Returns the asset tag where groupId = ? and name = ? or throws a {@link NoSuchTagException} if it could not be found. 866 * 867 * @param groupId the group ID 868 * @param name the name 869 * @return the matching asset tag 870 * @throws NoSuchTagException if a matching asset tag could not be found 871 */ 872 public static AssetTag findByG_N(long groupId, java.lang.String name) 873 throws com.liferay.portlet.asset.exception.NoSuchTagException { 874 return getPersistence().findByG_N(groupId, name); 875 } 876 877 /** 878 * Returns the asset tag where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 879 * 880 * @param groupId the group ID 881 * @param name the name 882 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 883 */ 884 public static AssetTag fetchByG_N(long groupId, java.lang.String name) { 885 return getPersistence().fetchByG_N(groupId, name); 886 } 887 888 /** 889 * Returns the asset tag where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 890 * 891 * @param groupId the group ID 892 * @param name the name 893 * @param retrieveFromCache whether to retrieve from the finder cache 894 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 895 */ 896 public static AssetTag fetchByG_N(long groupId, java.lang.String name, 897 boolean retrieveFromCache) { 898 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 899 } 900 901 /** 902 * Removes the asset tag where groupId = ? and name = ? from the database. 903 * 904 * @param groupId the group ID 905 * @param name the name 906 * @return the asset tag that was removed 907 */ 908 public static AssetTag removeByG_N(long groupId, java.lang.String name) 909 throws com.liferay.portlet.asset.exception.NoSuchTagException { 910 return getPersistence().removeByG_N(groupId, name); 911 } 912 913 /** 914 * Returns the number of asset tags where groupId = ? and name = ?. 915 * 916 * @param groupId the group ID 917 * @param name the name 918 * @return the number of matching asset tags 919 */ 920 public static int countByG_N(long groupId, java.lang.String name) { 921 return getPersistence().countByG_N(groupId, name); 922 } 923 924 /** 925 * Returns all the asset tags where groupId = ? and name LIKE ?. 926 * 927 * @param groupId the group ID 928 * @param name the name 929 * @return the matching asset tags 930 */ 931 public static List<AssetTag> findByG_LikeN(long groupId, 932 java.lang.String name) { 933 return getPersistence().findByG_LikeN(groupId, name); 934 } 935 936 /** 937 * Returns a range of all the asset tags where groupId = ? and name LIKE ?. 938 * 939 * <p> 940 * 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. 941 * </p> 942 * 943 * @param groupId the group ID 944 * @param name the name 945 * @param start the lower bound of the range of asset tags 946 * @param end the upper bound of the range of asset tags (not inclusive) 947 * @return the range of matching asset tags 948 */ 949 public static List<AssetTag> findByG_LikeN(long groupId, 950 java.lang.String name, int start, int end) { 951 return getPersistence().findByG_LikeN(groupId, name, start, end); 952 } 953 954 /** 955 * Returns an ordered range of all the asset tags where groupId = ? and name LIKE ?. 956 * 957 * <p> 958 * 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. 959 * </p> 960 * 961 * @param groupId the group ID 962 * @param name the name 963 * @param start the lower bound of the range of asset tags 964 * @param end the upper bound of the range of asset tags (not inclusive) 965 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 966 * @return the ordered range of matching asset tags 967 */ 968 public static List<AssetTag> findByG_LikeN(long groupId, 969 java.lang.String name, int start, int end, 970 OrderByComparator<AssetTag> orderByComparator) { 971 return getPersistence() 972 .findByG_LikeN(groupId, name, start, end, orderByComparator); 973 } 974 975 /** 976 * Returns an ordered range of all the asset tags where groupId = ? and name LIKE ?. 977 * 978 * <p> 979 * 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. 980 * </p> 981 * 982 * @param groupId the group ID 983 * @param name the name 984 * @param start the lower bound of the range of asset tags 985 * @param end the upper bound of the range of asset tags (not inclusive) 986 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 987 * @param retrieveFromCache whether to retrieve from the finder cache 988 * @return the ordered range of matching asset tags 989 */ 990 public static List<AssetTag> findByG_LikeN(long groupId, 991 java.lang.String name, int start, int end, 992 OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) { 993 return getPersistence() 994 .findByG_LikeN(groupId, name, start, end, orderByComparator, 995 retrieveFromCache); 996 } 997 998 /** 999 * Returns the first asset tag in the ordered set where groupId = ? and name LIKE ?. 1000 * 1001 * @param groupId the group ID 1002 * @param name the name 1003 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1004 * @return the first matching asset tag 1005 * @throws NoSuchTagException if a matching asset tag could not be found 1006 */ 1007 public static AssetTag findByG_LikeN_First(long groupId, 1008 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) 1009 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1010 return getPersistence() 1011 .findByG_LikeN_First(groupId, name, orderByComparator); 1012 } 1013 1014 /** 1015 * Returns the first asset tag in the ordered set where groupId = ? and name LIKE ?. 1016 * 1017 * @param groupId the group ID 1018 * @param name the name 1019 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1020 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 1021 */ 1022 public static AssetTag fetchByG_LikeN_First(long groupId, 1023 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) { 1024 return getPersistence() 1025 .fetchByG_LikeN_First(groupId, name, orderByComparator); 1026 } 1027 1028 /** 1029 * Returns the last asset tag in the ordered set where groupId = ? and name LIKE ?. 1030 * 1031 * @param groupId the group ID 1032 * @param name the name 1033 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1034 * @return the last matching asset tag 1035 * @throws NoSuchTagException if a matching asset tag could not be found 1036 */ 1037 public static AssetTag findByG_LikeN_Last(long groupId, 1038 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) 1039 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1040 return getPersistence() 1041 .findByG_LikeN_Last(groupId, name, orderByComparator); 1042 } 1043 1044 /** 1045 * Returns the last asset tag in the ordered set where groupId = ? and name LIKE ?. 1046 * 1047 * @param groupId the group ID 1048 * @param name the name 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 1051 */ 1052 public static AssetTag fetchByG_LikeN_Last(long groupId, 1053 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) { 1054 return getPersistence() 1055 .fetchByG_LikeN_Last(groupId, name, orderByComparator); 1056 } 1057 1058 /** 1059 * Returns the asset tags before and after the current asset tag in the ordered set where groupId = ? and name LIKE ?. 1060 * 1061 * @param tagId the primary key of the current asset tag 1062 * @param groupId the group ID 1063 * @param name the name 1064 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1065 * @return the previous, current, and next asset tag 1066 * @throws NoSuchTagException if a asset tag with the primary key could not be found 1067 */ 1068 public static AssetTag[] findByG_LikeN_PrevAndNext(long tagId, 1069 long groupId, java.lang.String name, 1070 OrderByComparator<AssetTag> orderByComparator) 1071 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1072 return getPersistence() 1073 .findByG_LikeN_PrevAndNext(tagId, groupId, name, 1074 orderByComparator); 1075 } 1076 1077 /** 1078 * Returns all the asset tags that the user has permission to view where groupId = ? and name LIKE ?. 1079 * 1080 * @param groupId the group ID 1081 * @param name the name 1082 * @return the matching asset tags that the user has permission to view 1083 */ 1084 public static List<AssetTag> filterFindByG_LikeN(long groupId, 1085 java.lang.String name) { 1086 return getPersistence().filterFindByG_LikeN(groupId, name); 1087 } 1088 1089 /** 1090 * Returns a range of all the asset tags that the user has permission to view where groupId = ? and name LIKE ?. 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 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. 1094 * </p> 1095 * 1096 * @param groupId the group ID 1097 * @param name the name 1098 * @param start the lower bound of the range of asset tags 1099 * @param end the upper bound of the range of asset tags (not inclusive) 1100 * @return the range of matching asset tags that the user has permission to view 1101 */ 1102 public static List<AssetTag> filterFindByG_LikeN(long groupId, 1103 java.lang.String name, int start, int end) { 1104 return getPersistence().filterFindByG_LikeN(groupId, name, start, end); 1105 } 1106 1107 /** 1108 * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = ? and name LIKE ?. 1109 * 1110 * <p> 1111 * 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. 1112 * </p> 1113 * 1114 * @param groupId the group ID 1115 * @param name the name 1116 * @param start the lower bound of the range of asset tags 1117 * @param end the upper bound of the range of asset tags (not inclusive) 1118 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1119 * @return the ordered range of matching asset tags that the user has permission to view 1120 */ 1121 public static List<AssetTag> filterFindByG_LikeN(long groupId, 1122 java.lang.String name, int start, int end, 1123 OrderByComparator<AssetTag> orderByComparator) { 1124 return getPersistence() 1125 .filterFindByG_LikeN(groupId, name, start, end, 1126 orderByComparator); 1127 } 1128 1129 /** 1130 * 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 ?. 1131 * 1132 * @param tagId the primary key of the current asset tag 1133 * @param groupId the group ID 1134 * @param name the name 1135 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1136 * @return the previous, current, and next asset tag 1137 * @throws NoSuchTagException if a asset tag with the primary key could not be found 1138 */ 1139 public static AssetTag[] filterFindByG_LikeN_PrevAndNext(long tagId, 1140 long groupId, java.lang.String name, 1141 OrderByComparator<AssetTag> orderByComparator) 1142 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1143 return getPersistence() 1144 .filterFindByG_LikeN_PrevAndNext(tagId, groupId, name, 1145 orderByComparator); 1146 } 1147 1148 /** 1149 * Returns all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 1150 * 1151 * @param groupIds the group IDs 1152 * @param name the name 1153 * @return the matching asset tags that the user has permission to view 1154 */ 1155 public static List<AssetTag> filterFindByG_LikeN(long[] groupIds, 1156 java.lang.String name) { 1157 return getPersistence().filterFindByG_LikeN(groupIds, name); 1158 } 1159 1160 /** 1161 * Returns a range of all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 1162 * 1163 * <p> 1164 * 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. 1165 * </p> 1166 * 1167 * @param groupIds the group IDs 1168 * @param name the name 1169 * @param start the lower bound of the range of asset tags 1170 * @param end the upper bound of the range of asset tags (not inclusive) 1171 * @return the range of matching asset tags that the user has permission to view 1172 */ 1173 public static List<AssetTag> filterFindByG_LikeN(long[] groupIds, 1174 java.lang.String name, int start, int end) { 1175 return getPersistence().filterFindByG_LikeN(groupIds, name, start, end); 1176 } 1177 1178 /** 1179 * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 1180 * 1181 * <p> 1182 * 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. 1183 * </p> 1184 * 1185 * @param groupIds the group IDs 1186 * @param name the name 1187 * @param start the lower bound of the range of asset tags 1188 * @param end the upper bound of the range of asset tags (not inclusive) 1189 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1190 * @return the ordered range of matching asset tags that the user has permission to view 1191 */ 1192 public static List<AssetTag> filterFindByG_LikeN(long[] groupIds, 1193 java.lang.String name, int start, int end, 1194 OrderByComparator<AssetTag> orderByComparator) { 1195 return getPersistence() 1196 .filterFindByG_LikeN(groupIds, name, start, end, 1197 orderByComparator); 1198 } 1199 1200 /** 1201 * Returns all the asset tags where groupId = any ? and name LIKE ?. 1202 * 1203 * <p> 1204 * 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. 1205 * </p> 1206 * 1207 * @param groupIds the group IDs 1208 * @param name the name 1209 * @return the matching asset tags 1210 */ 1211 public static List<AssetTag> findByG_LikeN(long[] groupIds, 1212 java.lang.String name) { 1213 return getPersistence().findByG_LikeN(groupIds, name); 1214 } 1215 1216 /** 1217 * Returns a range of all the asset tags where groupId = any ? and name LIKE ?. 1218 * 1219 * <p> 1220 * 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. 1221 * </p> 1222 * 1223 * @param groupIds the group IDs 1224 * @param name the name 1225 * @param start the lower bound of the range of asset tags 1226 * @param end the upper bound of the range of asset tags (not inclusive) 1227 * @return the range of matching asset tags 1228 */ 1229 public static List<AssetTag> findByG_LikeN(long[] groupIds, 1230 java.lang.String name, int start, int end) { 1231 return getPersistence().findByG_LikeN(groupIds, name, start, end); 1232 } 1233 1234 /** 1235 * Returns an ordered range of all the asset tags where groupId = any ? and name LIKE ?. 1236 * 1237 * <p> 1238 * 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. 1239 * </p> 1240 * 1241 * @param groupIds the group IDs 1242 * @param name the name 1243 * @param start the lower bound of the range of asset tags 1244 * @param end the upper bound of the range of asset tags (not inclusive) 1245 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1246 * @return the ordered range of matching asset tags 1247 */ 1248 public static List<AssetTag> findByG_LikeN(long[] groupIds, 1249 java.lang.String name, int start, int end, 1250 OrderByComparator<AssetTag> orderByComparator) { 1251 return getPersistence() 1252 .findByG_LikeN(groupIds, name, start, end, orderByComparator); 1253 } 1254 1255 /** 1256 * Returns an ordered range of all the asset tags where groupId = ? and name LIKE ?, optionally using the finder cache. 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 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. 1260 * </p> 1261 * 1262 * @param groupId the group ID 1263 * @param name the name 1264 * @param start the lower bound of the range of asset tags 1265 * @param end the upper bound of the range of asset tags (not inclusive) 1266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1267 * @param retrieveFromCache whether to retrieve from the finder cache 1268 * @return the ordered range of matching asset tags 1269 */ 1270 public static List<AssetTag> findByG_LikeN(long[] groupIds, 1271 java.lang.String name, int start, int end, 1272 OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) { 1273 return getPersistence() 1274 .findByG_LikeN(groupIds, name, start, end, 1275 orderByComparator, retrieveFromCache); 1276 } 1277 1278 /** 1279 * Removes all the asset tags where groupId = ? and name LIKE ? from the database. 1280 * 1281 * @param groupId the group ID 1282 * @param name the name 1283 */ 1284 public static void removeByG_LikeN(long groupId, java.lang.String name) { 1285 getPersistence().removeByG_LikeN(groupId, name); 1286 } 1287 1288 /** 1289 * Returns the number of asset tags where groupId = ? and name LIKE ?. 1290 * 1291 * @param groupId the group ID 1292 * @param name the name 1293 * @return the number of matching asset tags 1294 */ 1295 public static int countByG_LikeN(long groupId, java.lang.String name) { 1296 return getPersistence().countByG_LikeN(groupId, name); 1297 } 1298 1299 /** 1300 * Returns the number of asset tags where groupId = any ? and name LIKE ?. 1301 * 1302 * @param groupIds the group IDs 1303 * @param name the name 1304 * @return the number of matching asset tags 1305 */ 1306 public static int countByG_LikeN(long[] groupIds, java.lang.String name) { 1307 return getPersistence().countByG_LikeN(groupIds, name); 1308 } 1309 1310 /** 1311 * Returns the number of asset tags that the user has permission to view where groupId = ? and name LIKE ?. 1312 * 1313 * @param groupId the group ID 1314 * @param name the name 1315 * @return the number of matching asset tags that the user has permission to view 1316 */ 1317 public static int filterCountByG_LikeN(long groupId, java.lang.String name) { 1318 return getPersistence().filterCountByG_LikeN(groupId, name); 1319 } 1320 1321 /** 1322 * Returns the number of asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 1323 * 1324 * @param groupIds the group IDs 1325 * @param name the name 1326 * @return the number of matching asset tags that the user has permission to view 1327 */ 1328 public static int filterCountByG_LikeN(long[] groupIds, 1329 java.lang.String name) { 1330 return getPersistence().filterCountByG_LikeN(groupIds, name); 1331 } 1332 1333 /** 1334 * Caches the asset tag in the entity cache if it is enabled. 1335 * 1336 * @param assetTag the asset tag 1337 */ 1338 public static void cacheResult(AssetTag assetTag) { 1339 getPersistence().cacheResult(assetTag); 1340 } 1341 1342 /** 1343 * Caches the asset tags in the entity cache if it is enabled. 1344 * 1345 * @param assetTags the asset tags 1346 */ 1347 public static void cacheResult(List<AssetTag> assetTags) { 1348 getPersistence().cacheResult(assetTags); 1349 } 1350 1351 /** 1352 * Creates a new asset tag with the primary key. Does not add the asset tag to the database. 1353 * 1354 * @param tagId the primary key for the new asset tag 1355 * @return the new asset tag 1356 */ 1357 public static AssetTag create(long tagId) { 1358 return getPersistence().create(tagId); 1359 } 1360 1361 /** 1362 * Removes the asset tag with the primary key from the database. Also notifies the appropriate model listeners. 1363 * 1364 * @param tagId the primary key of the asset tag 1365 * @return the asset tag that was removed 1366 * @throws NoSuchTagException if a asset tag with the primary key could not be found 1367 */ 1368 public static AssetTag remove(long tagId) 1369 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1370 return getPersistence().remove(tagId); 1371 } 1372 1373 public static AssetTag updateImpl(AssetTag assetTag) { 1374 return getPersistence().updateImpl(assetTag); 1375 } 1376 1377 /** 1378 * Returns the asset tag with the primary key or throws a {@link NoSuchTagException} if it could not be found. 1379 * 1380 * @param tagId the primary key of the asset tag 1381 * @return the asset tag 1382 * @throws NoSuchTagException if a asset tag with the primary key could not be found 1383 */ 1384 public static AssetTag findByPrimaryKey(long tagId) 1385 throws com.liferay.portlet.asset.exception.NoSuchTagException { 1386 return getPersistence().findByPrimaryKey(tagId); 1387 } 1388 1389 /** 1390 * Returns the asset tag with the primary key or returns <code>null</code> if it could not be found. 1391 * 1392 * @param tagId the primary key of the asset tag 1393 * @return the asset tag, or <code>null</code> if a asset tag with the primary key could not be found 1394 */ 1395 public static AssetTag fetchByPrimaryKey(long tagId) { 1396 return getPersistence().fetchByPrimaryKey(tagId); 1397 } 1398 1399 public static java.util.Map<java.io.Serializable, AssetTag> fetchByPrimaryKeys( 1400 java.util.Set<java.io.Serializable> primaryKeys) { 1401 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1402 } 1403 1404 /** 1405 * Returns all the asset tags. 1406 * 1407 * @return the asset tags 1408 */ 1409 public static List<AssetTag> findAll() { 1410 return getPersistence().findAll(); 1411 } 1412 1413 /** 1414 * Returns a range of all the asset tags. 1415 * 1416 * <p> 1417 * 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. 1418 * </p> 1419 * 1420 * @param start the lower bound of the range of asset tags 1421 * @param end the upper bound of the range of asset tags (not inclusive) 1422 * @return the range of asset tags 1423 */ 1424 public static List<AssetTag> findAll(int start, int end) { 1425 return getPersistence().findAll(start, end); 1426 } 1427 1428 /** 1429 * Returns an ordered range of all the asset tags. 1430 * 1431 * <p> 1432 * 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. 1433 * </p> 1434 * 1435 * @param start the lower bound of the range of asset tags 1436 * @param end the upper bound of the range of asset tags (not inclusive) 1437 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1438 * @return the ordered range of asset tags 1439 */ 1440 public static List<AssetTag> findAll(int start, int end, 1441 OrderByComparator<AssetTag> orderByComparator) { 1442 return getPersistence().findAll(start, end, orderByComparator); 1443 } 1444 1445 /** 1446 * Returns an ordered range of all the asset tags. 1447 * 1448 * <p> 1449 * 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. 1450 * </p> 1451 * 1452 * @param start the lower bound of the range of asset tags 1453 * @param end the upper bound of the range of asset tags (not inclusive) 1454 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1455 * @param retrieveFromCache whether to retrieve from the finder cache 1456 * @return the ordered range of asset tags 1457 */ 1458 public static List<AssetTag> findAll(int start, int end, 1459 OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) { 1460 return getPersistence() 1461 .findAll(start, end, orderByComparator, retrieveFromCache); 1462 } 1463 1464 /** 1465 * Removes all the asset tags from the database. 1466 */ 1467 public static void removeAll() { 1468 getPersistence().removeAll(); 1469 } 1470 1471 /** 1472 * Returns the number of asset tags. 1473 * 1474 * @return the number of asset tags 1475 */ 1476 public static int countAll() { 1477 return getPersistence().countAll(); 1478 } 1479 1480 /** 1481 * Returns the primaryKeys of asset entries associated with the asset tag. 1482 * 1483 * @param pk the primary key of the asset tag 1484 * @return long[] of the primaryKeys of asset entries associated with the asset tag 1485 */ 1486 public static long[] getAssetEntryPrimaryKeys(long pk) { 1487 return getPersistence().getAssetEntryPrimaryKeys(pk); 1488 } 1489 1490 /** 1491 * Returns all the asset entries associated with the asset tag. 1492 * 1493 * @param pk the primary key of the asset tag 1494 * @return the asset entries associated with the asset tag 1495 */ 1496 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1497 long pk) { 1498 return getPersistence().getAssetEntries(pk); 1499 } 1500 1501 /** 1502 * Returns a range of all the asset entries associated with the asset tag. 1503 * 1504 * <p> 1505 * 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. 1506 * </p> 1507 * 1508 * @param pk the primary key of the asset tag 1509 * @param start the lower bound of the range of asset tags 1510 * @param end the upper bound of the range of asset tags (not inclusive) 1511 * @return the range of asset entries associated with the asset tag 1512 */ 1513 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1514 long pk, int start, int end) { 1515 return getPersistence().getAssetEntries(pk, start, end); 1516 } 1517 1518 /** 1519 * Returns an ordered range of all the asset entries associated with the asset tag. 1520 * 1521 * <p> 1522 * 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. 1523 * </p> 1524 * 1525 * @param pk the primary key of the asset tag 1526 * @param start the lower bound of the range of asset tags 1527 * @param end the upper bound of the range of asset tags (not inclusive) 1528 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1529 * @return the ordered range of asset entries associated with the asset tag 1530 */ 1531 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1532 long pk, int start, int end, 1533 OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator) { 1534 return getPersistence() 1535 .getAssetEntries(pk, start, end, orderByComparator); 1536 } 1537 1538 /** 1539 * Returns the number of asset entries associated with the asset tag. 1540 * 1541 * @param pk the primary key of the asset tag 1542 * @return the number of asset entries associated with the asset tag 1543 */ 1544 public static int getAssetEntriesSize(long pk) { 1545 return getPersistence().getAssetEntriesSize(pk); 1546 } 1547 1548 /** 1549 * Returns <code>true</code> if the asset entry is associated with the asset tag. 1550 * 1551 * @param pk the primary key of the asset tag 1552 * @param assetEntryPK the primary key of the asset entry 1553 * @return <code>true</code> if the asset entry is associated with the asset tag; <code>false</code> otherwise 1554 */ 1555 public static boolean containsAssetEntry(long pk, long assetEntryPK) { 1556 return getPersistence().containsAssetEntry(pk, assetEntryPK); 1557 } 1558 1559 /** 1560 * Returns <code>true</code> if the asset tag has any asset entries associated with it. 1561 * 1562 * @param pk the primary key of the asset tag to check for associations with asset entries 1563 * @return <code>true</code> if the asset tag has any asset entries associated with it; <code>false</code> otherwise 1564 */ 1565 public static boolean containsAssetEntries(long pk) { 1566 return getPersistence().containsAssetEntries(pk); 1567 } 1568 1569 /** 1570 * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1571 * 1572 * @param pk the primary key of the asset tag 1573 * @param assetEntryPK the primary key of the asset entry 1574 */ 1575 public static void addAssetEntry(long pk, long assetEntryPK) { 1576 getPersistence().addAssetEntry(pk, assetEntryPK); 1577 } 1578 1579 /** 1580 * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1581 * 1582 * @param pk the primary key of the asset tag 1583 * @param assetEntry the asset entry 1584 */ 1585 public static void addAssetEntry(long pk, 1586 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 1587 getPersistence().addAssetEntry(pk, assetEntry); 1588 } 1589 1590 /** 1591 * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1592 * 1593 * @param pk the primary key of the asset tag 1594 * @param assetEntryPKs the primary keys of the asset entries 1595 */ 1596 public static void addAssetEntries(long pk, long[] assetEntryPKs) { 1597 getPersistence().addAssetEntries(pk, assetEntryPKs); 1598 } 1599 1600 /** 1601 * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1602 * 1603 * @param pk the primary key of the asset tag 1604 * @param assetEntries the asset entries 1605 */ 1606 public static void addAssetEntries(long pk, 1607 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1608 getPersistence().addAssetEntries(pk, assetEntries); 1609 } 1610 1611 /** 1612 * Clears all associations between the asset tag and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1613 * 1614 * @param pk the primary key of the asset tag to clear the associated asset entries from 1615 */ 1616 public static void clearAssetEntries(long pk) { 1617 getPersistence().clearAssetEntries(pk); 1618 } 1619 1620 /** 1621 * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1622 * 1623 * @param pk the primary key of the asset tag 1624 * @param assetEntryPK the primary key of the asset entry 1625 */ 1626 public static void removeAssetEntry(long pk, long assetEntryPK) { 1627 getPersistence().removeAssetEntry(pk, assetEntryPK); 1628 } 1629 1630 /** 1631 * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1632 * 1633 * @param pk the primary key of the asset tag 1634 * @param assetEntry the asset entry 1635 */ 1636 public static void removeAssetEntry(long pk, 1637 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 1638 getPersistence().removeAssetEntry(pk, assetEntry); 1639 } 1640 1641 /** 1642 * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1643 * 1644 * @param pk the primary key of the asset tag 1645 * @param assetEntryPKs the primary keys of the asset entries 1646 */ 1647 public static void removeAssetEntries(long pk, long[] assetEntryPKs) { 1648 getPersistence().removeAssetEntries(pk, assetEntryPKs); 1649 } 1650 1651 /** 1652 * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1653 * 1654 * @param pk the primary key of the asset tag 1655 * @param assetEntries the asset entries 1656 */ 1657 public static void removeAssetEntries(long pk, 1658 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1659 getPersistence().removeAssetEntries(pk, assetEntries); 1660 } 1661 1662 /** 1663 * 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. 1664 * 1665 * @param pk the primary key of the asset tag 1666 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset tag 1667 */ 1668 public static void setAssetEntries(long pk, long[] assetEntryPKs) { 1669 getPersistence().setAssetEntries(pk, assetEntryPKs); 1670 } 1671 1672 /** 1673 * 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. 1674 * 1675 * @param pk the primary key of the asset tag 1676 * @param assetEntries the asset entries to be associated with the asset tag 1677 */ 1678 public static void setAssetEntries(long pk, 1679 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1680 getPersistence().setAssetEntries(pk, assetEntries); 1681 } 1682 1683 public static java.util.Set<java.lang.String> getBadColumnNames() { 1684 return getPersistence().getBadColumnNames(); 1685 } 1686 1687 public static AssetTagPersistence getPersistence() { 1688 if (_persistence == null) { 1689 _persistence = (AssetTagPersistence)PortalBeanLocatorUtil.locate(AssetTagPersistence.class.getName()); 1690 1691 ReferenceRegistry.registerReference(AssetTagUtil.class, 1692 "_persistence"); 1693 } 1694 1695 return _persistence; 1696 } 1697 1698 private static AssetTagPersistence _persistence; 1699 }