001 /** 002 * Copyright (c) 2000-2010 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.service.ServiceContext; 022 023 import com.liferay.portlet.softwarecatalog.model.SCLicense; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the s c license service. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see SCLicensePersistence 036 * @see SCLicensePersistenceImpl 037 * @generated 038 */ 039 public class SCLicenseUtil { 040 /** 041 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 042 */ 043 public static void clearCache() { 044 getPersistence().clearCache(); 045 } 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 049 */ 050 public static void clearCache(SCLicense scLicense) { 051 getPersistence().clearCache(scLicense); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 056 */ 057 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 058 throws SystemException { 059 return getPersistence().countWithDynamicQuery(dynamicQuery); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 064 */ 065 public static List<SCLicense> findWithDynamicQuery( 066 DynamicQuery dynamicQuery) throws SystemException { 067 return getPersistence().findWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 072 */ 073 public static List<SCLicense> findWithDynamicQuery( 074 DynamicQuery dynamicQuery, int start, int end) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 081 */ 082 public static List<SCLicense> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end, 084 OrderByComparator orderByComparator) throws SystemException { 085 return getPersistence() 086 .findWithDynamicQuery(dynamicQuery, start, end, 087 orderByComparator); 088 } 089 090 /** 091 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 092 */ 093 public static SCLicense remove(SCLicense scLicense) 094 throws SystemException { 095 return getPersistence().remove(scLicense); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 100 */ 101 public static SCLicense update(SCLicense scLicense, boolean merge) 102 throws SystemException { 103 return getPersistence().update(scLicense, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static SCLicense update(SCLicense scLicense, boolean merge, 110 ServiceContext serviceContext) throws SystemException { 111 return getPersistence().update(scLicense, merge, serviceContext); 112 } 113 114 /** 115 * Caches the s c license in the entity cache if it is enabled. 116 * 117 * @param scLicense the s c license to cache 118 */ 119 public static void cacheResult( 120 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) { 121 getPersistence().cacheResult(scLicense); 122 } 123 124 /** 125 * Caches the s c licenses in the entity cache if it is enabled. 126 * 127 * @param scLicenses the s c licenses to cache 128 */ 129 public static void cacheResult( 130 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) { 131 getPersistence().cacheResult(scLicenses); 132 } 133 134 /** 135 * Creates a new s c license with the primary key. 136 * 137 * @param licenseId the primary key for the new s c license 138 * @return the new s c license 139 */ 140 public static com.liferay.portlet.softwarecatalog.model.SCLicense create( 141 long licenseId) { 142 return getPersistence().create(licenseId); 143 } 144 145 /** 146 * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners. 147 * 148 * @param licenseId the primary key of the s c license to remove 149 * @return the s c license that was removed 150 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public static com.liferay.portlet.softwarecatalog.model.SCLicense remove( 154 long licenseId) 155 throws com.liferay.portal.kernel.exception.SystemException, 156 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 157 return getPersistence().remove(licenseId); 158 } 159 160 public static com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl( 161 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense, 162 boolean merge) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence().updateImpl(scLicense, merge); 165 } 166 167 /** 168 * Finds the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found. 169 * 170 * @param licenseId the primary key of the s c license to find 171 * @return the s c license 172 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey( 176 long licenseId) 177 throws com.liferay.portal.kernel.exception.SystemException, 178 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 179 return getPersistence().findByPrimaryKey(licenseId); 180 } 181 182 /** 183 * Finds the s c license with the primary key or returns <code>null</code> if it could not be found. 184 * 185 * @param licenseId the primary key of the s c license to find 186 * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found 187 * @throws SystemException if a system exception occurred 188 */ 189 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey( 190 long licenseId) 191 throws com.liferay.portal.kernel.exception.SystemException { 192 return getPersistence().fetchByPrimaryKey(licenseId); 193 } 194 195 /** 196 * Finds all the s c licenses where active = ?. 197 * 198 * @param active the active to search with 199 * @return the matching s c licenses 200 * @throws SystemException if a system exception occurred 201 */ 202 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 203 boolean active) 204 throws com.liferay.portal.kernel.exception.SystemException { 205 return getPersistence().findByActive(active); 206 } 207 208 /** 209 * Finds a range of all the s c licenses where active = ?. 210 * 211 * <p> 212 * 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. 213 * </p> 214 * 215 * @param active the active to search with 216 * @param start the lower bound of the range of s c licenses to return 217 * @param end the upper bound of the range of s c licenses to return (not inclusive) 218 * @return the range of matching s c licenses 219 * @throws SystemException if a system exception occurred 220 */ 221 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 222 boolean active, int start, int end) 223 throws com.liferay.portal.kernel.exception.SystemException { 224 return getPersistence().findByActive(active, start, end); 225 } 226 227 /** 228 * Finds an ordered range of all the s c licenses where active = ?. 229 * 230 * <p> 231 * 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. 232 * </p> 233 * 234 * @param active the active to search with 235 * @param start the lower bound of the range of s c licenses to return 236 * @param end the upper bound of the range of s c licenses to return (not inclusive) 237 * @param orderByComparator the comparator to order the results by 238 * @return the ordered range of matching s c licenses 239 * @throws SystemException if a system exception occurred 240 */ 241 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 242 boolean active, int start, int end, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence() 246 .findByActive(active, start, end, orderByComparator); 247 } 248 249 /** 250 * Finds the first s c license in the ordered set where active = ?. 251 * 252 * <p> 253 * 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. 254 * </p> 255 * 256 * @param active the active to search with 257 * @param orderByComparator the comparator to order the set by 258 * @return the first matching s c license 259 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 260 * @throws SystemException if a system exception occurred 261 */ 262 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First( 263 boolean active, 264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 265 throws com.liferay.portal.kernel.exception.SystemException, 266 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 267 return getPersistence().findByActive_First(active, orderByComparator); 268 } 269 270 /** 271 * Finds the last s c license in the ordered set where active = ?. 272 * 273 * <p> 274 * 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. 275 * </p> 276 * 277 * @param active the active to search with 278 * @param orderByComparator the comparator to order the set by 279 * @return the last matching s c license 280 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 281 * @throws SystemException if a system exception occurred 282 */ 283 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last( 284 boolean active, 285 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 286 throws com.liferay.portal.kernel.exception.SystemException, 287 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 288 return getPersistence().findByActive_Last(active, orderByComparator); 289 } 290 291 /** 292 * Finds the s c licenses before and after the current s c license in the ordered set where active = ?. 293 * 294 * <p> 295 * 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. 296 * </p> 297 * 298 * @param licenseId the primary key of the current s c license 299 * @param active the active to search with 300 * @param orderByComparator the comparator to order the set by 301 * @return the previous, current, and next s c license 302 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 303 * @throws SystemException if a system exception occurred 304 */ 305 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext( 306 long licenseId, boolean active, 307 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 308 throws com.liferay.portal.kernel.exception.SystemException, 309 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 310 return getPersistence() 311 .findByActive_PrevAndNext(licenseId, active, 312 orderByComparator); 313 } 314 315 /** 316 * Finds all the s c licenses where active = ? and recommended = ?. 317 * 318 * @param active the active to search with 319 * @param recommended the recommended to search with 320 * @return the matching s c licenses 321 * @throws SystemException if a system exception occurred 322 */ 323 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 324 boolean active, boolean recommended) 325 throws com.liferay.portal.kernel.exception.SystemException { 326 return getPersistence().findByA_R(active, recommended); 327 } 328 329 /** 330 * Finds a range of all the s c licenses where active = ? and recommended = ?. 331 * 332 * <p> 333 * 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. 334 * </p> 335 * 336 * @param active the active to search with 337 * @param recommended the recommended to search with 338 * @param start the lower bound of the range of s c licenses to return 339 * @param end the upper bound of the range of s c licenses to return (not inclusive) 340 * @return the range of matching s c licenses 341 * @throws SystemException if a system exception occurred 342 */ 343 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 344 boolean active, boolean recommended, int start, int end) 345 throws com.liferay.portal.kernel.exception.SystemException { 346 return getPersistence().findByA_R(active, recommended, start, end); 347 } 348 349 /** 350 * Finds an ordered range of all the s c licenses where active = ? and recommended = ?. 351 * 352 * <p> 353 * 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. 354 * </p> 355 * 356 * @param active the active to search with 357 * @param recommended the recommended to search with 358 * @param start the lower bound of the range of s c licenses to return 359 * @param end the upper bound of the range of s c licenses to return (not inclusive) 360 * @param orderByComparator the comparator to order the results by 361 * @return the ordered range of matching s c licenses 362 * @throws SystemException if a system exception occurred 363 */ 364 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 365 boolean active, boolean recommended, int start, int end, 366 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 367 throws com.liferay.portal.kernel.exception.SystemException { 368 return getPersistence() 369 .findByA_R(active, recommended, start, end, orderByComparator); 370 } 371 372 /** 373 * Finds the first s c license in the ordered set where active = ? and recommended = ?. 374 * 375 * <p> 376 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 377 * </p> 378 * 379 * @param active the active to search with 380 * @param recommended the recommended to search with 381 * @param orderByComparator the comparator to order the set by 382 * @return the first matching s c license 383 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 384 * @throws SystemException if a system exception occurred 385 */ 386 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First( 387 boolean active, boolean recommended, 388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 389 throws com.liferay.portal.kernel.exception.SystemException, 390 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 391 return getPersistence() 392 .findByA_R_First(active, recommended, orderByComparator); 393 } 394 395 /** 396 * Finds the last s c license in the ordered set where active = ? and recommended = ?. 397 * 398 * <p> 399 * 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. 400 * </p> 401 * 402 * @param active the active to search with 403 * @param recommended the recommended to search with 404 * @param orderByComparator the comparator to order the set by 405 * @return the last matching s c license 406 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 407 * @throws SystemException if a system exception occurred 408 */ 409 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last( 410 boolean active, boolean recommended, 411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 412 throws com.liferay.portal.kernel.exception.SystemException, 413 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 414 return getPersistence() 415 .findByA_R_Last(active, recommended, orderByComparator); 416 } 417 418 /** 419 * Finds the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 420 * 421 * <p> 422 * 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. 423 * </p> 424 * 425 * @param licenseId the primary key of the current s c license 426 * @param active the active to search with 427 * @param recommended the recommended to search with 428 * @param orderByComparator the comparator to order the set by 429 * @return the previous, current, and next s c license 430 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 431 * @throws SystemException if a system exception occurred 432 */ 433 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext( 434 long licenseId, boolean active, boolean recommended, 435 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 436 throws com.liferay.portal.kernel.exception.SystemException, 437 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 438 return getPersistence() 439 .findByA_R_PrevAndNext(licenseId, active, recommended, 440 orderByComparator); 441 } 442 443 /** 444 * Finds all the s c licenses. 445 * 446 * @return the s c licenses 447 * @throws SystemException if a system exception occurred 448 */ 449 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll() 450 throws com.liferay.portal.kernel.exception.SystemException { 451 return getPersistence().findAll(); 452 } 453 454 /** 455 * Finds a range of all the s c licenses. 456 * 457 * <p> 458 * 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. 459 * </p> 460 * 461 * @param start the lower bound of the range of s c licenses to return 462 * @param end the upper bound of the range of s c licenses to return (not inclusive) 463 * @return the range of s c licenses 464 * @throws SystemException if a system exception occurred 465 */ 466 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 467 int start, int end) 468 throws com.liferay.portal.kernel.exception.SystemException { 469 return getPersistence().findAll(start, end); 470 } 471 472 /** 473 * Finds an ordered range of all the s c licenses. 474 * 475 * <p> 476 * 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. 477 * </p> 478 * 479 * @param start the lower bound of the range of s c licenses to return 480 * @param end the upper bound of the range of s c licenses to return (not inclusive) 481 * @param orderByComparator the comparator to order the results by 482 * @return the ordered range of s c licenses 483 * @throws SystemException if a system exception occurred 484 */ 485 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 486 int start, int end, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException { 489 return getPersistence().findAll(start, end, orderByComparator); 490 } 491 492 /** 493 * Removes all the s c licenses where active = ? from the database. 494 * 495 * @param active the active to search with 496 * @throws SystemException if a system exception occurred 497 */ 498 public static void removeByActive(boolean active) 499 throws com.liferay.portal.kernel.exception.SystemException { 500 getPersistence().removeByActive(active); 501 } 502 503 /** 504 * Removes all the s c licenses where active = ? and recommended = ? from the database. 505 * 506 * @param active the active to search with 507 * @param recommended the recommended to search with 508 * @throws SystemException if a system exception occurred 509 */ 510 public static void removeByA_R(boolean active, boolean recommended) 511 throws com.liferay.portal.kernel.exception.SystemException { 512 getPersistence().removeByA_R(active, recommended); 513 } 514 515 /** 516 * Removes all the s c licenses from the database. 517 * 518 * @throws SystemException if a system exception occurred 519 */ 520 public static void removeAll() 521 throws com.liferay.portal.kernel.exception.SystemException { 522 getPersistence().removeAll(); 523 } 524 525 /** 526 * Counts all the s c licenses where active = ?. 527 * 528 * @param active the active to search with 529 * @return the number of matching s c licenses 530 * @throws SystemException if a system exception occurred 531 */ 532 public static int countByActive(boolean active) 533 throws com.liferay.portal.kernel.exception.SystemException { 534 return getPersistence().countByActive(active); 535 } 536 537 /** 538 * Counts all the s c licenses where active = ? and recommended = ?. 539 * 540 * @param active the active to search with 541 * @param recommended the recommended to search with 542 * @return the number of matching s c licenses 543 * @throws SystemException if a system exception occurred 544 */ 545 public static int countByA_R(boolean active, boolean recommended) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence().countByA_R(active, recommended); 548 } 549 550 /** 551 * Counts all the s c licenses. 552 * 553 * @return the number of s c licenses 554 * @throws SystemException if a system exception occurred 555 */ 556 public static int countAll() 557 throws com.liferay.portal.kernel.exception.SystemException { 558 return getPersistence().countAll(); 559 } 560 561 /** 562 * Gets all the s c product entries associated with the s c license. 563 * 564 * @param pk the primary key of the s c license to get the associated s c product entries for 565 * @return the s c product entries associated with the s c license 566 * @throws SystemException if a system exception occurred 567 */ 568 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 569 long pk) throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence().getSCProductEntries(pk); 571 } 572 573 /** 574 * Gets a range of all the s c product entries associated with the s c license. 575 * 576 * <p> 577 * 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. 578 * </p> 579 * 580 * @param pk the primary key of the s c license to get the associated s c product entries for 581 * @param start the lower bound of the range of s c licenses to return 582 * @param end the upper bound of the range of s c licenses to return (not inclusive) 583 * @return the range of s c product entries associated with the s c license 584 * @throws SystemException if a system exception occurred 585 */ 586 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 587 long pk, int start, int end) 588 throws com.liferay.portal.kernel.exception.SystemException { 589 return getPersistence().getSCProductEntries(pk, start, end); 590 } 591 592 /** 593 * Gets an ordered range of all the s c product entries associated with the s c license. 594 * 595 * <p> 596 * 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. 597 * </p> 598 * 599 * @param pk the primary key of the s c license to get the associated s c product entries for 600 * @param start the lower bound of the range of s c licenses to return 601 * @param end the upper bound of the range of s c licenses to return (not inclusive) 602 * @param orderByComparator the comparator to order the results by 603 * @return the ordered range of s c product entries associated with the s c license 604 * @throws SystemException if a system exception occurred 605 */ 606 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 607 long pk, int start, int end, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence() 611 .getSCProductEntries(pk, start, end, orderByComparator); 612 } 613 614 /** 615 * Gets the number of s c product entries associated with the s c license. 616 * 617 * @param pk the primary key of the s c license to get the number of associated s c product entries for 618 * @return the number of s c product entries associated with the s c license 619 * @throws SystemException if a system exception occurred 620 */ 621 public static int getSCProductEntriesSize(long pk) 622 throws com.liferay.portal.kernel.exception.SystemException { 623 return getPersistence().getSCProductEntriesSize(pk); 624 } 625 626 /** 627 * Determines whether the s c product entry is associated with the s c license. 628 * 629 * @param pk the primary key of the s c license 630 * @param scProductEntryPK the primary key of the s c product entry 631 * @return whether the s c product entry is associated with the s c license 632 * @throws SystemException if a system exception occurred 633 */ 634 public static boolean containsSCProductEntry(long pk, long scProductEntryPK) 635 throws com.liferay.portal.kernel.exception.SystemException { 636 return getPersistence().containsSCProductEntry(pk, scProductEntryPK); 637 } 638 639 /** 640 * Determines whether the s c license has any s c product entries associated with it. 641 * 642 * @param pk the primary key of the s c license to check for associations with s c product entries 643 * @return whether the s c license has any s c product entries associated with it 644 * @throws SystemException if a system exception occurred 645 */ 646 public static boolean containsSCProductEntries(long pk) 647 throws com.liferay.portal.kernel.exception.SystemException { 648 return getPersistence().containsSCProductEntries(pk); 649 } 650 651 /** 652 * 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. 653 * 654 * @param pk the primary key of the s c license 655 * @param scProductEntryPK the primary key of the s c product entry 656 * @throws SystemException if a system exception occurred 657 */ 658 public static void addSCProductEntry(long pk, long scProductEntryPK) 659 throws com.liferay.portal.kernel.exception.SystemException { 660 getPersistence().addSCProductEntry(pk, scProductEntryPK); 661 } 662 663 /** 664 * 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. 665 * 666 * @param pk the primary key of the s c license 667 * @param scProductEntry the s c product entry 668 * @throws SystemException if a system exception occurred 669 */ 670 public static void addSCProductEntry(long pk, 671 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 672 throws com.liferay.portal.kernel.exception.SystemException { 673 getPersistence().addSCProductEntry(pk, scProductEntry); 674 } 675 676 /** 677 * 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. 678 * 679 * @param pk the primary key of the s c license 680 * @param scProductEntryPKs the primary keys of the s c product entries 681 * @throws SystemException if a system exception occurred 682 */ 683 public static void addSCProductEntries(long pk, long[] scProductEntryPKs) 684 throws com.liferay.portal.kernel.exception.SystemException { 685 getPersistence().addSCProductEntries(pk, scProductEntryPKs); 686 } 687 688 /** 689 * 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. 690 * 691 * @param pk the primary key of the s c license 692 * @param scProductEntries the s c product entries 693 * @throws SystemException if a system exception occurred 694 */ 695 public static void addSCProductEntries(long pk, 696 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 697 throws com.liferay.portal.kernel.exception.SystemException { 698 getPersistence().addSCProductEntries(pk, scProductEntries); 699 } 700 701 /** 702 * 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. 703 * 704 * @param pk the primary key of the s c license to clear the associated s c product entries from 705 * @throws SystemException if a system exception occurred 706 */ 707 public static void clearSCProductEntries(long pk) 708 throws com.liferay.portal.kernel.exception.SystemException { 709 getPersistence().clearSCProductEntries(pk); 710 } 711 712 /** 713 * 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. 714 * 715 * @param pk the primary key of the s c license 716 * @param scProductEntryPK the primary key of the s c product entry 717 * @throws SystemException if a system exception occurred 718 */ 719 public static void removeSCProductEntry(long pk, long scProductEntryPK) 720 throws com.liferay.portal.kernel.exception.SystemException { 721 getPersistence().removeSCProductEntry(pk, scProductEntryPK); 722 } 723 724 /** 725 * 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. 726 * 727 * @param pk the primary key of the s c license 728 * @param scProductEntry the s c product entry 729 * @throws SystemException if a system exception occurred 730 */ 731 public static void removeSCProductEntry(long pk, 732 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 733 throws com.liferay.portal.kernel.exception.SystemException { 734 getPersistence().removeSCProductEntry(pk, scProductEntry); 735 } 736 737 /** 738 * 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. 739 * 740 * @param pk the primary key of the s c license 741 * @param scProductEntryPKs the primary keys of the s c product entries 742 * @throws SystemException if a system exception occurred 743 */ 744 public static void removeSCProductEntries(long pk, long[] scProductEntryPKs) 745 throws com.liferay.portal.kernel.exception.SystemException { 746 getPersistence().removeSCProductEntries(pk, scProductEntryPKs); 747 } 748 749 /** 750 * 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. 751 * 752 * @param pk the primary key of the s c license 753 * @param scProductEntries the s c product entries 754 * @throws SystemException if a system exception occurred 755 */ 756 public static void removeSCProductEntries(long pk, 757 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 758 throws com.liferay.portal.kernel.exception.SystemException { 759 getPersistence().removeSCProductEntries(pk, scProductEntries); 760 } 761 762 /** 763 * 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. 764 * 765 * @param pk the primary key of the s c license to set the associations for 766 * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license 767 * @throws SystemException if a system exception occurred 768 */ 769 public static void setSCProductEntries(long pk, long[] scProductEntryPKs) 770 throws com.liferay.portal.kernel.exception.SystemException { 771 getPersistence().setSCProductEntries(pk, scProductEntryPKs); 772 } 773 774 /** 775 * 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. 776 * 777 * @param pk the primary key of the s c license to set the associations for 778 * @param scProductEntries the s c product entries to be associated with the s c license 779 * @throws SystemException if a system exception occurred 780 */ 781 public static void setSCProductEntries(long pk, 782 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 783 throws com.liferay.portal.kernel.exception.SystemException { 784 getPersistence().setSCProductEntries(pk, scProductEntries); 785 } 786 787 public static SCLicensePersistence getPersistence() { 788 if (_persistence == null) { 789 _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName()); 790 } 791 792 return _persistence; 793 } 794 795 public void setPersistence(SCLicensePersistence persistence) { 796 _persistence = persistence; 797 } 798 799 private static SCLicensePersistence _persistence; 800 }