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.portal.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.model.UserIdMapper; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user ID mapper service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserIdMapperPersistenceImpl} 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. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see UserIdMapperPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserIdMapperPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserIdMapperUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(UserIdMapper userIdMapper) { 059 getPersistence().clearCache(userIdMapper); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<UserIdMapper> findWithDynamicQuery( 073 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<UserIdMapper> 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<UserIdMapper> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserIdMapper> 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 UserIdMapper update(UserIdMapper userIdMapper) { 100 return getPersistence().update(userIdMapper); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static UserIdMapper update(UserIdMapper userIdMapper, 107 ServiceContext serviceContext) { 108 return getPersistence().update(userIdMapper, serviceContext); 109 } 110 111 /** 112 * Returns all the user ID mappers where userId = ?. 113 * 114 * @param userId the user ID 115 * @return the matching user ID mappers 116 */ 117 public static List<UserIdMapper> findByUserId(long userId) { 118 return getPersistence().findByUserId(userId); 119 } 120 121 /** 122 * Returns a range of all the user ID mappers where userId = ?. 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 UserIdMapperModelImpl}. 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 userId the user ID 129 * @param start the lower bound of the range of user ID mappers 130 * @param end the upper bound of the range of user ID mappers (not inclusive) 131 * @return the range of matching user ID mappers 132 */ 133 public static List<UserIdMapper> findByUserId(long userId, int start, 134 int end) { 135 return getPersistence().findByUserId(userId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the user ID mappers where userId = ?. 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 UserIdMapperModelImpl}. 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 userId the user ID 146 * @param start the lower bound of the range of user ID mappers 147 * @param end the upper bound of the range of user ID mappers (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching user ID mappers 150 */ 151 public static List<UserIdMapper> findByUserId(long userId, int start, 152 int end, OrderByComparator<UserIdMapper> orderByComparator) { 153 return getPersistence() 154 .findByUserId(userId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the user ID mappers where userId = ?. 159 * 160 * <p> 161 * 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 UserIdMapperModelImpl}. 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. 162 * </p> 163 * 164 * @param userId the user ID 165 * @param start the lower bound of the range of user ID mappers 166 * @param end the upper bound of the range of user ID mappers (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching user ID mappers 170 */ 171 public static List<UserIdMapper> findByUserId(long userId, int start, 172 int end, OrderByComparator<UserIdMapper> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUserId(userId, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first user ID mapper in the ordered set where userId = ?. 181 * 182 * @param userId the user ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching user ID mapper 185 * @throws NoSuchUserIdMapperException if a matching user ID mapper could not be found 186 */ 187 public static UserIdMapper findByUserId_First(long userId, 188 OrderByComparator<UserIdMapper> orderByComparator) 189 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 190 return getPersistence().findByUserId_First(userId, orderByComparator); 191 } 192 193 /** 194 * Returns the first user ID mapper in the ordered set where userId = ?. 195 * 196 * @param userId the user ID 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 199 */ 200 public static UserIdMapper fetchByUserId_First(long userId, 201 OrderByComparator<UserIdMapper> orderByComparator) { 202 return getPersistence().fetchByUserId_First(userId, orderByComparator); 203 } 204 205 /** 206 * Returns the last user ID mapper in the ordered set where userId = ?. 207 * 208 * @param userId the user ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching user ID mapper 211 * @throws NoSuchUserIdMapperException if a matching user ID mapper could not be found 212 */ 213 public static UserIdMapper findByUserId_Last(long userId, 214 OrderByComparator<UserIdMapper> orderByComparator) 215 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 216 return getPersistence().findByUserId_Last(userId, orderByComparator); 217 } 218 219 /** 220 * Returns the last user ID mapper in the ordered set where userId = ?. 221 * 222 * @param userId the user ID 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 225 */ 226 public static UserIdMapper fetchByUserId_Last(long userId, 227 OrderByComparator<UserIdMapper> orderByComparator) { 228 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 229 } 230 231 /** 232 * Returns the user ID mappers before and after the current user ID mapper in the ordered set where userId = ?. 233 * 234 * @param userIdMapperId the primary key of the current user ID mapper 235 * @param userId the user ID 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next user ID mapper 238 * @throws NoSuchUserIdMapperException if a user ID mapper with the primary key could not be found 239 */ 240 public static UserIdMapper[] findByUserId_PrevAndNext(long userIdMapperId, 241 long userId, OrderByComparator<UserIdMapper> orderByComparator) 242 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 243 return getPersistence() 244 .findByUserId_PrevAndNext(userIdMapperId, userId, 245 orderByComparator); 246 } 247 248 /** 249 * Removes all the user ID mappers where userId = ? from the database. 250 * 251 * @param userId the user ID 252 */ 253 public static void removeByUserId(long userId) { 254 getPersistence().removeByUserId(userId); 255 } 256 257 /** 258 * Returns the number of user ID mappers where userId = ?. 259 * 260 * @param userId the user ID 261 * @return the number of matching user ID mappers 262 */ 263 public static int countByUserId(long userId) { 264 return getPersistence().countByUserId(userId); 265 } 266 267 /** 268 * Returns the user ID mapper where userId = ? and type = ? or throws a {@link NoSuchUserIdMapperException} if it could not be found. 269 * 270 * @param userId the user ID 271 * @param type the type 272 * @return the matching user ID mapper 273 * @throws NoSuchUserIdMapperException if a matching user ID mapper could not be found 274 */ 275 public static UserIdMapper findByU_T(long userId, java.lang.String type) 276 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 277 return getPersistence().findByU_T(userId, type); 278 } 279 280 /** 281 * Returns the user ID mapper where userId = ? and type = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 282 * 283 * @param userId the user ID 284 * @param type the type 285 * @return the matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 286 */ 287 public static UserIdMapper fetchByU_T(long userId, java.lang.String type) { 288 return getPersistence().fetchByU_T(userId, type); 289 } 290 291 /** 292 * Returns the user ID mapper where userId = ? and type = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 293 * 294 * @param userId the user ID 295 * @param type the type 296 * @param retrieveFromCache whether to retrieve from the finder cache 297 * @return the matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 298 */ 299 public static UserIdMapper fetchByU_T(long userId, java.lang.String type, 300 boolean retrieveFromCache) { 301 return getPersistence().fetchByU_T(userId, type, retrieveFromCache); 302 } 303 304 /** 305 * Removes the user ID mapper where userId = ? and type = ? from the database. 306 * 307 * @param userId the user ID 308 * @param type the type 309 * @return the user ID mapper that was removed 310 */ 311 public static UserIdMapper removeByU_T(long userId, java.lang.String type) 312 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 313 return getPersistence().removeByU_T(userId, type); 314 } 315 316 /** 317 * Returns the number of user ID mappers where userId = ? and type = ?. 318 * 319 * @param userId the user ID 320 * @param type the type 321 * @return the number of matching user ID mappers 322 */ 323 public static int countByU_T(long userId, java.lang.String type) { 324 return getPersistence().countByU_T(userId, type); 325 } 326 327 /** 328 * Returns the user ID mapper where type = ? and externalUserId = ? or throws a {@link NoSuchUserIdMapperException} if it could not be found. 329 * 330 * @param type the type 331 * @param externalUserId the external user ID 332 * @return the matching user ID mapper 333 * @throws NoSuchUserIdMapperException if a matching user ID mapper could not be found 334 */ 335 public static UserIdMapper findByT_E(java.lang.String type, 336 java.lang.String externalUserId) 337 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 338 return getPersistence().findByT_E(type, externalUserId); 339 } 340 341 /** 342 * Returns the user ID mapper where type = ? and externalUserId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 343 * 344 * @param type the type 345 * @param externalUserId the external user ID 346 * @return the matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 347 */ 348 public static UserIdMapper fetchByT_E(java.lang.String type, 349 java.lang.String externalUserId) { 350 return getPersistence().fetchByT_E(type, externalUserId); 351 } 352 353 /** 354 * Returns the user ID mapper where type = ? and externalUserId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 355 * 356 * @param type the type 357 * @param externalUserId the external user ID 358 * @param retrieveFromCache whether to retrieve from the finder cache 359 * @return the matching user ID mapper, or <code>null</code> if a matching user ID mapper could not be found 360 */ 361 public static UserIdMapper fetchByT_E(java.lang.String type, 362 java.lang.String externalUserId, boolean retrieveFromCache) { 363 return getPersistence() 364 .fetchByT_E(type, externalUserId, retrieveFromCache); 365 } 366 367 /** 368 * Removes the user ID mapper where type = ? and externalUserId = ? from the database. 369 * 370 * @param type the type 371 * @param externalUserId the external user ID 372 * @return the user ID mapper that was removed 373 */ 374 public static UserIdMapper removeByT_E(java.lang.String type, 375 java.lang.String externalUserId) 376 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 377 return getPersistence().removeByT_E(type, externalUserId); 378 } 379 380 /** 381 * Returns the number of user ID mappers where type = ? and externalUserId = ?. 382 * 383 * @param type the type 384 * @param externalUserId the external user ID 385 * @return the number of matching user ID mappers 386 */ 387 public static int countByT_E(java.lang.String type, 388 java.lang.String externalUserId) { 389 return getPersistence().countByT_E(type, externalUserId); 390 } 391 392 /** 393 * Caches the user ID mapper in the entity cache if it is enabled. 394 * 395 * @param userIdMapper the user ID mapper 396 */ 397 public static void cacheResult(UserIdMapper userIdMapper) { 398 getPersistence().cacheResult(userIdMapper); 399 } 400 401 /** 402 * Caches the user ID mappers in the entity cache if it is enabled. 403 * 404 * @param userIdMappers the user ID mappers 405 */ 406 public static void cacheResult(List<UserIdMapper> userIdMappers) { 407 getPersistence().cacheResult(userIdMappers); 408 } 409 410 /** 411 * Creates a new user ID mapper with the primary key. Does not add the user ID mapper to the database. 412 * 413 * @param userIdMapperId the primary key for the new user ID mapper 414 * @return the new user ID mapper 415 */ 416 public static UserIdMapper create(long userIdMapperId) { 417 return getPersistence().create(userIdMapperId); 418 } 419 420 /** 421 * Removes the user ID mapper with the primary key from the database. Also notifies the appropriate model listeners. 422 * 423 * @param userIdMapperId the primary key of the user ID mapper 424 * @return the user ID mapper that was removed 425 * @throws NoSuchUserIdMapperException if a user ID mapper with the primary key could not be found 426 */ 427 public static UserIdMapper remove(long userIdMapperId) 428 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 429 return getPersistence().remove(userIdMapperId); 430 } 431 432 public static UserIdMapper updateImpl(UserIdMapper userIdMapper) { 433 return getPersistence().updateImpl(userIdMapper); 434 } 435 436 /** 437 * Returns the user ID mapper with the primary key or throws a {@link NoSuchUserIdMapperException} if it could not be found. 438 * 439 * @param userIdMapperId the primary key of the user ID mapper 440 * @return the user ID mapper 441 * @throws NoSuchUserIdMapperException if a user ID mapper with the primary key could not be found 442 */ 443 public static UserIdMapper findByPrimaryKey(long userIdMapperId) 444 throws com.liferay.portal.exception.NoSuchUserIdMapperException { 445 return getPersistence().findByPrimaryKey(userIdMapperId); 446 } 447 448 /** 449 * Returns the user ID mapper with the primary key or returns <code>null</code> if it could not be found. 450 * 451 * @param userIdMapperId the primary key of the user ID mapper 452 * @return the user ID mapper, or <code>null</code> if a user ID mapper with the primary key could not be found 453 */ 454 public static UserIdMapper fetchByPrimaryKey(long userIdMapperId) { 455 return getPersistence().fetchByPrimaryKey(userIdMapperId); 456 } 457 458 public static java.util.Map<java.io.Serializable, UserIdMapper> fetchByPrimaryKeys( 459 java.util.Set<java.io.Serializable> primaryKeys) { 460 return getPersistence().fetchByPrimaryKeys(primaryKeys); 461 } 462 463 /** 464 * Returns all the user ID mappers. 465 * 466 * @return the user ID mappers 467 */ 468 public static List<UserIdMapper> findAll() { 469 return getPersistence().findAll(); 470 } 471 472 /** 473 * Returns a range of all the user ID mappers. 474 * 475 * <p> 476 * 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 UserIdMapperModelImpl}. 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. 477 * </p> 478 * 479 * @param start the lower bound of the range of user ID mappers 480 * @param end the upper bound of the range of user ID mappers (not inclusive) 481 * @return the range of user ID mappers 482 */ 483 public static List<UserIdMapper> findAll(int start, int end) { 484 return getPersistence().findAll(start, end); 485 } 486 487 /** 488 * Returns an ordered range of all the user ID mappers. 489 * 490 * <p> 491 * 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 UserIdMapperModelImpl}. 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. 492 * </p> 493 * 494 * @param start the lower bound of the range of user ID mappers 495 * @param end the upper bound of the range of user ID mappers (not inclusive) 496 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 497 * @return the ordered range of user ID mappers 498 */ 499 public static List<UserIdMapper> findAll(int start, int end, 500 OrderByComparator<UserIdMapper> orderByComparator) { 501 return getPersistence().findAll(start, end, orderByComparator); 502 } 503 504 /** 505 * Returns an ordered range of all the user ID mappers. 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 UserIdMapperModelImpl}. 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 start the lower bound of the range of user ID mappers 512 * @param end the upper bound of the range of user ID mappers (not inclusive) 513 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 514 * @param retrieveFromCache whether to retrieve from the finder cache 515 * @return the ordered range of user ID mappers 516 */ 517 public static List<UserIdMapper> findAll(int start, int end, 518 OrderByComparator<UserIdMapper> orderByComparator, 519 boolean retrieveFromCache) { 520 return getPersistence() 521 .findAll(start, end, orderByComparator, retrieveFromCache); 522 } 523 524 /** 525 * Removes all the user ID mappers from the database. 526 */ 527 public static void removeAll() { 528 getPersistence().removeAll(); 529 } 530 531 /** 532 * Returns the number of user ID mappers. 533 * 534 * @return the number of user ID mappers 535 */ 536 public static int countAll() { 537 return getPersistence().countAll(); 538 } 539 540 public static java.util.Set<java.lang.String> getBadColumnNames() { 541 return getPersistence().getBadColumnNames(); 542 } 543 544 public static UserIdMapperPersistence getPersistence() { 545 if (_persistence == null) { 546 _persistence = (UserIdMapperPersistence)PortalBeanLocatorUtil.locate(UserIdMapperPersistence.class.getName()); 547 548 ReferenceRegistry.registerReference(UserIdMapperUtil.class, 549 "_persistence"); 550 } 551 552 return _persistence; 553 } 554 555 private static UserIdMapperPersistence _persistence; 556 }