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.UserTrackerPath; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user tracker path service. This utility wraps {@link com.liferay.portal.service.persistence.impl.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. 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 UserTrackerPathPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserTrackerPathPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserTrackerPathUtil { 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(UserTrackerPath userTrackerPath) { 059 getPersistence().clearCache(userTrackerPath); 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<UserTrackerPath> 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<UserTrackerPath> 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<UserTrackerPath> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserTrackerPath> 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 UserTrackerPath update(UserTrackerPath userTrackerPath) { 100 return getPersistence().update(userTrackerPath); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static UserTrackerPath update(UserTrackerPath userTrackerPath, 107 ServiceContext serviceContext) { 108 return getPersistence().update(userTrackerPath, serviceContext); 109 } 110 111 /** 112 * Returns all the user tracker paths where userTrackerId = ?. 113 * 114 * @param userTrackerId the user tracker ID 115 * @return the matching user tracker paths 116 */ 117 public static List<UserTrackerPath> findByUserTrackerId(long userTrackerId) { 118 return getPersistence().findByUserTrackerId(userTrackerId); 119 } 120 121 /** 122 * Returns a range of all the user tracker paths where userTrackerId = ?. 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 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. 126 * </p> 127 * 128 * @param userTrackerId the user tracker ID 129 * @param start the lower bound of the range of user tracker paths 130 * @param end the upper bound of the range of user tracker paths (not inclusive) 131 * @return the range of matching user tracker paths 132 */ 133 public static List<UserTrackerPath> findByUserTrackerId( 134 long userTrackerId, int start, int end) { 135 return getPersistence().findByUserTrackerId(userTrackerId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the user tracker paths where userTrackerId = ?. 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 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. 143 * </p> 144 * 145 * @param userTrackerId the user tracker ID 146 * @param start the lower bound of the range of user tracker paths 147 * @param end the upper bound of the range of user tracker paths (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching user tracker paths 150 */ 151 public static List<UserTrackerPath> findByUserTrackerId( 152 long userTrackerId, int start, int end, 153 OrderByComparator<UserTrackerPath> orderByComparator) { 154 return getPersistence() 155 .findByUserTrackerId(userTrackerId, start, end, 156 orderByComparator); 157 } 158 159 /** 160 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 161 * 162 * @param userTrackerId the user tracker ID 163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 164 * @return the first matching user tracker path 165 * @throws NoSuchUserTrackerPathException if a matching user tracker path could not be found 166 */ 167 public static UserTrackerPath findByUserTrackerId_First( 168 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) 169 throws com.liferay.portal.NoSuchUserTrackerPathException { 170 return getPersistence() 171 .findByUserTrackerId_First(userTrackerId, orderByComparator); 172 } 173 174 /** 175 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 176 * 177 * @param userTrackerId the user tracker ID 178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 179 * @return the first matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 180 */ 181 public static UserTrackerPath fetchByUserTrackerId_First( 182 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) { 183 return getPersistence() 184 .fetchByUserTrackerId_First(userTrackerId, orderByComparator); 185 } 186 187 /** 188 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 189 * 190 * @param userTrackerId the user tracker ID 191 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 192 * @return the last matching user tracker path 193 * @throws NoSuchUserTrackerPathException if a matching user tracker path could not be found 194 */ 195 public static UserTrackerPath findByUserTrackerId_Last(long userTrackerId, 196 OrderByComparator<UserTrackerPath> orderByComparator) 197 throws com.liferay.portal.NoSuchUserTrackerPathException { 198 return getPersistence() 199 .findByUserTrackerId_Last(userTrackerId, orderByComparator); 200 } 201 202 /** 203 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 204 * 205 * @param userTrackerId the user tracker ID 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the last matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 208 */ 209 public static UserTrackerPath fetchByUserTrackerId_Last( 210 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) { 211 return getPersistence() 212 .fetchByUserTrackerId_Last(userTrackerId, orderByComparator); 213 } 214 215 /** 216 * Returns the user tracker paths before and after the current user tracker path in the ordered set where userTrackerId = ?. 217 * 218 * @param userTrackerPathId the primary key of the current user tracker path 219 * @param userTrackerId the user tracker ID 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the previous, current, and next user tracker path 222 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 223 */ 224 public static UserTrackerPath[] findByUserTrackerId_PrevAndNext( 225 long userTrackerPathId, long userTrackerId, 226 OrderByComparator<UserTrackerPath> orderByComparator) 227 throws com.liferay.portal.NoSuchUserTrackerPathException { 228 return getPersistence() 229 .findByUserTrackerId_PrevAndNext(userTrackerPathId, 230 userTrackerId, orderByComparator); 231 } 232 233 /** 234 * Removes all the user tracker paths where userTrackerId = ? from the database. 235 * 236 * @param userTrackerId the user tracker ID 237 */ 238 public static void removeByUserTrackerId(long userTrackerId) { 239 getPersistence().removeByUserTrackerId(userTrackerId); 240 } 241 242 /** 243 * Returns the number of user tracker paths where userTrackerId = ?. 244 * 245 * @param userTrackerId the user tracker ID 246 * @return the number of matching user tracker paths 247 */ 248 public static int countByUserTrackerId(long userTrackerId) { 249 return getPersistence().countByUserTrackerId(userTrackerId); 250 } 251 252 /** 253 * Caches the user tracker path in the entity cache if it is enabled. 254 * 255 * @param userTrackerPath the user tracker path 256 */ 257 public static void cacheResult(UserTrackerPath userTrackerPath) { 258 getPersistence().cacheResult(userTrackerPath); 259 } 260 261 /** 262 * Caches the user tracker paths in the entity cache if it is enabled. 263 * 264 * @param userTrackerPaths the user tracker paths 265 */ 266 public static void cacheResult(List<UserTrackerPath> userTrackerPaths) { 267 getPersistence().cacheResult(userTrackerPaths); 268 } 269 270 /** 271 * Creates a new user tracker path with the primary key. Does not add the user tracker path to the database. 272 * 273 * @param userTrackerPathId the primary key for the new user tracker path 274 * @return the new user tracker path 275 */ 276 public static UserTrackerPath create(long userTrackerPathId) { 277 return getPersistence().create(userTrackerPathId); 278 } 279 280 /** 281 * Removes the user tracker path with the primary key from the database. Also notifies the appropriate model listeners. 282 * 283 * @param userTrackerPathId the primary key of the user tracker path 284 * @return the user tracker path that was removed 285 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 286 */ 287 public static UserTrackerPath remove(long userTrackerPathId) 288 throws com.liferay.portal.NoSuchUserTrackerPathException { 289 return getPersistence().remove(userTrackerPathId); 290 } 291 292 public static UserTrackerPath updateImpl(UserTrackerPath userTrackerPath) { 293 return getPersistence().updateImpl(userTrackerPath); 294 } 295 296 /** 297 * Returns the user tracker path with the primary key or throws a {@link NoSuchUserTrackerPathException} if it could not be found. 298 * 299 * @param userTrackerPathId the primary key of the user tracker path 300 * @return the user tracker path 301 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 302 */ 303 public static UserTrackerPath findByPrimaryKey(long userTrackerPathId) 304 throws com.liferay.portal.NoSuchUserTrackerPathException { 305 return getPersistence().findByPrimaryKey(userTrackerPathId); 306 } 307 308 /** 309 * Returns the user tracker path with the primary key or returns <code>null</code> if it could not be found. 310 * 311 * @param userTrackerPathId the primary key of the user tracker path 312 * @return the user tracker path, or <code>null</code> if a user tracker path with the primary key could not be found 313 */ 314 public static UserTrackerPath fetchByPrimaryKey(long userTrackerPathId) { 315 return getPersistence().fetchByPrimaryKey(userTrackerPathId); 316 } 317 318 public static java.util.Map<java.io.Serializable, UserTrackerPath> fetchByPrimaryKeys( 319 java.util.Set<java.io.Serializable> primaryKeys) { 320 return getPersistence().fetchByPrimaryKeys(primaryKeys); 321 } 322 323 /** 324 * Returns all the user tracker paths. 325 * 326 * @return the user tracker paths 327 */ 328 public static List<UserTrackerPath> findAll() { 329 return getPersistence().findAll(); 330 } 331 332 /** 333 * Returns a range of all the user tracker paths. 334 * 335 * <p> 336 * 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 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. 337 * </p> 338 * 339 * @param start the lower bound of the range of user tracker paths 340 * @param end the upper bound of the range of user tracker paths (not inclusive) 341 * @return the range of user tracker paths 342 */ 343 public static List<UserTrackerPath> findAll(int start, int end) { 344 return getPersistence().findAll(start, end); 345 } 346 347 /** 348 * Returns an ordered range of all the user tracker paths. 349 * 350 * <p> 351 * 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 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. 352 * </p> 353 * 354 * @param start the lower bound of the range of user tracker paths 355 * @param end the upper bound of the range of user tracker paths (not inclusive) 356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 357 * @return the ordered range of user tracker paths 358 */ 359 public static List<UserTrackerPath> findAll(int start, int end, 360 OrderByComparator<UserTrackerPath> orderByComparator) { 361 return getPersistence().findAll(start, end, orderByComparator); 362 } 363 364 /** 365 * Removes all the user tracker paths from the database. 366 */ 367 public static void removeAll() { 368 getPersistence().removeAll(); 369 } 370 371 /** 372 * Returns the number of user tracker paths. 373 * 374 * @return the number of user tracker paths 375 */ 376 public static int countAll() { 377 return getPersistence().countAll(); 378 } 379 380 public static UserTrackerPathPersistence getPersistence() { 381 if (_persistence == null) { 382 _persistence = (UserTrackerPathPersistence)PortalBeanLocatorUtil.locate(UserTrackerPathPersistence.class.getName()); 383 384 ReferenceRegistry.registerReference(UserTrackerPathUtil.class, 385 "_persistence"); 386 } 387 388 return _persistence; 389 } 390 391 /** 392 * @deprecated As of 6.2.0 393 */ 394 @Deprecated 395 public void setPersistence(UserTrackerPathPersistence persistence) { 396 } 397 398 private static UserTrackerPathPersistence _persistence; 399 }