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