001 /** 002 * Copyright (c) 2000-2013 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.exception.SystemException; 022 import com.liferay.portal.kernel.util.OrderByComparator; 023 import com.liferay.portal.kernel.util.ReferenceRegistry; 024 import com.liferay.portal.model.UserTrackerPath; 025 import com.liferay.portal.service.ServiceContext; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the user tracker path service. This utility wraps {@link UserTrackerPathPersistenceImpl} 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 UserTrackerPathPersistence 038 * @see UserTrackerPathPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class UserTrackerPathUtil { 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(UserTrackerPath userTrackerPath) { 060 getPersistence().clearCache(userTrackerPath); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 067 throws SystemException { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<UserTrackerPath> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<UserTrackerPath> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) 084 throws SystemException { 085 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 086 } 087 088 /** 089 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 090 */ 091 public static List<UserTrackerPath> findWithDynamicQuery( 092 DynamicQuery dynamicQuery, int start, int end, 093 OrderByComparator orderByComparator) throws SystemException { 094 return getPersistence() 095 .findWithDynamicQuery(dynamicQuery, start, end, 096 orderByComparator); 097 } 098 099 /** 100 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 101 */ 102 public static UserTrackerPath update(UserTrackerPath userTrackerPath) 103 throws SystemException { 104 return getPersistence().update(userTrackerPath); 105 } 106 107 /** 108 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 109 */ 110 public static UserTrackerPath update(UserTrackerPath userTrackerPath, 111 ServiceContext serviceContext) throws SystemException { 112 return getPersistence().update(userTrackerPath, serviceContext); 113 } 114 115 /** 116 * Returns all the user tracker paths where userTrackerId = ?. 117 * 118 * @param userTrackerId the user tracker ID 119 * @return the matching user tracker paths 120 * @throws SystemException if a system exception occurred 121 */ 122 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findByUserTrackerId( 123 long userTrackerId) 124 throws com.liferay.portal.kernel.exception.SystemException { 125 return getPersistence().findByUserTrackerId(userTrackerId); 126 } 127 128 /** 129 * Returns a range of all the user tracker paths where userTrackerId = ?. 130 * 131 * <p> 132 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserTrackerPathModelImpl}. 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. 133 * </p> 134 * 135 * @param userTrackerId the user tracker ID 136 * @param start the lower bound of the range of user tracker paths 137 * @param end the upper bound of the range of user tracker paths (not inclusive) 138 * @return the range of matching user tracker paths 139 * @throws SystemException if a system exception occurred 140 */ 141 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findByUserTrackerId( 142 long userTrackerId, int start, int end) 143 throws com.liferay.portal.kernel.exception.SystemException { 144 return getPersistence().findByUserTrackerId(userTrackerId, start, end); 145 } 146 147 /** 148 * Returns an ordered range of all the user tracker paths where userTrackerId = ?. 149 * 150 * <p> 151 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserTrackerPathModelImpl}. 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. 152 * </p> 153 * 154 * @param userTrackerId the user tracker ID 155 * @param start the lower bound of the range of user tracker paths 156 * @param end the upper bound of the range of user tracker paths (not inclusive) 157 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 158 * @return the ordered range of matching user tracker paths 159 * @throws SystemException if a system exception occurred 160 */ 161 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findByUserTrackerId( 162 long userTrackerId, int start, int end, 163 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 164 throws com.liferay.portal.kernel.exception.SystemException { 165 return getPersistence() 166 .findByUserTrackerId(userTrackerId, start, end, 167 orderByComparator); 168 } 169 170 /** 171 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 172 * 173 * @param userTrackerId the user tracker ID 174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 175 * @return the first matching user tracker path 176 * @throws com.liferay.portal.NoSuchUserTrackerPathException if a matching user tracker path could not be found 177 * @throws SystemException if a system exception occurred 178 */ 179 public static com.liferay.portal.model.UserTrackerPath findByUserTrackerId_First( 180 long userTrackerId, 181 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 182 throws com.liferay.portal.NoSuchUserTrackerPathException, 183 com.liferay.portal.kernel.exception.SystemException { 184 return getPersistence() 185 .findByUserTrackerId_First(userTrackerId, orderByComparator); 186 } 187 188 /** 189 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 190 * 191 * @param userTrackerId the user tracker ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the first matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portal.model.UserTrackerPath fetchByUserTrackerId_First( 197 long userTrackerId, 198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence() 201 .fetchByUserTrackerId_First(userTrackerId, orderByComparator); 202 } 203 204 /** 205 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 206 * 207 * @param userTrackerId the user tracker ID 208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 209 * @return the last matching user tracker path 210 * @throws com.liferay.portal.NoSuchUserTrackerPathException if a matching user tracker path could not be found 211 * @throws SystemException if a system exception occurred 212 */ 213 public static com.liferay.portal.model.UserTrackerPath findByUserTrackerId_Last( 214 long userTrackerId, 215 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 216 throws com.liferay.portal.NoSuchUserTrackerPathException, 217 com.liferay.portal.kernel.exception.SystemException { 218 return getPersistence() 219 .findByUserTrackerId_Last(userTrackerId, orderByComparator); 220 } 221 222 /** 223 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 224 * 225 * @param userTrackerId the user tracker ID 226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 227 * @return the last matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 228 * @throws SystemException if a system exception occurred 229 */ 230 public static com.liferay.portal.model.UserTrackerPath fetchByUserTrackerId_Last( 231 long userTrackerId, 232 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 233 throws com.liferay.portal.kernel.exception.SystemException { 234 return getPersistence() 235 .fetchByUserTrackerId_Last(userTrackerId, orderByComparator); 236 } 237 238 /** 239 * Returns the user tracker paths before and after the current user tracker path in the ordered set where userTrackerId = ?. 240 * 241 * @param userTrackerPathId the primary key of the current user tracker path 242 * @param userTrackerId the user tracker ID 243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 244 * @return the previous, current, and next user tracker path 245 * @throws com.liferay.portal.NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 246 * @throws SystemException if a system exception occurred 247 */ 248 public static com.liferay.portal.model.UserTrackerPath[] findByUserTrackerId_PrevAndNext( 249 long userTrackerPathId, long userTrackerId, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.NoSuchUserTrackerPathException, 252 com.liferay.portal.kernel.exception.SystemException { 253 return getPersistence() 254 .findByUserTrackerId_PrevAndNext(userTrackerPathId, 255 userTrackerId, orderByComparator); 256 } 257 258 /** 259 * Removes all the user tracker paths where userTrackerId = ? from the database. 260 * 261 * @param userTrackerId the user tracker ID 262 * @throws SystemException if a system exception occurred 263 */ 264 public static void removeByUserTrackerId(long userTrackerId) 265 throws com.liferay.portal.kernel.exception.SystemException { 266 getPersistence().removeByUserTrackerId(userTrackerId); 267 } 268 269 /** 270 * Returns the number of user tracker paths where userTrackerId = ?. 271 * 272 * @param userTrackerId the user tracker ID 273 * @return the number of matching user tracker paths 274 * @throws SystemException if a system exception occurred 275 */ 276 public static int countByUserTrackerId(long userTrackerId) 277 throws com.liferay.portal.kernel.exception.SystemException { 278 return getPersistence().countByUserTrackerId(userTrackerId); 279 } 280 281 /** 282 * Caches the user tracker path in the entity cache if it is enabled. 283 * 284 * @param userTrackerPath the user tracker path 285 */ 286 public static void cacheResult( 287 com.liferay.portal.model.UserTrackerPath userTrackerPath) { 288 getPersistence().cacheResult(userTrackerPath); 289 } 290 291 /** 292 * Caches the user tracker paths in the entity cache if it is enabled. 293 * 294 * @param userTrackerPaths the user tracker paths 295 */ 296 public static void cacheResult( 297 java.util.List<com.liferay.portal.model.UserTrackerPath> userTrackerPaths) { 298 getPersistence().cacheResult(userTrackerPaths); 299 } 300 301 /** 302 * Creates a new user tracker path with the primary key. Does not add the user tracker path to the database. 303 * 304 * @param userTrackerPathId the primary key for the new user tracker path 305 * @return the new user tracker path 306 */ 307 public static com.liferay.portal.model.UserTrackerPath create( 308 long userTrackerPathId) { 309 return getPersistence().create(userTrackerPathId); 310 } 311 312 /** 313 * Removes the user tracker path with the primary key from the database. Also notifies the appropriate model listeners. 314 * 315 * @param userTrackerPathId the primary key of the user tracker path 316 * @return the user tracker path that was removed 317 * @throws com.liferay.portal.NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 318 * @throws SystemException if a system exception occurred 319 */ 320 public static com.liferay.portal.model.UserTrackerPath remove( 321 long userTrackerPathId) 322 throws com.liferay.portal.NoSuchUserTrackerPathException, 323 com.liferay.portal.kernel.exception.SystemException { 324 return getPersistence().remove(userTrackerPathId); 325 } 326 327 public static com.liferay.portal.model.UserTrackerPath updateImpl( 328 com.liferay.portal.model.UserTrackerPath userTrackerPath) 329 throws com.liferay.portal.kernel.exception.SystemException { 330 return getPersistence().updateImpl(userTrackerPath); 331 } 332 333 /** 334 * Returns the user tracker path with the primary key or throws a {@link com.liferay.portal.NoSuchUserTrackerPathException} if it could not be found. 335 * 336 * @param userTrackerPathId the primary key of the user tracker path 337 * @return the user tracker path 338 * @throws com.liferay.portal.NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 339 * @throws SystemException if a system exception occurred 340 */ 341 public static com.liferay.portal.model.UserTrackerPath findByPrimaryKey( 342 long userTrackerPathId) 343 throws com.liferay.portal.NoSuchUserTrackerPathException, 344 com.liferay.portal.kernel.exception.SystemException { 345 return getPersistence().findByPrimaryKey(userTrackerPathId); 346 } 347 348 /** 349 * Returns the user tracker path with the primary key or returns <code>null</code> if it could not be found. 350 * 351 * @param userTrackerPathId the primary key of the user tracker path 352 * @return the user tracker path, or <code>null</code> if a user tracker path with the primary key could not be found 353 * @throws SystemException if a system exception occurred 354 */ 355 public static com.liferay.portal.model.UserTrackerPath fetchByPrimaryKey( 356 long userTrackerPathId) 357 throws com.liferay.portal.kernel.exception.SystemException { 358 return getPersistence().fetchByPrimaryKey(userTrackerPathId); 359 } 360 361 /** 362 * Returns all the user tracker paths. 363 * 364 * @return the user tracker paths 365 * @throws SystemException if a system exception occurred 366 */ 367 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findAll() 368 throws com.liferay.portal.kernel.exception.SystemException { 369 return getPersistence().findAll(); 370 } 371 372 /** 373 * Returns a range of all the user tracker paths. 374 * 375 * <p> 376 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserTrackerPathModelImpl}. 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. 377 * </p> 378 * 379 * @param start the lower bound of the range of user tracker paths 380 * @param end the upper bound of the range of user tracker paths (not inclusive) 381 * @return the range of user tracker paths 382 * @throws SystemException if a system exception occurred 383 */ 384 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findAll( 385 int start, int end) 386 throws com.liferay.portal.kernel.exception.SystemException { 387 return getPersistence().findAll(start, end); 388 } 389 390 /** 391 * Returns an ordered range of all the user tracker paths. 392 * 393 * <p> 394 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserTrackerPathModelImpl}. 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. 395 * </p> 396 * 397 * @param start the lower bound of the range of user tracker paths 398 * @param end the upper bound of the range of user tracker paths (not inclusive) 399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 400 * @return the ordered range of user tracker paths 401 * @throws SystemException if a system exception occurred 402 */ 403 public static java.util.List<com.liferay.portal.model.UserTrackerPath> findAll( 404 int start, int end, 405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 406 throws com.liferay.portal.kernel.exception.SystemException { 407 return getPersistence().findAll(start, end, orderByComparator); 408 } 409 410 /** 411 * Removes all the user tracker paths from the database. 412 * 413 * @throws SystemException if a system exception occurred 414 */ 415 public static void removeAll() 416 throws com.liferay.portal.kernel.exception.SystemException { 417 getPersistence().removeAll(); 418 } 419 420 /** 421 * Returns the number of user tracker paths. 422 * 423 * @return the number of user tracker paths 424 * @throws SystemException if a system exception occurred 425 */ 426 public static int countAll() 427 throws com.liferay.portal.kernel.exception.SystemException { 428 return getPersistence().countAll(); 429 } 430 431 public static UserTrackerPathPersistence getPersistence() { 432 if (_persistence == null) { 433 _persistence = (UserTrackerPathPersistence)PortalBeanLocatorUtil.locate(UserTrackerPathPersistence.class.getName()); 434 435 ReferenceRegistry.registerReference(UserTrackerPathUtil.class, 436 "_persistence"); 437 } 438 439 return _persistence; 440 } 441 442 /** 443 * @deprecated As of 6.2.0 444 */ 445 public void setPersistence(UserTrackerPathPersistence persistence) { 446 } 447 448 private static UserTrackerPathPersistence _persistence; 449 }