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