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