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.AssetTagStats; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset tag stats service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetTagStatsPersistenceImpl} 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 AssetTagStatsPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetTagStatsPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetTagStatsUtil { 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(AssetTagStats assetTagStats) { 060 getPersistence().clearCache(assetTagStats); 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<AssetTagStats> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<AssetTagStats> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AssetTagStats> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetTagStats> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AssetTagStats update(AssetTagStats assetTagStats) { 101 return getPersistence().update(assetTagStats); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static AssetTagStats update(AssetTagStats assetTagStats, 108 ServiceContext serviceContext) { 109 return getPersistence().update(assetTagStats, serviceContext); 110 } 111 112 /** 113 * Returns all the asset tag statses where tagId = ?. 114 * 115 * @param tagId the tag ID 116 * @return the matching asset tag statses 117 */ 118 public static List<AssetTagStats> findByTagId(long tagId) { 119 return getPersistence().findByTagId(tagId); 120 } 121 122 /** 123 * Returns a range of all the asset tag statses where tagId = ?. 124 * 125 * <p> 126 * 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 AssetTagStatsModelImpl}. 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. 127 * </p> 128 * 129 * @param tagId the tag ID 130 * @param start the lower bound of the range of asset tag statses 131 * @param end the upper bound of the range of asset tag statses (not inclusive) 132 * @return the range of matching asset tag statses 133 */ 134 public static List<AssetTagStats> findByTagId(long tagId, int start, int end) { 135 return getPersistence().findByTagId(tagId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the asset tag statses where tagId = ?. 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 AssetTagStatsModelImpl}. 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 tagId the tag ID 146 * @param start the lower bound of the range of asset tag statses 147 * @param end the upper bound of the range of asset tag statses (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching asset tag statses 150 */ 151 public static List<AssetTagStats> findByTagId(long tagId, int start, 152 int end, OrderByComparator<AssetTagStats> orderByComparator) { 153 return getPersistence().findByTagId(tagId, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns the first asset tag stats in the ordered set where tagId = ?. 158 * 159 * @param tagId the tag ID 160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 161 * @return the first matching asset tag stats 162 * @throws NoSuchTagStatsException if a matching asset tag stats could not be found 163 */ 164 public static AssetTagStats findByTagId_First(long tagId, 165 OrderByComparator<AssetTagStats> orderByComparator) 166 throws com.liferay.portlet.asset.NoSuchTagStatsException { 167 return getPersistence().findByTagId_First(tagId, orderByComparator); 168 } 169 170 /** 171 * Returns the first asset tag stats in the ordered set where tagId = ?. 172 * 173 * @param tagId the tag ID 174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 175 * @return the first matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 176 */ 177 public static AssetTagStats fetchByTagId_First(long tagId, 178 OrderByComparator<AssetTagStats> orderByComparator) { 179 return getPersistence().fetchByTagId_First(tagId, orderByComparator); 180 } 181 182 /** 183 * Returns the last asset tag stats in the ordered set where tagId = ?. 184 * 185 * @param tagId the tag ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the last matching asset tag stats 188 * @throws NoSuchTagStatsException if a matching asset tag stats could not be found 189 */ 190 public static AssetTagStats findByTagId_Last(long tagId, 191 OrderByComparator<AssetTagStats> orderByComparator) 192 throws com.liferay.portlet.asset.NoSuchTagStatsException { 193 return getPersistence().findByTagId_Last(tagId, orderByComparator); 194 } 195 196 /** 197 * Returns the last asset tag stats in the ordered set where tagId = ?. 198 * 199 * @param tagId the tag ID 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the last matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 202 */ 203 public static AssetTagStats fetchByTagId_Last(long tagId, 204 OrderByComparator<AssetTagStats> orderByComparator) { 205 return getPersistence().fetchByTagId_Last(tagId, orderByComparator); 206 } 207 208 /** 209 * Returns the asset tag statses before and after the current asset tag stats in the ordered set where tagId = ?. 210 * 211 * @param tagStatsId the primary key of the current asset tag stats 212 * @param tagId the tag ID 213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 214 * @return the previous, current, and next asset tag stats 215 * @throws NoSuchTagStatsException if a asset tag stats with the primary key could not be found 216 */ 217 public static AssetTagStats[] findByTagId_PrevAndNext(long tagStatsId, 218 long tagId, OrderByComparator<AssetTagStats> orderByComparator) 219 throws com.liferay.portlet.asset.NoSuchTagStatsException { 220 return getPersistence() 221 .findByTagId_PrevAndNext(tagStatsId, tagId, orderByComparator); 222 } 223 224 /** 225 * Removes all the asset tag statses where tagId = ? from the database. 226 * 227 * @param tagId the tag ID 228 */ 229 public static void removeByTagId(long tagId) { 230 getPersistence().removeByTagId(tagId); 231 } 232 233 /** 234 * Returns the number of asset tag statses where tagId = ?. 235 * 236 * @param tagId the tag ID 237 * @return the number of matching asset tag statses 238 */ 239 public static int countByTagId(long tagId) { 240 return getPersistence().countByTagId(tagId); 241 } 242 243 /** 244 * Returns all the asset tag statses where classNameId = ?. 245 * 246 * @param classNameId the class name ID 247 * @return the matching asset tag statses 248 */ 249 public static List<AssetTagStats> findByClassNameId(long classNameId) { 250 return getPersistence().findByClassNameId(classNameId); 251 } 252 253 /** 254 * Returns a range of all the asset tag statses where classNameId = ?. 255 * 256 * <p> 257 * 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 AssetTagStatsModelImpl}. 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. 258 * </p> 259 * 260 * @param classNameId the class name ID 261 * @param start the lower bound of the range of asset tag statses 262 * @param end the upper bound of the range of asset tag statses (not inclusive) 263 * @return the range of matching asset tag statses 264 */ 265 public static List<AssetTagStats> findByClassNameId(long classNameId, 266 int start, int end) { 267 return getPersistence().findByClassNameId(classNameId, start, end); 268 } 269 270 /** 271 * Returns an ordered range of all the asset tag statses where classNameId = ?. 272 * 273 * <p> 274 * 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 AssetTagStatsModelImpl}. 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. 275 * </p> 276 * 277 * @param classNameId the class name ID 278 * @param start the lower bound of the range of asset tag statses 279 * @param end the upper bound of the range of asset tag statses (not inclusive) 280 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 281 * @return the ordered range of matching asset tag statses 282 */ 283 public static List<AssetTagStats> findByClassNameId(long classNameId, 284 int start, int end, OrderByComparator<AssetTagStats> orderByComparator) { 285 return getPersistence() 286 .findByClassNameId(classNameId, start, end, orderByComparator); 287 } 288 289 /** 290 * Returns the first asset tag stats in the ordered set where classNameId = ?. 291 * 292 * @param classNameId the class name ID 293 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 294 * @return the first matching asset tag stats 295 * @throws NoSuchTagStatsException if a matching asset tag stats could not be found 296 */ 297 public static AssetTagStats findByClassNameId_First(long classNameId, 298 OrderByComparator<AssetTagStats> orderByComparator) 299 throws com.liferay.portlet.asset.NoSuchTagStatsException { 300 return getPersistence() 301 .findByClassNameId_First(classNameId, orderByComparator); 302 } 303 304 /** 305 * Returns the first asset tag stats in the ordered set where classNameId = ?. 306 * 307 * @param classNameId the class name ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the first matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 310 */ 311 public static AssetTagStats fetchByClassNameId_First(long classNameId, 312 OrderByComparator<AssetTagStats> orderByComparator) { 313 return getPersistence() 314 .fetchByClassNameId_First(classNameId, orderByComparator); 315 } 316 317 /** 318 * Returns the last asset tag stats in the ordered set where classNameId = ?. 319 * 320 * @param classNameId the class name ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the last matching asset tag stats 323 * @throws NoSuchTagStatsException if a matching asset tag stats could not be found 324 */ 325 public static AssetTagStats findByClassNameId_Last(long classNameId, 326 OrderByComparator<AssetTagStats> orderByComparator) 327 throws com.liferay.portlet.asset.NoSuchTagStatsException { 328 return getPersistence() 329 .findByClassNameId_Last(classNameId, orderByComparator); 330 } 331 332 /** 333 * Returns the last asset tag stats in the ordered set where classNameId = ?. 334 * 335 * @param classNameId the class name ID 336 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 337 * @return the last matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 338 */ 339 public static AssetTagStats fetchByClassNameId_Last(long classNameId, 340 OrderByComparator<AssetTagStats> orderByComparator) { 341 return getPersistence() 342 .fetchByClassNameId_Last(classNameId, orderByComparator); 343 } 344 345 /** 346 * Returns the asset tag statses before and after the current asset tag stats in the ordered set where classNameId = ?. 347 * 348 * @param tagStatsId the primary key of the current asset tag stats 349 * @param classNameId the class name ID 350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 351 * @return the previous, current, and next asset tag stats 352 * @throws NoSuchTagStatsException if a asset tag stats with the primary key could not be found 353 */ 354 public static AssetTagStats[] findByClassNameId_PrevAndNext( 355 long tagStatsId, long classNameId, 356 OrderByComparator<AssetTagStats> orderByComparator) 357 throws com.liferay.portlet.asset.NoSuchTagStatsException { 358 return getPersistence() 359 .findByClassNameId_PrevAndNext(tagStatsId, classNameId, 360 orderByComparator); 361 } 362 363 /** 364 * Removes all the asset tag statses where classNameId = ? from the database. 365 * 366 * @param classNameId the class name ID 367 */ 368 public static void removeByClassNameId(long classNameId) { 369 getPersistence().removeByClassNameId(classNameId); 370 } 371 372 /** 373 * Returns the number of asset tag statses where classNameId = ?. 374 * 375 * @param classNameId the class name ID 376 * @return the number of matching asset tag statses 377 */ 378 public static int countByClassNameId(long classNameId) { 379 return getPersistence().countByClassNameId(classNameId); 380 } 381 382 /** 383 * Returns the asset tag stats where tagId = ? and classNameId = ? or throws a {@link NoSuchTagStatsException} if it could not be found. 384 * 385 * @param tagId the tag ID 386 * @param classNameId the class name ID 387 * @return the matching asset tag stats 388 * @throws NoSuchTagStatsException if a matching asset tag stats could not be found 389 */ 390 public static AssetTagStats findByT_C(long tagId, long classNameId) 391 throws com.liferay.portlet.asset.NoSuchTagStatsException { 392 return getPersistence().findByT_C(tagId, classNameId); 393 } 394 395 /** 396 * Returns the asset tag stats where tagId = ? and classNameId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 397 * 398 * @param tagId the tag ID 399 * @param classNameId the class name ID 400 * @return the matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 401 */ 402 public static AssetTagStats fetchByT_C(long tagId, long classNameId) { 403 return getPersistence().fetchByT_C(tagId, classNameId); 404 } 405 406 /** 407 * Returns the asset tag stats where tagId = ? and classNameId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 408 * 409 * @param tagId the tag ID 410 * @param classNameId the class name ID 411 * @param retrieveFromCache whether to use the finder cache 412 * @return the matching asset tag stats, or <code>null</code> if a matching asset tag stats could not be found 413 */ 414 public static AssetTagStats fetchByT_C(long tagId, long classNameId, 415 boolean retrieveFromCache) { 416 return getPersistence().fetchByT_C(tagId, classNameId, retrieveFromCache); 417 } 418 419 /** 420 * Removes the asset tag stats where tagId = ? and classNameId = ? from the database. 421 * 422 * @param tagId the tag ID 423 * @param classNameId the class name ID 424 * @return the asset tag stats that was removed 425 */ 426 public static AssetTagStats removeByT_C(long tagId, long classNameId) 427 throws com.liferay.portlet.asset.NoSuchTagStatsException { 428 return getPersistence().removeByT_C(tagId, classNameId); 429 } 430 431 /** 432 * Returns the number of asset tag statses where tagId = ? and classNameId = ?. 433 * 434 * @param tagId the tag ID 435 * @param classNameId the class name ID 436 * @return the number of matching asset tag statses 437 */ 438 public static int countByT_C(long tagId, long classNameId) { 439 return getPersistence().countByT_C(tagId, classNameId); 440 } 441 442 /** 443 * Caches the asset tag stats in the entity cache if it is enabled. 444 * 445 * @param assetTagStats the asset tag stats 446 */ 447 public static void cacheResult(AssetTagStats assetTagStats) { 448 getPersistence().cacheResult(assetTagStats); 449 } 450 451 /** 452 * Caches the asset tag statses in the entity cache if it is enabled. 453 * 454 * @param assetTagStatses the asset tag statses 455 */ 456 public static void cacheResult(List<AssetTagStats> assetTagStatses) { 457 getPersistence().cacheResult(assetTagStatses); 458 } 459 460 /** 461 * Creates a new asset tag stats with the primary key. Does not add the asset tag stats to the database. 462 * 463 * @param tagStatsId the primary key for the new asset tag stats 464 * @return the new asset tag stats 465 */ 466 public static AssetTagStats create(long tagStatsId) { 467 return getPersistence().create(tagStatsId); 468 } 469 470 /** 471 * Removes the asset tag stats with the primary key from the database. Also notifies the appropriate model listeners. 472 * 473 * @param tagStatsId the primary key of the asset tag stats 474 * @return the asset tag stats that was removed 475 * @throws NoSuchTagStatsException if a asset tag stats with the primary key could not be found 476 */ 477 public static AssetTagStats remove(long tagStatsId) 478 throws com.liferay.portlet.asset.NoSuchTagStatsException { 479 return getPersistence().remove(tagStatsId); 480 } 481 482 public static AssetTagStats updateImpl(AssetTagStats assetTagStats) { 483 return getPersistence().updateImpl(assetTagStats); 484 } 485 486 /** 487 * Returns the asset tag stats with the primary key or throws a {@link NoSuchTagStatsException} if it could not be found. 488 * 489 * @param tagStatsId the primary key of the asset tag stats 490 * @return the asset tag stats 491 * @throws NoSuchTagStatsException if a asset tag stats with the primary key could not be found 492 */ 493 public static AssetTagStats findByPrimaryKey(long tagStatsId) 494 throws com.liferay.portlet.asset.NoSuchTagStatsException { 495 return getPersistence().findByPrimaryKey(tagStatsId); 496 } 497 498 /** 499 * Returns the asset tag stats with the primary key or returns <code>null</code> if it could not be found. 500 * 501 * @param tagStatsId the primary key of the asset tag stats 502 * @return the asset tag stats, or <code>null</code> if a asset tag stats with the primary key could not be found 503 */ 504 public static AssetTagStats fetchByPrimaryKey(long tagStatsId) { 505 return getPersistence().fetchByPrimaryKey(tagStatsId); 506 } 507 508 public static java.util.Map<java.io.Serializable, AssetTagStats> fetchByPrimaryKeys( 509 java.util.Set<java.io.Serializable> primaryKeys) { 510 return getPersistence().fetchByPrimaryKeys(primaryKeys); 511 } 512 513 /** 514 * Returns all the asset tag statses. 515 * 516 * @return the asset tag statses 517 */ 518 public static List<AssetTagStats> findAll() { 519 return getPersistence().findAll(); 520 } 521 522 /** 523 * Returns a range of all the asset tag statses. 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 AssetTagStatsModelImpl}. 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 start the lower bound of the range of asset tag statses 530 * @param end the upper bound of the range of asset tag statses (not inclusive) 531 * @return the range of asset tag statses 532 */ 533 public static List<AssetTagStats> findAll(int start, int end) { 534 return getPersistence().findAll(start, end); 535 } 536 537 /** 538 * Returns an ordered range of all the asset tag statses. 539 * 540 * <p> 541 * 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 AssetTagStatsModelImpl}. 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. 542 * </p> 543 * 544 * @param start the lower bound of the range of asset tag statses 545 * @param end the upper bound of the range of asset tag statses (not inclusive) 546 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 547 * @return the ordered range of asset tag statses 548 */ 549 public static List<AssetTagStats> findAll(int start, int end, 550 OrderByComparator<AssetTagStats> orderByComparator) { 551 return getPersistence().findAll(start, end, orderByComparator); 552 } 553 554 /** 555 * Removes all the asset tag statses from the database. 556 */ 557 public static void removeAll() { 558 getPersistence().removeAll(); 559 } 560 561 /** 562 * Returns the number of asset tag statses. 563 * 564 * @return the number of asset tag statses 565 */ 566 public static int countAll() { 567 return getPersistence().countAll(); 568 } 569 570 public static AssetTagStatsPersistence getPersistence() { 571 if (_persistence == null) { 572 _persistence = (AssetTagStatsPersistence)PortalBeanLocatorUtil.locate(AssetTagStatsPersistence.class.getName()); 573 574 ReferenceRegistry.registerReference(AssetTagStatsUtil.class, 575 "_persistence"); 576 } 577 578 return _persistence; 579 } 580 581 /** 582 * @deprecated As of 6.2.0 583 */ 584 @Deprecated 585 public void setPersistence(AssetTagStatsPersistence persistence) { 586 } 587 588 private static AssetTagStatsPersistence _persistence; 589 }