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