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