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.blogs.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.blogs.model.BlogsStatsUser; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the blogs stats user service. This utility wraps {@link com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl} 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 BlogsStatsUserPersistence 038 * @see com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class BlogsStatsUserUtil { 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(BlogsStatsUser blogsStatsUser) { 060 getPersistence().clearCache(blogsStatsUser); 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<BlogsStatsUser> 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<BlogsStatsUser> 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<BlogsStatsUser> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<BlogsStatsUser> 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 BlogsStatsUser update(BlogsStatsUser blogsStatsUser) { 101 return getPersistence().update(blogsStatsUser); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser, 108 ServiceContext serviceContext) { 109 return getPersistence().update(blogsStatsUser, serviceContext); 110 } 111 112 /** 113 * Returns all the blogs stats users where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching blogs stats users 117 */ 118 public static List<BlogsStatsUser> findByGroupId(long groupId) { 119 return getPersistence().findByGroupId(groupId); 120 } 121 122 /** 123 * Returns a range of all the blogs stats users where groupId = ?. 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 BlogsStatsUserModelImpl}. 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 groupId the group ID 130 * @param start the lower bound of the range of blogs stats users 131 * @param end the upper bound of the range of blogs stats users (not inclusive) 132 * @return the range of matching blogs stats users 133 */ 134 public static List<BlogsStatsUser> findByGroupId(long groupId, int start, 135 int end) { 136 return getPersistence().findByGroupId(groupId, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the blogs stats users where groupId = ?. 141 * 142 * <p> 143 * 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 BlogsStatsUserModelImpl}. 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. 144 * </p> 145 * 146 * @param groupId the group ID 147 * @param start the lower bound of the range of blogs stats users 148 * @param end the upper bound of the range of blogs stats users (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching blogs stats users 151 */ 152 public static List<BlogsStatsUser> findByGroupId(long groupId, int start, 153 int end, OrderByComparator<BlogsStatsUser> orderByComparator) { 154 return getPersistence() 155 .findByGroupId(groupId, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns the first blogs stats user in the ordered set where groupId = ?. 160 * 161 * @param groupId the group ID 162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 163 * @return the first matching blogs stats user 164 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 165 */ 166 public static BlogsStatsUser findByGroupId_First(long groupId, 167 OrderByComparator<BlogsStatsUser> orderByComparator) 168 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 169 return getPersistence().findByGroupId_First(groupId, orderByComparator); 170 } 171 172 /** 173 * Returns the first blogs stats user in the ordered set where groupId = ?. 174 * 175 * @param groupId the group ID 176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 177 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 178 */ 179 public static BlogsStatsUser fetchByGroupId_First(long groupId, 180 OrderByComparator<BlogsStatsUser> orderByComparator) { 181 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 182 } 183 184 /** 185 * Returns the last blogs stats user in the ordered set where groupId = ?. 186 * 187 * @param groupId the group ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the last matching blogs stats user 190 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 191 */ 192 public static BlogsStatsUser findByGroupId_Last(long groupId, 193 OrderByComparator<BlogsStatsUser> orderByComparator) 194 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 195 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 196 } 197 198 /** 199 * Returns the last blogs stats user in the ordered set where groupId = ?. 200 * 201 * @param groupId the group ID 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 204 */ 205 public static BlogsStatsUser fetchByGroupId_Last(long groupId, 206 OrderByComparator<BlogsStatsUser> orderByComparator) { 207 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 208 } 209 210 /** 211 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ?. 212 * 213 * @param statsUserId the primary key of the current blogs stats user 214 * @param groupId the group ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the previous, current, and next blogs stats user 217 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 218 */ 219 public static BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId, 220 long groupId, OrderByComparator<BlogsStatsUser> orderByComparator) 221 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 222 return getPersistence() 223 .findByGroupId_PrevAndNext(statsUserId, groupId, 224 orderByComparator); 225 } 226 227 /** 228 * Removes all the blogs stats users where groupId = ? from the database. 229 * 230 * @param groupId the group ID 231 */ 232 public static void removeByGroupId(long groupId) { 233 getPersistence().removeByGroupId(groupId); 234 } 235 236 /** 237 * Returns the number of blogs stats users where groupId = ?. 238 * 239 * @param groupId the group ID 240 * @return the number of matching blogs stats users 241 */ 242 public static int countByGroupId(long groupId) { 243 return getPersistence().countByGroupId(groupId); 244 } 245 246 /** 247 * Returns all the blogs stats users where userId = ?. 248 * 249 * @param userId the user ID 250 * @return the matching blogs stats users 251 */ 252 public static List<BlogsStatsUser> findByUserId(long userId) { 253 return getPersistence().findByUserId(userId); 254 } 255 256 /** 257 * Returns a range of all the blogs stats users where userId = ?. 258 * 259 * <p> 260 * 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 BlogsStatsUserModelImpl}. 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. 261 * </p> 262 * 263 * @param userId the user ID 264 * @param start the lower bound of the range of blogs stats users 265 * @param end the upper bound of the range of blogs stats users (not inclusive) 266 * @return the range of matching blogs stats users 267 */ 268 public static List<BlogsStatsUser> findByUserId(long userId, int start, 269 int end) { 270 return getPersistence().findByUserId(userId, start, end); 271 } 272 273 /** 274 * Returns an ordered range of all the blogs stats users where userId = ?. 275 * 276 * <p> 277 * 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 BlogsStatsUserModelImpl}. 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. 278 * </p> 279 * 280 * @param userId the user ID 281 * @param start the lower bound of the range of blogs stats users 282 * @param end the upper bound of the range of blogs stats users (not inclusive) 283 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 284 * @return the ordered range of matching blogs stats users 285 */ 286 public static List<BlogsStatsUser> findByUserId(long userId, int start, 287 int end, OrderByComparator<BlogsStatsUser> orderByComparator) { 288 return getPersistence() 289 .findByUserId(userId, start, end, orderByComparator); 290 } 291 292 /** 293 * Returns the first blogs stats user in the ordered set where userId = ?. 294 * 295 * @param userId the user ID 296 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 297 * @return the first matching blogs stats user 298 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 299 */ 300 public static BlogsStatsUser findByUserId_First(long userId, 301 OrderByComparator<BlogsStatsUser> orderByComparator) 302 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 303 return getPersistence().findByUserId_First(userId, orderByComparator); 304 } 305 306 /** 307 * Returns the first blogs stats user in the ordered set where userId = ?. 308 * 309 * @param userId the user ID 310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 311 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 312 */ 313 public static BlogsStatsUser fetchByUserId_First(long userId, 314 OrderByComparator<BlogsStatsUser> orderByComparator) { 315 return getPersistence().fetchByUserId_First(userId, orderByComparator); 316 } 317 318 /** 319 * Returns the last blogs stats user in the ordered set where userId = ?. 320 * 321 * @param userId the user ID 322 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 323 * @return the last matching blogs stats user 324 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 325 */ 326 public static BlogsStatsUser findByUserId_Last(long userId, 327 OrderByComparator<BlogsStatsUser> orderByComparator) 328 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 329 return getPersistence().findByUserId_Last(userId, orderByComparator); 330 } 331 332 /** 333 * Returns the last blogs stats user in the ordered set where userId = ?. 334 * 335 * @param userId the user ID 336 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 337 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 338 */ 339 public static BlogsStatsUser fetchByUserId_Last(long userId, 340 OrderByComparator<BlogsStatsUser> orderByComparator) { 341 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 342 } 343 344 /** 345 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = ?. 346 * 347 * @param statsUserId the primary key of the current blogs stats user 348 * @param userId the user ID 349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 350 * @return the previous, current, and next blogs stats user 351 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 352 */ 353 public static BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId, 354 long userId, OrderByComparator<BlogsStatsUser> orderByComparator) 355 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 356 return getPersistence() 357 .findByUserId_PrevAndNext(statsUserId, userId, 358 orderByComparator); 359 } 360 361 /** 362 * Removes all the blogs stats users where userId = ? from the database. 363 * 364 * @param userId the user ID 365 */ 366 public static void removeByUserId(long userId) { 367 getPersistence().removeByUserId(userId); 368 } 369 370 /** 371 * Returns the number of blogs stats users where userId = ?. 372 * 373 * @param userId the user ID 374 * @return the number of matching blogs stats users 375 */ 376 public static int countByUserId(long userId) { 377 return getPersistence().countByUserId(userId); 378 } 379 380 /** 381 * Returns the blogs stats user where groupId = ? and userId = ? or throws a {@link NoSuchStatsUserException} if it could not be found. 382 * 383 * @param groupId the group ID 384 * @param userId the user ID 385 * @return the matching blogs stats user 386 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 387 */ 388 public static BlogsStatsUser findByG_U(long groupId, long userId) 389 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 390 return getPersistence().findByG_U(groupId, userId); 391 } 392 393 /** 394 * Returns the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 395 * 396 * @param groupId the group ID 397 * @param userId the user ID 398 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 399 */ 400 public static BlogsStatsUser fetchByG_U(long groupId, long userId) { 401 return getPersistence().fetchByG_U(groupId, userId); 402 } 403 404 /** 405 * Returns the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 406 * 407 * @param groupId the group ID 408 * @param userId the user ID 409 * @param retrieveFromCache whether to use the finder cache 410 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 411 */ 412 public static BlogsStatsUser fetchByG_U(long groupId, long userId, 413 boolean retrieveFromCache) { 414 return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache); 415 } 416 417 /** 418 * Removes the blogs stats user where groupId = ? and userId = ? from the database. 419 * 420 * @param groupId the group ID 421 * @param userId the user ID 422 * @return the blogs stats user that was removed 423 */ 424 public static BlogsStatsUser removeByG_U(long groupId, long userId) 425 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 426 return getPersistence().removeByG_U(groupId, userId); 427 } 428 429 /** 430 * Returns the number of blogs stats users where groupId = ? and userId = ?. 431 * 432 * @param groupId the group ID 433 * @param userId the user ID 434 * @return the number of matching blogs stats users 435 */ 436 public static int countByG_U(long groupId, long userId) { 437 return getPersistence().countByG_U(groupId, userId); 438 } 439 440 /** 441 * Returns all the blogs stats users where groupId = ? and entryCount ≠ ?. 442 * 443 * @param groupId the group ID 444 * @param entryCount the entry count 445 * @return the matching blogs stats users 446 */ 447 public static List<BlogsStatsUser> findByG_NotE(long groupId, int entryCount) { 448 return getPersistence().findByG_NotE(groupId, entryCount); 449 } 450 451 /** 452 * Returns a range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 453 * 454 * <p> 455 * 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 BlogsStatsUserModelImpl}. 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. 456 * </p> 457 * 458 * @param groupId the group ID 459 * @param entryCount the entry count 460 * @param start the lower bound of the range of blogs stats users 461 * @param end the upper bound of the range of blogs stats users (not inclusive) 462 * @return the range of matching blogs stats users 463 */ 464 public static List<BlogsStatsUser> findByG_NotE(long groupId, 465 int entryCount, int start, int end) { 466 return getPersistence().findByG_NotE(groupId, entryCount, start, end); 467 } 468 469 /** 470 * Returns an ordered range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 471 * 472 * <p> 473 * 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 BlogsStatsUserModelImpl}. 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. 474 * </p> 475 * 476 * @param groupId the group ID 477 * @param entryCount the entry count 478 * @param start the lower bound of the range of blogs stats users 479 * @param end the upper bound of the range of blogs stats users (not inclusive) 480 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 481 * @return the ordered range of matching blogs stats users 482 */ 483 public static List<BlogsStatsUser> findByG_NotE(long groupId, 484 int entryCount, int start, int end, 485 OrderByComparator<BlogsStatsUser> orderByComparator) { 486 return getPersistence() 487 .findByG_NotE(groupId, entryCount, start, end, 488 orderByComparator); 489 } 490 491 /** 492 * Returns the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 493 * 494 * @param groupId the group ID 495 * @param entryCount the entry count 496 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 497 * @return the first matching blogs stats user 498 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 499 */ 500 public static BlogsStatsUser findByG_NotE_First(long groupId, 501 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) 502 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 503 return getPersistence() 504 .findByG_NotE_First(groupId, entryCount, orderByComparator); 505 } 506 507 /** 508 * Returns the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 509 * 510 * @param groupId the group ID 511 * @param entryCount the entry count 512 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 513 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 514 */ 515 public static BlogsStatsUser fetchByG_NotE_First(long groupId, 516 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) { 517 return getPersistence() 518 .fetchByG_NotE_First(groupId, entryCount, orderByComparator); 519 } 520 521 /** 522 * Returns the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 523 * 524 * @param groupId the group ID 525 * @param entryCount the entry count 526 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 527 * @return the last matching blogs stats user 528 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 529 */ 530 public static BlogsStatsUser findByG_NotE_Last(long groupId, 531 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) 532 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 533 return getPersistence() 534 .findByG_NotE_Last(groupId, entryCount, orderByComparator); 535 } 536 537 /** 538 * Returns the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 539 * 540 * @param groupId the group ID 541 * @param entryCount the entry count 542 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 543 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 544 */ 545 public static BlogsStatsUser fetchByG_NotE_Last(long groupId, 546 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) { 547 return getPersistence() 548 .fetchByG_NotE_Last(groupId, entryCount, orderByComparator); 549 } 550 551 /** 552 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 553 * 554 * @param statsUserId the primary key of the current blogs stats user 555 * @param groupId the group ID 556 * @param entryCount the entry count 557 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 558 * @return the previous, current, and next blogs stats user 559 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 560 */ 561 public static BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId, 562 long groupId, int entryCount, 563 OrderByComparator<BlogsStatsUser> orderByComparator) 564 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 565 return getPersistence() 566 .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount, 567 orderByComparator); 568 } 569 570 /** 571 * Removes all the blogs stats users where groupId = ? and entryCount ≠ ? from the database. 572 * 573 * @param groupId the group ID 574 * @param entryCount the entry count 575 */ 576 public static void removeByG_NotE(long groupId, int entryCount) { 577 getPersistence().removeByG_NotE(groupId, entryCount); 578 } 579 580 /** 581 * Returns the number of blogs stats users where groupId = ? and entryCount ≠ ?. 582 * 583 * @param groupId the group ID 584 * @param entryCount the entry count 585 * @return the number of matching blogs stats users 586 */ 587 public static int countByG_NotE(long groupId, int entryCount) { 588 return getPersistence().countByG_NotE(groupId, entryCount); 589 } 590 591 /** 592 * Returns all the blogs stats users where companyId = ? and entryCount ≠ ?. 593 * 594 * @param companyId the company ID 595 * @param entryCount the entry count 596 * @return the matching blogs stats users 597 */ 598 public static List<BlogsStatsUser> findByC_NotE(long companyId, 599 int entryCount) { 600 return getPersistence().findByC_NotE(companyId, entryCount); 601 } 602 603 /** 604 * Returns a range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 605 * 606 * <p> 607 * 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 BlogsStatsUserModelImpl}. 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. 608 * </p> 609 * 610 * @param companyId the company ID 611 * @param entryCount the entry count 612 * @param start the lower bound of the range of blogs stats users 613 * @param end the upper bound of the range of blogs stats users (not inclusive) 614 * @return the range of matching blogs stats users 615 */ 616 public static List<BlogsStatsUser> findByC_NotE(long companyId, 617 int entryCount, int start, int end) { 618 return getPersistence().findByC_NotE(companyId, entryCount, start, end); 619 } 620 621 /** 622 * Returns an ordered range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 623 * 624 * <p> 625 * 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 BlogsStatsUserModelImpl}. 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. 626 * </p> 627 * 628 * @param companyId the company ID 629 * @param entryCount the entry count 630 * @param start the lower bound of the range of blogs stats users 631 * @param end the upper bound of the range of blogs stats users (not inclusive) 632 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 633 * @return the ordered range of matching blogs stats users 634 */ 635 public static List<BlogsStatsUser> findByC_NotE(long companyId, 636 int entryCount, int start, int end, 637 OrderByComparator<BlogsStatsUser> orderByComparator) { 638 return getPersistence() 639 .findByC_NotE(companyId, entryCount, start, end, 640 orderByComparator); 641 } 642 643 /** 644 * Returns the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 645 * 646 * @param companyId the company ID 647 * @param entryCount the entry count 648 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 649 * @return the first matching blogs stats user 650 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 651 */ 652 public static BlogsStatsUser findByC_NotE_First(long companyId, 653 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) 654 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 655 return getPersistence() 656 .findByC_NotE_First(companyId, entryCount, orderByComparator); 657 } 658 659 /** 660 * Returns the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 661 * 662 * @param companyId the company ID 663 * @param entryCount the entry count 664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 665 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 666 */ 667 public static BlogsStatsUser fetchByC_NotE_First(long companyId, 668 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) { 669 return getPersistence() 670 .fetchByC_NotE_First(companyId, entryCount, orderByComparator); 671 } 672 673 /** 674 * Returns the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 675 * 676 * @param companyId the company ID 677 * @param entryCount the entry count 678 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 679 * @return the last matching blogs stats user 680 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 681 */ 682 public static BlogsStatsUser findByC_NotE_Last(long companyId, 683 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) 684 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 685 return getPersistence() 686 .findByC_NotE_Last(companyId, entryCount, orderByComparator); 687 } 688 689 /** 690 * Returns the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 691 * 692 * @param companyId the company ID 693 * @param entryCount the entry count 694 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 695 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 696 */ 697 public static BlogsStatsUser fetchByC_NotE_Last(long companyId, 698 int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) { 699 return getPersistence() 700 .fetchByC_NotE_Last(companyId, entryCount, orderByComparator); 701 } 702 703 /** 704 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 705 * 706 * @param statsUserId the primary key of the current blogs stats user 707 * @param companyId the company ID 708 * @param entryCount the entry count 709 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 710 * @return the previous, current, and next blogs stats user 711 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 712 */ 713 public static BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId, 714 long companyId, int entryCount, 715 OrderByComparator<BlogsStatsUser> orderByComparator) 716 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 717 return getPersistence() 718 .findByC_NotE_PrevAndNext(statsUserId, companyId, 719 entryCount, orderByComparator); 720 } 721 722 /** 723 * Removes all the blogs stats users where companyId = ? and entryCount ≠ ? from the database. 724 * 725 * @param companyId the company ID 726 * @param entryCount the entry count 727 */ 728 public static void removeByC_NotE(long companyId, int entryCount) { 729 getPersistence().removeByC_NotE(companyId, entryCount); 730 } 731 732 /** 733 * Returns the number of blogs stats users where companyId = ? and entryCount ≠ ?. 734 * 735 * @param companyId the company ID 736 * @param entryCount the entry count 737 * @return the number of matching blogs stats users 738 */ 739 public static int countByC_NotE(long companyId, int entryCount) { 740 return getPersistence().countByC_NotE(companyId, entryCount); 741 } 742 743 /** 744 * Returns all the blogs stats users where userId = ? and lastPostDate = ?. 745 * 746 * @param userId the user ID 747 * @param lastPostDate the last post date 748 * @return the matching blogs stats users 749 */ 750 public static List<BlogsStatsUser> findByU_L(long userId, 751 java.util.Date lastPostDate) { 752 return getPersistence().findByU_L(userId, lastPostDate); 753 } 754 755 /** 756 * Returns a range of all the blogs stats users where userId = ? and lastPostDate = ?. 757 * 758 * <p> 759 * 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 BlogsStatsUserModelImpl}. 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. 760 * </p> 761 * 762 * @param userId the user ID 763 * @param lastPostDate the last post date 764 * @param start the lower bound of the range of blogs stats users 765 * @param end the upper bound of the range of blogs stats users (not inclusive) 766 * @return the range of matching blogs stats users 767 */ 768 public static List<BlogsStatsUser> findByU_L(long userId, 769 java.util.Date lastPostDate, int start, int end) { 770 return getPersistence().findByU_L(userId, lastPostDate, start, end); 771 } 772 773 /** 774 * Returns an ordered range of all the blogs stats users where userId = ? and lastPostDate = ?. 775 * 776 * <p> 777 * 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 BlogsStatsUserModelImpl}. 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. 778 * </p> 779 * 780 * @param userId the user ID 781 * @param lastPostDate the last post date 782 * @param start the lower bound of the range of blogs stats users 783 * @param end the upper bound of the range of blogs stats users (not inclusive) 784 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 785 * @return the ordered range of matching blogs stats users 786 */ 787 public static List<BlogsStatsUser> findByU_L(long userId, 788 java.util.Date lastPostDate, int start, int end, 789 OrderByComparator<BlogsStatsUser> orderByComparator) { 790 return getPersistence() 791 .findByU_L(userId, lastPostDate, start, end, 792 orderByComparator); 793 } 794 795 /** 796 * Returns the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 797 * 798 * @param userId the user ID 799 * @param lastPostDate the last post date 800 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 801 * @return the first matching blogs stats user 802 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 803 */ 804 public static BlogsStatsUser findByU_L_First(long userId, 805 java.util.Date lastPostDate, 806 OrderByComparator<BlogsStatsUser> orderByComparator) 807 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 808 return getPersistence() 809 .findByU_L_First(userId, lastPostDate, orderByComparator); 810 } 811 812 /** 813 * Returns the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 814 * 815 * @param userId the user ID 816 * @param lastPostDate the last post date 817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 818 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 819 */ 820 public static BlogsStatsUser fetchByU_L_First(long userId, 821 java.util.Date lastPostDate, 822 OrderByComparator<BlogsStatsUser> orderByComparator) { 823 return getPersistence() 824 .fetchByU_L_First(userId, lastPostDate, orderByComparator); 825 } 826 827 /** 828 * Returns the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 829 * 830 * @param userId the user ID 831 * @param lastPostDate the last post date 832 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 833 * @return the last matching blogs stats user 834 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 835 */ 836 public static BlogsStatsUser findByU_L_Last(long userId, 837 java.util.Date lastPostDate, 838 OrderByComparator<BlogsStatsUser> orderByComparator) 839 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 840 return getPersistence() 841 .findByU_L_Last(userId, lastPostDate, orderByComparator); 842 } 843 844 /** 845 * Returns the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 846 * 847 * @param userId the user ID 848 * @param lastPostDate the last post date 849 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 850 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 851 */ 852 public static BlogsStatsUser fetchByU_L_Last(long userId, 853 java.util.Date lastPostDate, 854 OrderByComparator<BlogsStatsUser> orderByComparator) { 855 return getPersistence() 856 .fetchByU_L_Last(userId, lastPostDate, orderByComparator); 857 } 858 859 /** 860 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 861 * 862 * @param statsUserId the primary key of the current blogs stats user 863 * @param userId the user ID 864 * @param lastPostDate the last post date 865 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 866 * @return the previous, current, and next blogs stats user 867 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 868 */ 869 public static BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId, 870 long userId, java.util.Date lastPostDate, 871 OrderByComparator<BlogsStatsUser> orderByComparator) 872 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 873 return getPersistence() 874 .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate, 875 orderByComparator); 876 } 877 878 /** 879 * Removes all the blogs stats users where userId = ? and lastPostDate = ? from the database. 880 * 881 * @param userId the user ID 882 * @param lastPostDate the last post date 883 */ 884 public static void removeByU_L(long userId, java.util.Date lastPostDate) { 885 getPersistence().removeByU_L(userId, lastPostDate); 886 } 887 888 /** 889 * Returns the number of blogs stats users where userId = ? and lastPostDate = ?. 890 * 891 * @param userId the user ID 892 * @param lastPostDate the last post date 893 * @return the number of matching blogs stats users 894 */ 895 public static int countByU_L(long userId, java.util.Date lastPostDate) { 896 return getPersistence().countByU_L(userId, lastPostDate); 897 } 898 899 /** 900 * Caches the blogs stats user in the entity cache if it is enabled. 901 * 902 * @param blogsStatsUser the blogs stats user 903 */ 904 public static void cacheResult(BlogsStatsUser blogsStatsUser) { 905 getPersistence().cacheResult(blogsStatsUser); 906 } 907 908 /** 909 * Caches the blogs stats users in the entity cache if it is enabled. 910 * 911 * @param blogsStatsUsers the blogs stats users 912 */ 913 public static void cacheResult(List<BlogsStatsUser> blogsStatsUsers) { 914 getPersistence().cacheResult(blogsStatsUsers); 915 } 916 917 /** 918 * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database. 919 * 920 * @param statsUserId the primary key for the new blogs stats user 921 * @return the new blogs stats user 922 */ 923 public static BlogsStatsUser create(long statsUserId) { 924 return getPersistence().create(statsUserId); 925 } 926 927 /** 928 * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners. 929 * 930 * @param statsUserId the primary key of the blogs stats user 931 * @return the blogs stats user that was removed 932 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 933 */ 934 public static BlogsStatsUser remove(long statsUserId) 935 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 936 return getPersistence().remove(statsUserId); 937 } 938 939 public static BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser) { 940 return getPersistence().updateImpl(blogsStatsUser); 941 } 942 943 /** 944 * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found. 945 * 946 * @param statsUserId the primary key of the blogs stats user 947 * @return the blogs stats user 948 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 949 */ 950 public static BlogsStatsUser findByPrimaryKey(long statsUserId) 951 throws com.liferay.portlet.blogs.NoSuchStatsUserException { 952 return getPersistence().findByPrimaryKey(statsUserId); 953 } 954 955 /** 956 * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found. 957 * 958 * @param statsUserId the primary key of the blogs stats user 959 * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found 960 */ 961 public static BlogsStatsUser fetchByPrimaryKey(long statsUserId) { 962 return getPersistence().fetchByPrimaryKey(statsUserId); 963 } 964 965 public static java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys( 966 java.util.Set<java.io.Serializable> primaryKeys) { 967 return getPersistence().fetchByPrimaryKeys(primaryKeys); 968 } 969 970 /** 971 * Returns all the blogs stats users. 972 * 973 * @return the blogs stats users 974 */ 975 public static List<BlogsStatsUser> findAll() { 976 return getPersistence().findAll(); 977 } 978 979 /** 980 * Returns a range of all the blogs stats users. 981 * 982 * <p> 983 * 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 BlogsStatsUserModelImpl}. 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. 984 * </p> 985 * 986 * @param start the lower bound of the range of blogs stats users 987 * @param end the upper bound of the range of blogs stats users (not inclusive) 988 * @return the range of blogs stats users 989 */ 990 public static List<BlogsStatsUser> findAll(int start, int end) { 991 return getPersistence().findAll(start, end); 992 } 993 994 /** 995 * Returns an ordered range of all the blogs stats users. 996 * 997 * <p> 998 * 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 BlogsStatsUserModelImpl}. 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. 999 * </p> 1000 * 1001 * @param start the lower bound of the range of blogs stats users 1002 * @param end the upper bound of the range of blogs stats users (not inclusive) 1003 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1004 * @return the ordered range of blogs stats users 1005 */ 1006 public static List<BlogsStatsUser> findAll(int start, int end, 1007 OrderByComparator<BlogsStatsUser> orderByComparator) { 1008 return getPersistence().findAll(start, end, orderByComparator); 1009 } 1010 1011 /** 1012 * Removes all the blogs stats users from the database. 1013 */ 1014 public static void removeAll() { 1015 getPersistence().removeAll(); 1016 } 1017 1018 /** 1019 * Returns the number of blogs stats users. 1020 * 1021 * @return the number of blogs stats users 1022 */ 1023 public static int countAll() { 1024 return getPersistence().countAll(); 1025 } 1026 1027 public static BlogsStatsUserPersistence getPersistence() { 1028 if (_persistence == null) { 1029 _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName()); 1030 1031 ReferenceRegistry.registerReference(BlogsStatsUserUtil.class, 1032 "_persistence"); 1033 } 1034 1035 return _persistence; 1036 } 1037 1038 /** 1039 * @deprecated As of 6.2.0 1040 */ 1041 @Deprecated 1042 public void setPersistence(BlogsStatsUserPersistence persistence) { 1043 } 1044 1045 private static BlogsStatsUserPersistence _persistence; 1046 }