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