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 groupId = ?. 113 * 114 * @param groupId the group ID 115 * @return the matching asset tags 116 */ 117 public static List<AssetTag> findByGroupId(long groupId) { 118 return getPersistence().findByGroupId(groupId); 119 } 120 121 /** 122 * Returns a range of all the asset tags where groupId = ?. 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 groupId the group ID 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> findByGroupId(long groupId, int start, int end) { 134 return getPersistence().findByGroupId(groupId, start, end); 135 } 136 137 /** 138 * Returns an ordered range of all the asset tags where groupId = ?. 139 * 140 * <p> 141 * 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. 142 * </p> 143 * 144 * @param groupId the group ID 145 * @param start the lower bound of the range of asset tags 146 * @param end the upper bound of the range of asset tags (not inclusive) 147 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 148 * @return the ordered range of matching asset tags 149 */ 150 public static List<AssetTag> findByGroupId(long groupId, int start, 151 int end, OrderByComparator<AssetTag> orderByComparator) { 152 return getPersistence() 153 .findByGroupId(groupId, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns the first asset tag in the ordered set where groupId = ?. 158 * 159 * @param groupId the group ID 160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 161 * @return the first matching asset tag 162 * @throws NoSuchTagException if a matching asset tag could not be found 163 */ 164 public static AssetTag findByGroupId_First(long groupId, 165 OrderByComparator<AssetTag> orderByComparator) 166 throws com.liferay.portlet.asset.NoSuchTagException { 167 return getPersistence().findByGroupId_First(groupId, orderByComparator); 168 } 169 170 /** 171 * Returns the first asset tag in the ordered set where groupId = ?. 172 * 173 * @param groupId the group ID 174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 175 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 176 */ 177 public static AssetTag fetchByGroupId_First(long groupId, 178 OrderByComparator<AssetTag> orderByComparator) { 179 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 180 } 181 182 /** 183 * Returns the last asset tag in the ordered set where groupId = ?. 184 * 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the last matching asset tag 188 * @throws NoSuchTagException if a matching asset tag could not be found 189 */ 190 public static AssetTag findByGroupId_Last(long groupId, 191 OrderByComparator<AssetTag> orderByComparator) 192 throws com.liferay.portlet.asset.NoSuchTagException { 193 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 194 } 195 196 /** 197 * Returns the last asset tag in the ordered set where groupId = ?. 198 * 199 * @param groupId the group ID 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 202 */ 203 public static AssetTag fetchByGroupId_Last(long groupId, 204 OrderByComparator<AssetTag> orderByComparator) { 205 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 206 } 207 208 /** 209 * Returns the asset tags before and after the current asset tag in the ordered set where groupId = ?. 210 * 211 * @param tagId the primary key of the current asset tag 212 * @param groupId the group ID 213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 214 * @return the previous, current, and next asset tag 215 * @throws NoSuchTagException if a asset tag with the primary key could not be found 216 */ 217 public static AssetTag[] findByGroupId_PrevAndNext(long tagId, 218 long groupId, OrderByComparator<AssetTag> orderByComparator) 219 throws com.liferay.portlet.asset.NoSuchTagException { 220 return getPersistence() 221 .findByGroupId_PrevAndNext(tagId, groupId, orderByComparator); 222 } 223 224 /** 225 * Returns all the asset tags that the user has permission to view where groupId = ?. 226 * 227 * @param groupId the group ID 228 * @return the matching asset tags that the user has permission to view 229 */ 230 public static List<AssetTag> filterFindByGroupId(long groupId) { 231 return getPersistence().filterFindByGroupId(groupId); 232 } 233 234 /** 235 * Returns a range of all the asset tags that the user has permission to view where groupId = ?. 236 * 237 * <p> 238 * 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. 239 * </p> 240 * 241 * @param groupId the group ID 242 * @param start the lower bound of the range of asset tags 243 * @param end the upper bound of the range of asset tags (not inclusive) 244 * @return the range of matching asset tags that the user has permission to view 245 */ 246 public static List<AssetTag> filterFindByGroupId(long groupId, int start, 247 int end) { 248 return getPersistence().filterFindByGroupId(groupId, start, end); 249 } 250 251 /** 252 * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = ?. 253 * 254 * <p> 255 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 256 * </p> 257 * 258 * @param groupId the group ID 259 * @param start the lower bound of the range of asset tags 260 * @param end the upper bound of the range of asset tags (not inclusive) 261 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 262 * @return the ordered range of matching asset tags that the user has permission to view 263 */ 264 public static List<AssetTag> filterFindByGroupId(long groupId, int start, 265 int end, OrderByComparator<AssetTag> orderByComparator) { 266 return getPersistence() 267 .filterFindByGroupId(groupId, start, end, orderByComparator); 268 } 269 270 /** 271 * 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 = ?. 272 * 273 * @param tagId the primary key of the current asset tag 274 * @param groupId the group ID 275 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 276 * @return the previous, current, and next asset tag 277 * @throws NoSuchTagException if a asset tag with the primary key could not be found 278 */ 279 public static AssetTag[] filterFindByGroupId_PrevAndNext(long tagId, 280 long groupId, OrderByComparator<AssetTag> orderByComparator) 281 throws com.liferay.portlet.asset.NoSuchTagException { 282 return getPersistence() 283 .filterFindByGroupId_PrevAndNext(tagId, groupId, 284 orderByComparator); 285 } 286 287 /** 288 * Returns all the asset tags that the user has permission to view where groupId = any ?. 289 * 290 * @param groupIds the group IDs 291 * @return the matching asset tags that the user has permission to view 292 */ 293 public static List<AssetTag> filterFindByGroupId(long[] groupIds) { 294 return getPersistence().filterFindByGroupId(groupIds); 295 } 296 297 /** 298 * Returns a range of all the asset tags that the user has permission to view where groupId = any ?. 299 * 300 * <p> 301 * 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. 302 * </p> 303 * 304 * @param groupIds the group IDs 305 * @param start the lower bound of the range of asset tags 306 * @param end the upper bound of the range of asset tags (not inclusive) 307 * @return the range of matching asset tags that the user has permission to view 308 */ 309 public static List<AssetTag> filterFindByGroupId(long[] groupIds, 310 int start, int end) { 311 return getPersistence().filterFindByGroupId(groupIds, start, end); 312 } 313 314 /** 315 * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any ?. 316 * 317 * <p> 318 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 319 * </p> 320 * 321 * @param groupIds the group IDs 322 * @param start the lower bound of the range of asset tags 323 * @param end the upper bound of the range of asset tags (not inclusive) 324 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 325 * @return the ordered range of matching asset tags that the user has permission to view 326 */ 327 public static List<AssetTag> filterFindByGroupId(long[] groupIds, 328 int start, int end, OrderByComparator<AssetTag> orderByComparator) { 329 return getPersistence() 330 .filterFindByGroupId(groupIds, start, end, orderByComparator); 331 } 332 333 /** 334 * Returns all the asset tags where groupId = any ?. 335 * 336 * <p> 337 * 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. 338 * </p> 339 * 340 * @param groupIds the group IDs 341 * @return the matching asset tags 342 */ 343 public static List<AssetTag> findByGroupId(long[] groupIds) { 344 return getPersistence().findByGroupId(groupIds); 345 } 346 347 /** 348 * Returns a range of all the asset tags where groupId = any ?. 349 * 350 * <p> 351 * 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. 352 * </p> 353 * 354 * @param groupIds the group IDs 355 * @param start the lower bound of the range of asset tags 356 * @param end the upper bound of the range of asset tags (not inclusive) 357 * @return the range of matching asset tags 358 */ 359 public static List<AssetTag> findByGroupId(long[] groupIds, int start, 360 int end) { 361 return getPersistence().findByGroupId(groupIds, start, end); 362 } 363 364 /** 365 * Returns an ordered range of all the asset tags where groupId = any ?. 366 * 367 * <p> 368 * 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. 369 * </p> 370 * 371 * @param groupIds the group IDs 372 * @param start the lower bound of the range of asset tags 373 * @param end the upper bound of the range of asset tags (not inclusive) 374 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 375 * @return the ordered range of matching asset tags 376 */ 377 public static List<AssetTag> findByGroupId(long[] groupIds, int start, 378 int end, OrderByComparator<AssetTag> orderByComparator) { 379 return getPersistence() 380 .findByGroupId(groupIds, start, end, orderByComparator); 381 } 382 383 /** 384 * Removes all the asset tags where groupId = ? from the database. 385 * 386 * @param groupId the group ID 387 */ 388 public static void removeByGroupId(long groupId) { 389 getPersistence().removeByGroupId(groupId); 390 } 391 392 /** 393 * Returns the number of asset tags where groupId = ?. 394 * 395 * @param groupId the group ID 396 * @return the number of matching asset tags 397 */ 398 public static int countByGroupId(long groupId) { 399 return getPersistence().countByGroupId(groupId); 400 } 401 402 /** 403 * Returns the number of asset tags where groupId = any ?. 404 * 405 * @param groupIds the group IDs 406 * @return the number of matching asset tags 407 */ 408 public static int countByGroupId(long[] groupIds) { 409 return getPersistence().countByGroupId(groupIds); 410 } 411 412 /** 413 * Returns the number of asset tags that the user has permission to view where groupId = ?. 414 * 415 * @param groupId the group ID 416 * @return the number of matching asset tags that the user has permission to view 417 */ 418 public static int filterCountByGroupId(long groupId) { 419 return getPersistence().filterCountByGroupId(groupId); 420 } 421 422 /** 423 * Returns the number of asset tags that the user has permission to view where groupId = any ?. 424 * 425 * @param groupIds the group IDs 426 * @return the number of matching asset tags that the user has permission to view 427 */ 428 public static int filterCountByGroupId(long[] groupIds) { 429 return getPersistence().filterCountByGroupId(groupIds); 430 } 431 432 /** 433 * Returns the asset tag where groupId = ? and name = ? or throws a {@link NoSuchTagException} if it could not be found. 434 * 435 * @param groupId the group ID 436 * @param name the name 437 * @return the matching asset tag 438 * @throws NoSuchTagException if a matching asset tag could not be found 439 */ 440 public static AssetTag findByG_N(long groupId, java.lang.String name) 441 throws com.liferay.portlet.asset.NoSuchTagException { 442 return getPersistence().findByG_N(groupId, name); 443 } 444 445 /** 446 * Returns the asset tag where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 447 * 448 * @param groupId the group ID 449 * @param name the name 450 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 451 */ 452 public static AssetTag fetchByG_N(long groupId, java.lang.String name) { 453 return getPersistence().fetchByG_N(groupId, name); 454 } 455 456 /** 457 * Returns the asset tag where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 458 * 459 * @param groupId the group ID 460 * @param name the name 461 * @param retrieveFromCache whether to use the finder cache 462 * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found 463 */ 464 public static AssetTag fetchByG_N(long groupId, java.lang.String name, 465 boolean retrieveFromCache) { 466 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 467 } 468 469 /** 470 * Removes the asset tag where groupId = ? and name = ? from the database. 471 * 472 * @param groupId the group ID 473 * @param name the name 474 * @return the asset tag that was removed 475 */ 476 public static AssetTag removeByG_N(long groupId, java.lang.String name) 477 throws com.liferay.portlet.asset.NoSuchTagException { 478 return getPersistence().removeByG_N(groupId, name); 479 } 480 481 /** 482 * Returns the number of asset tags where groupId = ? and name = ?. 483 * 484 * @param groupId the group ID 485 * @param name the name 486 * @return the number of matching asset tags 487 */ 488 public static int countByG_N(long groupId, java.lang.String name) { 489 return getPersistence().countByG_N(groupId, name); 490 } 491 492 /** 493 * Returns all the asset tags where groupId = ? and name LIKE ?. 494 * 495 * @param groupId the group ID 496 * @param name the name 497 * @return the matching asset tags 498 */ 499 public static List<AssetTag> findByG_LikeN(long groupId, 500 java.lang.String name) { 501 return getPersistence().findByG_LikeN(groupId, name); 502 } 503 504 /** 505 * Returns a range of all the asset tags where groupId = ? and name LIKE ?. 506 * 507 * <p> 508 * 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. 509 * </p> 510 * 511 * @param groupId the group ID 512 * @param name the name 513 * @param start the lower bound of the range of asset tags 514 * @param end the upper bound of the range of asset tags (not inclusive) 515 * @return the range of matching asset tags 516 */ 517 public static List<AssetTag> findByG_LikeN(long groupId, 518 java.lang.String name, int start, int end) { 519 return getPersistence().findByG_LikeN(groupId, name, start, end); 520 } 521 522 /** 523 * Returns an ordered range of all the asset tags where groupId = ? and name LIKE ?. 524 * 525 * <p> 526 * 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. 527 * </p> 528 * 529 * @param groupId the group ID 530 * @param name the name 531 * @param start the lower bound of the range of asset tags 532 * @param end the upper bound of the range of asset tags (not inclusive) 533 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 534 * @return the ordered range of matching asset tags 535 */ 536 public static List<AssetTag> findByG_LikeN(long groupId, 537 java.lang.String name, int start, int end, 538 OrderByComparator<AssetTag> orderByComparator) { 539 return getPersistence() 540 .findByG_LikeN(groupId, name, start, end, orderByComparator); 541 } 542 543 /** 544 * Returns the first asset tag in the ordered set where groupId = ? and name LIKE ?. 545 * 546 * @param groupId the group ID 547 * @param name the name 548 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 549 * @return the first matching asset tag 550 * @throws NoSuchTagException if a matching asset tag could not be found 551 */ 552 public static AssetTag findByG_LikeN_First(long groupId, 553 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) 554 throws com.liferay.portlet.asset.NoSuchTagException { 555 return getPersistence() 556 .findByG_LikeN_First(groupId, name, orderByComparator); 557 } 558 559 /** 560 * Returns the first asset tag in the ordered set where groupId = ? and name LIKE ?. 561 * 562 * @param groupId the group ID 563 * @param name the name 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found 566 */ 567 public static AssetTag fetchByG_LikeN_First(long groupId, 568 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) { 569 return getPersistence() 570 .fetchByG_LikeN_First(groupId, name, orderByComparator); 571 } 572 573 /** 574 * Returns the last asset tag in the ordered set where groupId = ? and name LIKE ?. 575 * 576 * @param groupId the group ID 577 * @param name the name 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the last matching asset tag 580 * @throws NoSuchTagException if a matching asset tag could not be found 581 */ 582 public static AssetTag findByG_LikeN_Last(long groupId, 583 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) 584 throws com.liferay.portlet.asset.NoSuchTagException { 585 return getPersistence() 586 .findByG_LikeN_Last(groupId, name, orderByComparator); 587 } 588 589 /** 590 * Returns the last asset tag in the ordered set where groupId = ? and name LIKE ?. 591 * 592 * @param groupId the group ID 593 * @param name the name 594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 595 * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found 596 */ 597 public static AssetTag fetchByG_LikeN_Last(long groupId, 598 java.lang.String name, OrderByComparator<AssetTag> orderByComparator) { 599 return getPersistence() 600 .fetchByG_LikeN_Last(groupId, name, orderByComparator); 601 } 602 603 /** 604 * Returns the asset tags before and after the current asset tag in the ordered set where groupId = ? and name LIKE ?. 605 * 606 * @param tagId the primary key of the current asset tag 607 * @param groupId the group ID 608 * @param name the name 609 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 610 * @return the previous, current, and next asset tag 611 * @throws NoSuchTagException if a asset tag with the primary key could not be found 612 */ 613 public static AssetTag[] findByG_LikeN_PrevAndNext(long tagId, 614 long groupId, java.lang.String name, 615 OrderByComparator<AssetTag> orderByComparator) 616 throws com.liferay.portlet.asset.NoSuchTagException { 617 return getPersistence() 618 .findByG_LikeN_PrevAndNext(tagId, groupId, name, 619 orderByComparator); 620 } 621 622 /** 623 * Returns all the asset tags that the user has permission to view where groupId = ? and name LIKE ?. 624 * 625 * @param groupId the group ID 626 * @param name the name 627 * @return the matching asset tags that the user has permission to view 628 */ 629 public static List<AssetTag> filterFindByG_LikeN(long groupId, 630 java.lang.String name) { 631 return getPersistence().filterFindByG_LikeN(groupId, name); 632 } 633 634 /** 635 * Returns a range of all the asset tags that the user has permission to view where groupId = ? and name LIKE ?. 636 * 637 * <p> 638 * 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. 639 * </p> 640 * 641 * @param groupId the group ID 642 * @param name the name 643 * @param start the lower bound of the range of asset tags 644 * @param end the upper bound of the range of asset tags (not inclusive) 645 * @return the range of matching asset tags that the user has permission to view 646 */ 647 public static List<AssetTag> filterFindByG_LikeN(long groupId, 648 java.lang.String name, int start, int end) { 649 return getPersistence().filterFindByG_LikeN(groupId, name, start, end); 650 } 651 652 /** 653 * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = ? and name LIKE ?. 654 * 655 * <p> 656 * 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. 657 * </p> 658 * 659 * @param groupId the group ID 660 * @param name the name 661 * @param start the lower bound of the range of asset tags 662 * @param end the upper bound of the range of asset tags (not inclusive) 663 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 664 * @return the ordered range of matching asset tags that the user has permission to view 665 */ 666 public static List<AssetTag> filterFindByG_LikeN(long groupId, 667 java.lang.String name, int start, int end, 668 OrderByComparator<AssetTag> orderByComparator) { 669 return getPersistence() 670 .filterFindByG_LikeN(groupId, name, start, end, 671 orderByComparator); 672 } 673 674 /** 675 * 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 ?. 676 * 677 * @param tagId the primary key of the current asset tag 678 * @param groupId the group ID 679 * @param name the name 680 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 681 * @return the previous, current, and next asset tag 682 * @throws NoSuchTagException if a asset tag with the primary key could not be found 683 */ 684 public static AssetTag[] filterFindByG_LikeN_PrevAndNext(long tagId, 685 long groupId, java.lang.String name, 686 OrderByComparator<AssetTag> orderByComparator) 687 throws com.liferay.portlet.asset.NoSuchTagException { 688 return getPersistence() 689 .filterFindByG_LikeN_PrevAndNext(tagId, groupId, name, 690 orderByComparator); 691 } 692 693 /** 694 * Returns all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 695 * 696 * @param groupIds the group IDs 697 * @param name the name 698 * @return the matching asset tags that the user has permission to view 699 */ 700 public static List<AssetTag> filterFindByG_LikeN(long[] groupIds, 701 java.lang.String name) { 702 return getPersistence().filterFindByG_LikeN(groupIds, name); 703 } 704 705 /** 706 * Returns a range of all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 707 * 708 * <p> 709 * 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. 710 * </p> 711 * 712 * @param groupIds the group IDs 713 * @param name the name 714 * @param start the lower bound of the range of asset tags 715 * @param end the upper bound of the range of asset tags (not inclusive) 716 * @return the range of matching asset tags that the user has permission to view 717 */ 718 public static List<AssetTag> filterFindByG_LikeN(long[] groupIds, 719 java.lang.String name, int start, int end) { 720 return getPersistence().filterFindByG_LikeN(groupIds, name, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 725 * 726 * <p> 727 * 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. 728 * </p> 729 * 730 * @param groupIds the group IDs 731 * @param name the name 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> filterFindByG_LikeN(long[] groupIds, 738 java.lang.String name, int start, int end, 739 OrderByComparator<AssetTag> orderByComparator) { 740 return getPersistence() 741 .filterFindByG_LikeN(groupIds, name, start, end, 742 orderByComparator); 743 } 744 745 /** 746 * Returns all the asset tags where groupId = any ? and name LIKE ?. 747 * 748 * <p> 749 * 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. 750 * </p> 751 * 752 * @param groupIds the group IDs 753 * @param name the name 754 * @return the matching asset tags 755 */ 756 public static List<AssetTag> findByG_LikeN(long[] groupIds, 757 java.lang.String name) { 758 return getPersistence().findByG_LikeN(groupIds, name); 759 } 760 761 /** 762 * Returns a range of all the asset tags where groupId = any ? and name LIKE ?. 763 * 764 * <p> 765 * 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. 766 * </p> 767 * 768 * @param groupIds the group IDs 769 * @param name the name 770 * @param start the lower bound of the range of asset tags 771 * @param end the upper bound of the range of asset tags (not inclusive) 772 * @return the range of matching asset tags 773 */ 774 public static List<AssetTag> findByG_LikeN(long[] groupIds, 775 java.lang.String name, int start, int end) { 776 return getPersistence().findByG_LikeN(groupIds, name, start, end); 777 } 778 779 /** 780 * Returns an ordered range of all the asset tags where groupId = any ? and name LIKE ?. 781 * 782 * <p> 783 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 784 * </p> 785 * 786 * @param groupIds the group IDs 787 * @param name the name 788 * @param start the lower bound of the range of asset tags 789 * @param end the upper bound of the range of asset tags (not inclusive) 790 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 791 * @return the ordered range of matching asset tags 792 */ 793 public static List<AssetTag> findByG_LikeN(long[] groupIds, 794 java.lang.String name, int start, int end, 795 OrderByComparator<AssetTag> orderByComparator) { 796 return getPersistence() 797 .findByG_LikeN(groupIds, name, start, end, orderByComparator); 798 } 799 800 /** 801 * Removes all the asset tags where groupId = ? and name LIKE ? from the database. 802 * 803 * @param groupId the group ID 804 * @param name the name 805 */ 806 public static void removeByG_LikeN(long groupId, java.lang.String name) { 807 getPersistence().removeByG_LikeN(groupId, name); 808 } 809 810 /** 811 * Returns the number of asset tags where groupId = ? and name LIKE ?. 812 * 813 * @param groupId the group ID 814 * @param name the name 815 * @return the number of matching asset tags 816 */ 817 public static int countByG_LikeN(long groupId, java.lang.String name) { 818 return getPersistence().countByG_LikeN(groupId, name); 819 } 820 821 /** 822 * Returns the number of asset tags where groupId = any ? and name LIKE ?. 823 * 824 * @param groupIds the group IDs 825 * @param name the name 826 * @return the number of matching asset tags 827 */ 828 public static int countByG_LikeN(long[] groupIds, java.lang.String name) { 829 return getPersistence().countByG_LikeN(groupIds, name); 830 } 831 832 /** 833 * Returns the number of asset tags that the user has permission to view where groupId = ? and name LIKE ?. 834 * 835 * @param groupId the group ID 836 * @param name the name 837 * @return the number of matching asset tags that the user has permission to view 838 */ 839 public static int filterCountByG_LikeN(long groupId, java.lang.String name) { 840 return getPersistence().filterCountByG_LikeN(groupId, name); 841 } 842 843 /** 844 * Returns the number of asset tags that the user has permission to view where groupId = any ? and name LIKE ?. 845 * 846 * @param groupIds the group IDs 847 * @param name the name 848 * @return the number of matching asset tags that the user has permission to view 849 */ 850 public static int filterCountByG_LikeN(long[] groupIds, 851 java.lang.String name) { 852 return getPersistence().filterCountByG_LikeN(groupIds, name); 853 } 854 855 /** 856 * Caches the asset tag in the entity cache if it is enabled. 857 * 858 * @param assetTag the asset tag 859 */ 860 public static void cacheResult(AssetTag assetTag) { 861 getPersistence().cacheResult(assetTag); 862 } 863 864 /** 865 * Caches the asset tags in the entity cache if it is enabled. 866 * 867 * @param assetTags the asset tags 868 */ 869 public static void cacheResult(List<AssetTag> assetTags) { 870 getPersistence().cacheResult(assetTags); 871 } 872 873 /** 874 * Creates a new asset tag with the primary key. Does not add the asset tag to the database. 875 * 876 * @param tagId the primary key for the new asset tag 877 * @return the new asset tag 878 */ 879 public static AssetTag create(long tagId) { 880 return getPersistence().create(tagId); 881 } 882 883 /** 884 * Removes the asset tag with the primary key from the database. Also notifies the appropriate model listeners. 885 * 886 * @param tagId the primary key of the asset tag 887 * @return the asset tag that was removed 888 * @throws NoSuchTagException if a asset tag with the primary key could not be found 889 */ 890 public static AssetTag remove(long tagId) 891 throws com.liferay.portlet.asset.NoSuchTagException { 892 return getPersistence().remove(tagId); 893 } 894 895 public static AssetTag updateImpl(AssetTag assetTag) { 896 return getPersistence().updateImpl(assetTag); 897 } 898 899 /** 900 * Returns the asset tag with the primary key or throws a {@link NoSuchTagException} if it could not be found. 901 * 902 * @param tagId the primary key of the asset tag 903 * @return the asset tag 904 * @throws NoSuchTagException if a asset tag with the primary key could not be found 905 */ 906 public static AssetTag findByPrimaryKey(long tagId) 907 throws com.liferay.portlet.asset.NoSuchTagException { 908 return getPersistence().findByPrimaryKey(tagId); 909 } 910 911 /** 912 * Returns the asset tag with the primary key or returns <code>null</code> if it could not be found. 913 * 914 * @param tagId the primary key of the asset tag 915 * @return the asset tag, or <code>null</code> if a asset tag with the primary key could not be found 916 */ 917 public static AssetTag fetchByPrimaryKey(long tagId) { 918 return getPersistence().fetchByPrimaryKey(tagId); 919 } 920 921 public static java.util.Map<java.io.Serializable, AssetTag> fetchByPrimaryKeys( 922 java.util.Set<java.io.Serializable> primaryKeys) { 923 return getPersistence().fetchByPrimaryKeys(primaryKeys); 924 } 925 926 /** 927 * Returns all the asset tags. 928 * 929 * @return the asset tags 930 */ 931 public static List<AssetTag> findAll() { 932 return getPersistence().findAll(); 933 } 934 935 /** 936 * Returns a range of all the asset tags. 937 * 938 * <p> 939 * 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. 940 * </p> 941 * 942 * @param start the lower bound of the range of asset tags 943 * @param end the upper bound of the range of asset tags (not inclusive) 944 * @return the range of asset tags 945 */ 946 public static List<AssetTag> findAll(int start, int end) { 947 return getPersistence().findAll(start, end); 948 } 949 950 /** 951 * Returns an ordered range of all the asset tags. 952 * 953 * <p> 954 * 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. 955 * </p> 956 * 957 * @param start the lower bound of the range of asset tags 958 * @param end the upper bound of the range of asset tags (not inclusive) 959 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 960 * @return the ordered range of asset tags 961 */ 962 public static List<AssetTag> findAll(int start, int end, 963 OrderByComparator<AssetTag> orderByComparator) { 964 return getPersistence().findAll(start, end, orderByComparator); 965 } 966 967 /** 968 * Removes all the asset tags from the database. 969 */ 970 public static void removeAll() { 971 getPersistence().removeAll(); 972 } 973 974 /** 975 * Returns the number of asset tags. 976 * 977 * @return the number of asset tags 978 */ 979 public static int countAll() { 980 return getPersistence().countAll(); 981 } 982 983 /** 984 * Returns the primaryKeys of asset entries associated with the asset tag. 985 * 986 * @param pk the primary key of the asset tag 987 * @return long[] of the primaryKeys of asset entries associated with the asset tag 988 */ 989 public static long[] getAssetEntryPrimaryKeys(long pk) { 990 return getPersistence().getAssetEntryPrimaryKeys(pk); 991 } 992 993 /** 994 * Returns all the asset entries associated with the asset tag. 995 * 996 * @param pk the primary key of the asset tag 997 * @return the asset entries associated with the asset tag 998 */ 999 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1000 long pk) { 1001 return getPersistence().getAssetEntries(pk); 1002 } 1003 1004 /** 1005 * Returns a range of all the asset entries associated with the asset tag. 1006 * 1007 * <p> 1008 * 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. 1009 * </p> 1010 * 1011 * @param pk the primary key of the asset tag 1012 * @param start the lower bound of the range of asset tags 1013 * @param end the upper bound of the range of asset tags (not inclusive) 1014 * @return the range of asset entries associated with the asset tag 1015 */ 1016 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1017 long pk, int start, int end) { 1018 return getPersistence().getAssetEntries(pk, start, end); 1019 } 1020 1021 /** 1022 * Returns an ordered range of all the asset entries associated with the asset tag. 1023 * 1024 * <p> 1025 * 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. 1026 * </p> 1027 * 1028 * @param pk the primary key of the asset tag 1029 * @param start the lower bound of the range of asset tags 1030 * @param end the upper bound of the range of asset tags (not inclusive) 1031 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1032 * @return the ordered range of asset entries associated with the asset tag 1033 */ 1034 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 1035 long pk, int start, int end, 1036 OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator) { 1037 return getPersistence() 1038 .getAssetEntries(pk, start, end, orderByComparator); 1039 } 1040 1041 /** 1042 * Returns the number of asset entries associated with the asset tag. 1043 * 1044 * @param pk the primary key of the asset tag 1045 * @return the number of asset entries associated with the asset tag 1046 */ 1047 public static int getAssetEntriesSize(long pk) { 1048 return getPersistence().getAssetEntriesSize(pk); 1049 } 1050 1051 /** 1052 * Returns <code>true</code> if the asset entry is associated with the asset tag. 1053 * 1054 * @param pk the primary key of the asset tag 1055 * @param assetEntryPK the primary key of the asset entry 1056 * @return <code>true</code> if the asset entry is associated with the asset tag; <code>false</code> otherwise 1057 */ 1058 public static boolean containsAssetEntry(long pk, long assetEntryPK) { 1059 return getPersistence().containsAssetEntry(pk, assetEntryPK); 1060 } 1061 1062 /** 1063 * Returns <code>true</code> if the asset tag has any asset entries associated with it. 1064 * 1065 * @param pk the primary key of the asset tag to check for associations with asset entries 1066 * @return <code>true</code> if the asset tag has any asset entries associated with it; <code>false</code> otherwise 1067 */ 1068 public static boolean containsAssetEntries(long pk) { 1069 return getPersistence().containsAssetEntries(pk); 1070 } 1071 1072 /** 1073 * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1074 * 1075 * @param pk the primary key of the asset tag 1076 * @param assetEntryPK the primary key of the asset entry 1077 */ 1078 public static void addAssetEntry(long pk, long assetEntryPK) { 1079 getPersistence().addAssetEntry(pk, assetEntryPK); 1080 } 1081 1082 /** 1083 * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1084 * 1085 * @param pk the primary key of the asset tag 1086 * @param assetEntry the asset entry 1087 */ 1088 public static void addAssetEntry(long pk, 1089 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 1090 getPersistence().addAssetEntry(pk, assetEntry); 1091 } 1092 1093 /** 1094 * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1095 * 1096 * @param pk the primary key of the asset tag 1097 * @param assetEntryPKs the primary keys of the asset entries 1098 */ 1099 public static void addAssetEntries(long pk, long[] assetEntryPKs) { 1100 getPersistence().addAssetEntries(pk, assetEntryPKs); 1101 } 1102 1103 /** 1104 * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1105 * 1106 * @param pk the primary key of the asset tag 1107 * @param assetEntries the asset entries 1108 */ 1109 public static void addAssetEntries(long pk, 1110 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1111 getPersistence().addAssetEntries(pk, assetEntries); 1112 } 1113 1114 /** 1115 * Clears all associations between the asset tag and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1116 * 1117 * @param pk the primary key of the asset tag to clear the associated asset entries from 1118 */ 1119 public static void clearAssetEntries(long pk) { 1120 getPersistence().clearAssetEntries(pk); 1121 } 1122 1123 /** 1124 * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1125 * 1126 * @param pk the primary key of the asset tag 1127 * @param assetEntryPK the primary key of the asset entry 1128 */ 1129 public static void removeAssetEntry(long pk, long assetEntryPK) { 1130 getPersistence().removeAssetEntry(pk, assetEntryPK); 1131 } 1132 1133 /** 1134 * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1135 * 1136 * @param pk the primary key of the asset tag 1137 * @param assetEntry the asset entry 1138 */ 1139 public static void removeAssetEntry(long pk, 1140 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 1141 getPersistence().removeAssetEntry(pk, assetEntry); 1142 } 1143 1144 /** 1145 * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1146 * 1147 * @param pk the primary key of the asset tag 1148 * @param assetEntryPKs the primary keys of the asset entries 1149 */ 1150 public static void removeAssetEntries(long pk, long[] assetEntryPKs) { 1151 getPersistence().removeAssetEntries(pk, assetEntryPKs); 1152 } 1153 1154 /** 1155 * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1156 * 1157 * @param pk the primary key of the asset tag 1158 * @param assetEntries the asset entries 1159 */ 1160 public static void removeAssetEntries(long pk, 1161 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1162 getPersistence().removeAssetEntries(pk, assetEntries); 1163 } 1164 1165 /** 1166 * 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. 1167 * 1168 * @param pk the primary key of the asset tag 1169 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset tag 1170 */ 1171 public static void setAssetEntries(long pk, long[] assetEntryPKs) { 1172 getPersistence().setAssetEntries(pk, assetEntryPKs); 1173 } 1174 1175 /** 1176 * 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. 1177 * 1178 * @param pk the primary key of the asset tag 1179 * @param assetEntries the asset entries to be associated with the asset tag 1180 */ 1181 public static void setAssetEntries(long pk, 1182 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 1183 getPersistence().setAssetEntries(pk, assetEntries); 1184 } 1185 1186 public static AssetTagPersistence getPersistence() { 1187 if (_persistence == null) { 1188 _persistence = (AssetTagPersistence)PortalBeanLocatorUtil.locate(AssetTagPersistence.class.getName()); 1189 1190 ReferenceRegistry.registerReference(AssetTagUtil.class, 1191 "_persistence"); 1192 } 1193 1194 return _persistence; 1195 } 1196 1197 /** 1198 * @deprecated As of 6.2.0 1199 */ 1200 @Deprecated 1201 public void setPersistence(AssetTagPersistence persistence) { 1202 } 1203 1204 private static AssetTagPersistence _persistence; 1205 }