001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portlet.softwarecatalog.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.service.ServiceContext; 023 024 import com.liferay.portlet.softwarecatalog.model.SCLicense; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the s c license service. This utility wraps {@link SCLicensePersistenceImpl} 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 SCLicensePersistence 037 * @see SCLicensePersistenceImpl 038 * @generated 039 */ 040 public class SCLicenseUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(SCLicense scLicense) { 058 getPersistence().clearCache(scLicense); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<SCLicense> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 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<SCLicense> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 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<SCLicense> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 099 */ 100 public static SCLicense remove(SCLicense scLicense) 101 throws SystemException { 102 return getPersistence().remove(scLicense); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 107 */ 108 public static SCLicense update(SCLicense scLicense, boolean merge) 109 throws SystemException { 110 return getPersistence().update(scLicense, merge); 111 } 112 113 /** 114 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 115 */ 116 public static SCLicense update(SCLicense scLicense, boolean merge, 117 ServiceContext serviceContext) throws SystemException { 118 return getPersistence().update(scLicense, merge, serviceContext); 119 } 120 121 /** 122 * Caches the s c license in the entity cache if it is enabled. 123 * 124 * @param scLicense the s c license to cache 125 */ 126 public static void cacheResult( 127 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) { 128 getPersistence().cacheResult(scLicense); 129 } 130 131 /** 132 * Caches the s c licenses in the entity cache if it is enabled. 133 * 134 * @param scLicenses the s c licenses to cache 135 */ 136 public static void cacheResult( 137 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) { 138 getPersistence().cacheResult(scLicenses); 139 } 140 141 /** 142 * Creates a new s c license with the primary key. Does not add the s c license to the database. 143 * 144 * @param licenseId the primary key for the new s c license 145 * @return the new s c license 146 */ 147 public static com.liferay.portlet.softwarecatalog.model.SCLicense create( 148 long licenseId) { 149 return getPersistence().create(licenseId); 150 } 151 152 /** 153 * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners. 154 * 155 * @param licenseId the primary key of the s c license to remove 156 * @return the s c license that was removed 157 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 158 * @throws SystemException if a system exception occurred 159 */ 160 public static com.liferay.portlet.softwarecatalog.model.SCLicense remove( 161 long licenseId) 162 throws com.liferay.portal.kernel.exception.SystemException, 163 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 164 return getPersistence().remove(licenseId); 165 } 166 167 public static com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl( 168 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense, 169 boolean merge) 170 throws com.liferay.portal.kernel.exception.SystemException { 171 return getPersistence().updateImpl(scLicense, merge); 172 } 173 174 /** 175 * Finds the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found. 176 * 177 * @param licenseId the primary key of the s c license to find 178 * @return the s c license 179 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 180 * @throws SystemException if a system exception occurred 181 */ 182 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey( 183 long licenseId) 184 throws com.liferay.portal.kernel.exception.SystemException, 185 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 186 return getPersistence().findByPrimaryKey(licenseId); 187 } 188 189 /** 190 * Finds the s c license with the primary key or returns <code>null</code> if it could not be found. 191 * 192 * @param licenseId the primary key of the s c license to find 193 * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey( 197 long licenseId) 198 throws com.liferay.portal.kernel.exception.SystemException { 199 return getPersistence().fetchByPrimaryKey(licenseId); 200 } 201 202 /** 203 * Finds all the s c licenses where active = ?. 204 * 205 * @param active the active to search with 206 * @return the matching s c licenses 207 * @throws SystemException if a system exception occurred 208 */ 209 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 210 boolean active) 211 throws com.liferay.portal.kernel.exception.SystemException { 212 return getPersistence().findByActive(active); 213 } 214 215 /** 216 * Finds a range of all the s c licenses where active = ?. 217 * 218 * <p> 219 * 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. 220 * </p> 221 * 222 * @param active the active to search with 223 * @param start the lower bound of the range of s c licenses to return 224 * @param end the upper bound of the range of s c licenses to return (not inclusive) 225 * @return the range of matching s c licenses 226 * @throws SystemException if a system exception occurred 227 */ 228 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 229 boolean active, int start, int end) 230 throws com.liferay.portal.kernel.exception.SystemException { 231 return getPersistence().findByActive(active, start, end); 232 } 233 234 /** 235 * Finds an ordered range of all the s c licenses where active = ?. 236 * 237 * <p> 238 * 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. 239 * </p> 240 * 241 * @param active the active to search with 242 * @param start the lower bound of the range of s c licenses to return 243 * @param end the upper bound of the range of s c licenses to return (not inclusive) 244 * @param orderByComparator the comparator to order the results by 245 * @return the ordered range of matching s c licenses 246 * @throws SystemException if a system exception occurred 247 */ 248 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 249 boolean active, int start, int end, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.kernel.exception.SystemException { 252 return getPersistence() 253 .findByActive(active, start, end, orderByComparator); 254 } 255 256 /** 257 * Finds the first s c license in the ordered set where active = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 261 * </p> 262 * 263 * @param active the active to search with 264 * @param orderByComparator the comparator to order the set by 265 * @return the first matching s c license 266 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 267 * @throws SystemException if a system exception occurred 268 */ 269 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First( 270 boolean active, 271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 272 throws com.liferay.portal.kernel.exception.SystemException, 273 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 274 return getPersistence().findByActive_First(active, orderByComparator); 275 } 276 277 /** 278 * Finds the last s c license in the ordered set where active = ?. 279 * 280 * <p> 281 * 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. 282 * </p> 283 * 284 * @param active the active to search with 285 * @param orderByComparator the comparator to order the set by 286 * @return the last matching s c license 287 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 288 * @throws SystemException if a system exception occurred 289 */ 290 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last( 291 boolean active, 292 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 293 throws com.liferay.portal.kernel.exception.SystemException, 294 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 295 return getPersistence().findByActive_Last(active, orderByComparator); 296 } 297 298 /** 299 * Finds the s c licenses before and after the current s c license in the ordered set where active = ?. 300 * 301 * <p> 302 * 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. 303 * </p> 304 * 305 * @param licenseId the primary key of the current s c license 306 * @param active the active to search with 307 * @param orderByComparator the comparator to order the set by 308 * @return the previous, current, and next s c license 309 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 310 * @throws SystemException if a system exception occurred 311 */ 312 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext( 313 long licenseId, boolean active, 314 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 315 throws com.liferay.portal.kernel.exception.SystemException, 316 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 317 return getPersistence() 318 .findByActive_PrevAndNext(licenseId, active, 319 orderByComparator); 320 } 321 322 /** 323 * Filters by the user's permissions and finds all the s c licenses where active = ?. 324 * 325 * @param active the active to search with 326 * @return the matching s c licenses that the user has permission to view 327 * @throws SystemException if a system exception occurred 328 */ 329 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 330 boolean active) 331 throws com.liferay.portal.kernel.exception.SystemException { 332 return getPersistence().filterFindByActive(active); 333 } 334 335 /** 336 * Filters by the user's permissions and finds a range of all the s c licenses where active = ?. 337 * 338 * <p> 339 * 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. 340 * </p> 341 * 342 * @param active the active to search with 343 * @param start the lower bound of the range of s c licenses to return 344 * @param end the upper bound of the range of s c licenses to return (not inclusive) 345 * @return the range of matching s c licenses that the user has permission to view 346 * @throws SystemException if a system exception occurred 347 */ 348 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 349 boolean active, int start, int end) 350 throws com.liferay.portal.kernel.exception.SystemException { 351 return getPersistence().filterFindByActive(active, start, end); 352 } 353 354 /** 355 * Filters by the user's permissions and finds an ordered range of all the s c licenses where active = ?. 356 * 357 * <p> 358 * 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. 359 * </p> 360 * 361 * @param active the active to search with 362 * @param start the lower bound of the range of s c licenses to return 363 * @param end the upper bound of the range of s c licenses to return (not inclusive) 364 * @param orderByComparator the comparator to order the results by 365 * @return the ordered range of matching s c licenses that the user has permission to view 366 * @throws SystemException if a system exception occurred 367 */ 368 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 369 boolean active, int start, int end, 370 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 371 throws com.liferay.portal.kernel.exception.SystemException { 372 return getPersistence() 373 .filterFindByActive(active, start, end, orderByComparator); 374 } 375 376 /** 377 * Filters the s c licenses before and after the current s c license in the ordered set where active = ?. 378 * 379 * <p> 380 * 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. 381 * </p> 382 * 383 * @param licenseId the primary key of the current s c license 384 * @param active the active to search with 385 * @param orderByComparator the comparator to order the set by 386 * @return the previous, current, and next s c license 387 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 388 * @throws SystemException if a system exception occurred 389 */ 390 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByActive_PrevAndNext( 391 long licenseId, boolean active, 392 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 393 throws com.liferay.portal.kernel.exception.SystemException, 394 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 395 return getPersistence() 396 .filterFindByActive_PrevAndNext(licenseId, active, 397 orderByComparator); 398 } 399 400 /** 401 * Finds all the s c licenses where active = ? and recommended = ?. 402 * 403 * @param active the active to search with 404 * @param recommended the recommended to search with 405 * @return the matching s c licenses 406 * @throws SystemException if a system exception occurred 407 */ 408 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 409 boolean active, boolean recommended) 410 throws com.liferay.portal.kernel.exception.SystemException { 411 return getPersistence().findByA_R(active, recommended); 412 } 413 414 /** 415 * Finds a range of all the s c licenses where active = ? and recommended = ?. 416 * 417 * <p> 418 * 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. 419 * </p> 420 * 421 * @param active the active to search with 422 * @param recommended the recommended to search with 423 * @param start the lower bound of the range of s c licenses to return 424 * @param end the upper bound of the range of s c licenses to return (not inclusive) 425 * @return the range of matching s c licenses 426 * @throws SystemException if a system exception occurred 427 */ 428 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 429 boolean active, boolean recommended, int start, int end) 430 throws com.liferay.portal.kernel.exception.SystemException { 431 return getPersistence().findByA_R(active, recommended, start, end); 432 } 433 434 /** 435 * Finds an ordered range of all the s c licenses where active = ? and recommended = ?. 436 * 437 * <p> 438 * 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. 439 * </p> 440 * 441 * @param active the active to search with 442 * @param recommended the recommended to search with 443 * @param start the lower bound of the range of s c licenses to return 444 * @param end the upper bound of the range of s c licenses to return (not inclusive) 445 * @param orderByComparator the comparator to order the results by 446 * @return the ordered range of matching s c licenses 447 * @throws SystemException if a system exception occurred 448 */ 449 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 450 boolean active, boolean recommended, int start, int end, 451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 452 throws com.liferay.portal.kernel.exception.SystemException { 453 return getPersistence() 454 .findByA_R(active, recommended, start, end, orderByComparator); 455 } 456 457 /** 458 * Finds the first s c license in the ordered set where active = ? and recommended = ?. 459 * 460 * <p> 461 * 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. 462 * </p> 463 * 464 * @param active the active to search with 465 * @param recommended the recommended to search with 466 * @param orderByComparator the comparator to order the set by 467 * @return the first matching s c license 468 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 469 * @throws SystemException if a system exception occurred 470 */ 471 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First( 472 boolean active, boolean recommended, 473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 474 throws com.liferay.portal.kernel.exception.SystemException, 475 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 476 return getPersistence() 477 .findByA_R_First(active, recommended, orderByComparator); 478 } 479 480 /** 481 * Finds the last s c license in the ordered set where active = ? and recommended = ?. 482 * 483 * <p> 484 * 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. 485 * </p> 486 * 487 * @param active the active to search with 488 * @param recommended the recommended to search with 489 * @param orderByComparator the comparator to order the set by 490 * @return the last matching s c license 491 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 492 * @throws SystemException if a system exception occurred 493 */ 494 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last( 495 boolean active, boolean recommended, 496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 497 throws com.liferay.portal.kernel.exception.SystemException, 498 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 499 return getPersistence() 500 .findByA_R_Last(active, recommended, orderByComparator); 501 } 502 503 /** 504 * Finds the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 505 * 506 * <p> 507 * 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. 508 * </p> 509 * 510 * @param licenseId the primary key of the current s c license 511 * @param active the active to search with 512 * @param recommended the recommended to search with 513 * @param orderByComparator the comparator to order the set by 514 * @return the previous, current, and next s c license 515 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 516 * @throws SystemException if a system exception occurred 517 */ 518 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext( 519 long licenseId, boolean active, boolean recommended, 520 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 521 throws com.liferay.portal.kernel.exception.SystemException, 522 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 523 return getPersistence() 524 .findByA_R_PrevAndNext(licenseId, active, recommended, 525 orderByComparator); 526 } 527 528 /** 529 * Filters by the user's permissions and finds all the s c licenses where active = ? and recommended = ?. 530 * 531 * @param active the active to search with 532 * @param recommended the recommended to search with 533 * @return the matching s c licenses that the user has permission to view 534 * @throws SystemException if a system exception occurred 535 */ 536 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 537 boolean active, boolean recommended) 538 throws com.liferay.portal.kernel.exception.SystemException { 539 return getPersistence().filterFindByA_R(active, recommended); 540 } 541 542 /** 543 * Filters by the user's permissions and finds a range of all the s c licenses where active = ? and recommended = ?. 544 * 545 * <p> 546 * 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. 547 * </p> 548 * 549 * @param active the active to search with 550 * @param recommended the recommended to search with 551 * @param start the lower bound of the range of s c licenses to return 552 * @param end the upper bound of the range of s c licenses to return (not inclusive) 553 * @return the range of matching s c licenses that the user has permission to view 554 * @throws SystemException if a system exception occurred 555 */ 556 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 557 boolean active, boolean recommended, int start, int end) 558 throws com.liferay.portal.kernel.exception.SystemException { 559 return getPersistence().filterFindByA_R(active, recommended, start, end); 560 } 561 562 /** 563 * Filters by the user's permissions and finds an ordered range of all the s c licenses where active = ? and recommended = ?. 564 * 565 * <p> 566 * 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. 567 * </p> 568 * 569 * @param active the active to search with 570 * @param recommended the recommended to search with 571 * @param start the lower bound of the range of s c licenses to return 572 * @param end the upper bound of the range of s c licenses to return (not inclusive) 573 * @param orderByComparator the comparator to order the results by 574 * @return the ordered range of matching s c licenses that the user has permission to view 575 * @throws SystemException if a system exception occurred 576 */ 577 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 578 boolean active, boolean recommended, int start, int end, 579 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 580 throws com.liferay.portal.kernel.exception.SystemException { 581 return getPersistence() 582 .filterFindByA_R(active, recommended, start, end, 583 orderByComparator); 584 } 585 586 /** 587 * Filters the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 588 * 589 * <p> 590 * 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. 591 * </p> 592 * 593 * @param licenseId the primary key of the current s c license 594 * @param active the active to search with 595 * @param recommended the recommended to search with 596 * @param orderByComparator the comparator to order the set by 597 * @return the previous, current, and next s c license 598 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 599 * @throws SystemException if a system exception occurred 600 */ 601 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByA_R_PrevAndNext( 602 long licenseId, boolean active, boolean recommended, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException, 605 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 606 return getPersistence() 607 .filterFindByA_R_PrevAndNext(licenseId, active, recommended, 608 orderByComparator); 609 } 610 611 /** 612 * Finds all the s c licenses. 613 * 614 * @return the s c licenses 615 * @throws SystemException if a system exception occurred 616 */ 617 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll() 618 throws com.liferay.portal.kernel.exception.SystemException { 619 return getPersistence().findAll(); 620 } 621 622 /** 623 * Finds a range of all the s c licenses. 624 * 625 * <p> 626 * 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. 627 * </p> 628 * 629 * @param start the lower bound of the range of s c licenses to return 630 * @param end the upper bound of the range of s c licenses to return (not inclusive) 631 * @return the range of s c licenses 632 * @throws SystemException if a system exception occurred 633 */ 634 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 635 int start, int end) 636 throws com.liferay.portal.kernel.exception.SystemException { 637 return getPersistence().findAll(start, end); 638 } 639 640 /** 641 * Finds an ordered range of all the s c licenses. 642 * 643 * <p> 644 * 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. 645 * </p> 646 * 647 * @param start the lower bound of the range of s c licenses to return 648 * @param end the upper bound of the range of s c licenses to return (not inclusive) 649 * @param orderByComparator the comparator to order the results by 650 * @return the ordered range of s c licenses 651 * @throws SystemException if a system exception occurred 652 */ 653 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 654 int start, int end, 655 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 656 throws com.liferay.portal.kernel.exception.SystemException { 657 return getPersistence().findAll(start, end, orderByComparator); 658 } 659 660 /** 661 * Removes all the s c licenses where active = ? from the database. 662 * 663 * @param active the active to search with 664 * @throws SystemException if a system exception occurred 665 */ 666 public static void removeByActive(boolean active) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 getPersistence().removeByActive(active); 669 } 670 671 /** 672 * Removes all the s c licenses where active = ? and recommended = ? from the database. 673 * 674 * @param active the active to search with 675 * @param recommended the recommended to search with 676 * @throws SystemException if a system exception occurred 677 */ 678 public static void removeByA_R(boolean active, boolean recommended) 679 throws com.liferay.portal.kernel.exception.SystemException { 680 getPersistence().removeByA_R(active, recommended); 681 } 682 683 /** 684 * Removes all the s c licenses from the database. 685 * 686 * @throws SystemException if a system exception occurred 687 */ 688 public static void removeAll() 689 throws com.liferay.portal.kernel.exception.SystemException { 690 getPersistence().removeAll(); 691 } 692 693 /** 694 * Counts all the s c licenses where active = ?. 695 * 696 * @param active the active to search with 697 * @return the number of matching s c licenses 698 * @throws SystemException if a system exception occurred 699 */ 700 public static int countByActive(boolean active) 701 throws com.liferay.portal.kernel.exception.SystemException { 702 return getPersistence().countByActive(active); 703 } 704 705 /** 706 * Filters by the user's permissions and counts all the s c licenses where active = ?. 707 * 708 * @param active the active to search with 709 * @return the number of matching s c licenses that the user has permission to view 710 * @throws SystemException if a system exception occurred 711 */ 712 public static int filterCountByActive(boolean active) 713 throws com.liferay.portal.kernel.exception.SystemException { 714 return getPersistence().filterCountByActive(active); 715 } 716 717 /** 718 * Counts all the s c licenses where active = ? and recommended = ?. 719 * 720 * @param active the active to search with 721 * @param recommended the recommended to search with 722 * @return the number of matching s c licenses 723 * @throws SystemException if a system exception occurred 724 */ 725 public static int countByA_R(boolean active, boolean recommended) 726 throws com.liferay.portal.kernel.exception.SystemException { 727 return getPersistence().countByA_R(active, recommended); 728 } 729 730 /** 731 * Filters by the user's permissions and counts all the s c licenses where active = ? and recommended = ?. 732 * 733 * @param active the active to search with 734 * @param recommended the recommended to search with 735 * @return the number of matching s c licenses that the user has permission to view 736 * @throws SystemException if a system exception occurred 737 */ 738 public static int filterCountByA_R(boolean active, boolean recommended) 739 throws com.liferay.portal.kernel.exception.SystemException { 740 return getPersistence().filterCountByA_R(active, recommended); 741 } 742 743 /** 744 * Counts all the s c licenses. 745 * 746 * @return the number of s c licenses 747 * @throws SystemException if a system exception occurred 748 */ 749 public static int countAll() 750 throws com.liferay.portal.kernel.exception.SystemException { 751 return getPersistence().countAll(); 752 } 753 754 /** 755 * Gets all the s c product entries associated with the s c license. 756 * 757 * @param pk the primary key of the s c license to get the associated s c product entries for 758 * @return the s c product entries associated with the s c license 759 * @throws SystemException if a system exception occurred 760 */ 761 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 762 long pk) throws com.liferay.portal.kernel.exception.SystemException { 763 return getPersistence().getSCProductEntries(pk); 764 } 765 766 /** 767 * Gets a range of all the s c product entries associated with the s c license. 768 * 769 * <p> 770 * 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. 771 * </p> 772 * 773 * @param pk the primary key of the s c license to get the associated s c product entries for 774 * @param start the lower bound of the range of s c licenses to return 775 * @param end the upper bound of the range of s c licenses to return (not inclusive) 776 * @return the range of s c product entries associated with the s c license 777 * @throws SystemException if a system exception occurred 778 */ 779 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 780 long pk, int start, int end) 781 throws com.liferay.portal.kernel.exception.SystemException { 782 return getPersistence().getSCProductEntries(pk, start, end); 783 } 784 785 /** 786 * Gets an ordered range of all the s c product entries associated with the s c license. 787 * 788 * <p> 789 * 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. 790 * </p> 791 * 792 * @param pk the primary key of the s c license to get the associated s c product entries for 793 * @param start the lower bound of the range of s c licenses to return 794 * @param end the upper bound of the range of s c licenses to return (not inclusive) 795 * @param orderByComparator the comparator to order the results by 796 * @return the ordered range of s c product entries associated with the s c license 797 * @throws SystemException if a system exception occurred 798 */ 799 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 800 long pk, int start, int end, 801 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 802 throws com.liferay.portal.kernel.exception.SystemException { 803 return getPersistence() 804 .getSCProductEntries(pk, start, end, orderByComparator); 805 } 806 807 /** 808 * Gets the number of s c product entries associated with the s c license. 809 * 810 * @param pk the primary key of the s c license to get the number of associated s c product entries for 811 * @return the number of s c product entries associated with the s c license 812 * @throws SystemException if a system exception occurred 813 */ 814 public static int getSCProductEntriesSize(long pk) 815 throws com.liferay.portal.kernel.exception.SystemException { 816 return getPersistence().getSCProductEntriesSize(pk); 817 } 818 819 /** 820 * Determines if the s c product entry is associated with the s c license. 821 * 822 * @param pk the primary key of the s c license 823 * @param scProductEntryPK the primary key of the s c product entry 824 * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise 825 * @throws SystemException if a system exception occurred 826 */ 827 public static boolean containsSCProductEntry(long pk, long scProductEntryPK) 828 throws com.liferay.portal.kernel.exception.SystemException { 829 return getPersistence().containsSCProductEntry(pk, scProductEntryPK); 830 } 831 832 /** 833 * Determines if the s c license has any s c product entries associated with it. 834 * 835 * @param pk the primary key of the s c license to check for associations with s c product entries 836 * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise 837 * @throws SystemException if a system exception occurred 838 */ 839 public static boolean containsSCProductEntries(long pk) 840 throws com.liferay.portal.kernel.exception.SystemException { 841 return getPersistence().containsSCProductEntries(pk); 842 } 843 844 /** 845 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 846 * 847 * @param pk the primary key of the s c license 848 * @param scProductEntryPK the primary key of the s c product entry 849 * @throws SystemException if a system exception occurred 850 */ 851 public static void addSCProductEntry(long pk, long scProductEntryPK) 852 throws com.liferay.portal.kernel.exception.SystemException { 853 getPersistence().addSCProductEntry(pk, scProductEntryPK); 854 } 855 856 /** 857 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 858 * 859 * @param pk the primary key of the s c license 860 * @param scProductEntry the s c product entry 861 * @throws SystemException if a system exception occurred 862 */ 863 public static void addSCProductEntry(long pk, 864 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 865 throws com.liferay.portal.kernel.exception.SystemException { 866 getPersistence().addSCProductEntry(pk, scProductEntry); 867 } 868 869 /** 870 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 871 * 872 * @param pk the primary key of the s c license 873 * @param scProductEntryPKs the primary keys of the s c product entries 874 * @throws SystemException if a system exception occurred 875 */ 876 public static void addSCProductEntries(long pk, long[] scProductEntryPKs) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 getPersistence().addSCProductEntries(pk, scProductEntryPKs); 879 } 880 881 /** 882 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 883 * 884 * @param pk the primary key of the s c license 885 * @param scProductEntries the s c product entries 886 * @throws SystemException if a system exception occurred 887 */ 888 public static void addSCProductEntries(long pk, 889 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 890 throws com.liferay.portal.kernel.exception.SystemException { 891 getPersistence().addSCProductEntries(pk, scProductEntries); 892 } 893 894 /** 895 * Clears all associations between the s c license and its s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 896 * 897 * @param pk the primary key of the s c license to clear the associated s c product entries from 898 * @throws SystemException if a system exception occurred 899 */ 900 public static void clearSCProductEntries(long pk) 901 throws com.liferay.portal.kernel.exception.SystemException { 902 getPersistence().clearSCProductEntries(pk); 903 } 904 905 /** 906 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 907 * 908 * @param pk the primary key of the s c license 909 * @param scProductEntryPK the primary key of the s c product entry 910 * @throws SystemException if a system exception occurred 911 */ 912 public static void removeSCProductEntry(long pk, long scProductEntryPK) 913 throws com.liferay.portal.kernel.exception.SystemException { 914 getPersistence().removeSCProductEntry(pk, scProductEntryPK); 915 } 916 917 /** 918 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 919 * 920 * @param pk the primary key of the s c license 921 * @param scProductEntry the s c product entry 922 * @throws SystemException if a system exception occurred 923 */ 924 public static void removeSCProductEntry(long pk, 925 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 926 throws com.liferay.portal.kernel.exception.SystemException { 927 getPersistence().removeSCProductEntry(pk, scProductEntry); 928 } 929 930 /** 931 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 932 * 933 * @param pk the primary key of the s c license 934 * @param scProductEntryPKs the primary keys of the s c product entries 935 * @throws SystemException if a system exception occurred 936 */ 937 public static void removeSCProductEntries(long pk, long[] scProductEntryPKs) 938 throws com.liferay.portal.kernel.exception.SystemException { 939 getPersistence().removeSCProductEntries(pk, scProductEntryPKs); 940 } 941 942 /** 943 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 944 * 945 * @param pk the primary key of the s c license 946 * @param scProductEntries the s c product entries 947 * @throws SystemException if a system exception occurred 948 */ 949 public static void removeSCProductEntries(long pk, 950 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 951 throws com.liferay.portal.kernel.exception.SystemException { 952 getPersistence().removeSCProductEntries(pk, scProductEntries); 953 } 954 955 /** 956 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 957 * 958 * @param pk the primary key of the s c license to set the associations for 959 * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license 960 * @throws SystemException if a system exception occurred 961 */ 962 public static void setSCProductEntries(long pk, long[] scProductEntryPKs) 963 throws com.liferay.portal.kernel.exception.SystemException { 964 getPersistence().setSCProductEntries(pk, scProductEntryPKs); 965 } 966 967 /** 968 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 969 * 970 * @param pk the primary key of the s c license to set the associations for 971 * @param scProductEntries the s c product entries to be associated with the s c license 972 * @throws SystemException if a system exception occurred 973 */ 974 public static void setSCProductEntries(long pk, 975 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 976 throws com.liferay.portal.kernel.exception.SystemException { 977 getPersistence().setSCProductEntries(pk, scProductEntries); 978 } 979 980 public static SCLicensePersistence getPersistence() { 981 if (_persistence == null) { 982 _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName()); 983 984 ReferenceRegistry.registerReference(SCLicenseUtil.class, 985 "_persistence"); 986 } 987 988 return _persistence; 989 } 990 991 public void setPersistence(SCLicensePersistence persistence) { 992 _persistence = persistence; 993 994 ReferenceRegistry.registerReference(SCLicenseUtil.class, "_persistence"); 995 } 996 997 private static SCLicensePersistence _persistence; 998 }