001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.softwarecatalog.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.softwarecatalog.model.SCLicense; 022 023 /** 024 * The persistence interface for the s c license service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCLicensePersistenceImpl 032 * @see SCLicenseUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCLicensePersistence extends BasePersistence<SCLicense> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * 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. 041 */ 042 043 /** 044 * Returns all the s c licenses where active = ?. 045 * 046 * @param active the active 047 * @return the matching s c licenses 048 */ 049 public java.util.List<SCLicense> findByActive(boolean active); 050 051 /** 052 * Returns a range of all the s c licenses where active = ?. 053 * 054 * <p> 055 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 056 * </p> 057 * 058 * @param active the active 059 * @param start the lower bound of the range of s c licenses 060 * @param end the upper bound of the range of s c licenses (not inclusive) 061 * @return the range of matching s c licenses 062 */ 063 public java.util.List<SCLicense> findByActive(boolean active, int start, 064 int end); 065 066 /** 067 * Returns an ordered range of all the s c licenses where active = ?. 068 * 069 * <p> 070 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 071 * </p> 072 * 073 * @param active the active 074 * @param start the lower bound of the range of s c licenses 075 * @param end the upper bound of the range of s c licenses (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching s c licenses 078 */ 079 public java.util.List<SCLicense> findByActive(boolean active, int start, 080 int end, 081 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 082 083 /** 084 * Returns the first s c license in the ordered set where active = ?. 085 * 086 * @param active the active 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching s c license 089 * @throws NoSuchLicenseException if a matching s c license could not be found 090 */ 091 public SCLicense findByActive_First(boolean active, 092 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 093 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 094 095 /** 096 * Returns the first s c license in the ordered set where active = ?. 097 * 098 * @param active the active 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 101 */ 102 public SCLicense fetchByActive_First(boolean active, 103 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 104 105 /** 106 * Returns the last s c license in the ordered set where active = ?. 107 * 108 * @param active the active 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching s c license 111 * @throws NoSuchLicenseException if a matching s c license could not be found 112 */ 113 public SCLicense findByActive_Last(boolean active, 114 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 115 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 116 117 /** 118 * Returns the last s c license in the ordered set where active = ?. 119 * 120 * @param active the active 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 123 */ 124 public SCLicense fetchByActive_Last(boolean active, 125 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 126 127 /** 128 * Returns the s c licenses before and after the current s c license in the ordered set where active = ?. 129 * 130 * @param licenseId the primary key of the current s c license 131 * @param active the active 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next s c license 134 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 135 */ 136 public SCLicense[] findByActive_PrevAndNext(long licenseId, boolean active, 137 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 138 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 139 140 /** 141 * Returns all the s c licenses that the user has permission to view where active = ?. 142 * 143 * @param active the active 144 * @return the matching s c licenses that the user has permission to view 145 */ 146 public java.util.List<SCLicense> filterFindByActive(boolean active); 147 148 /** 149 * Returns a range of all the s c licenses that the user has permission to view where active = ?. 150 * 151 * <p> 152 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCLicenseModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 153 * </p> 154 * 155 * @param active the active 156 * @param start the lower bound of the range of s c licenses 157 * @param end the upper bound of the range of s c licenses (not inclusive) 158 * @return the range of matching s c licenses that the user has permission to view 159 */ 160 public java.util.List<SCLicense> filterFindByActive(boolean active, 161 int start, int end); 162 163 /** 164 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ?. 165 * 166 * <p> 167 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 168 * </p> 169 * 170 * @param active the active 171 * @param start the lower bound of the range of s c licenses 172 * @param end the upper bound of the range of s c licenses (not inclusive) 173 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 174 * @return the ordered range of matching s c licenses that the user has permission to view 175 */ 176 public java.util.List<SCLicense> filterFindByActive(boolean active, 177 int start, int end, 178 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 179 180 /** 181 * 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 = ?. 182 * 183 * @param licenseId the primary key of the current s c license 184 * @param active the active 185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 186 * @return the previous, current, and next s c license 187 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 188 */ 189 public SCLicense[] filterFindByActive_PrevAndNext(long licenseId, 190 boolean active, 191 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 192 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 193 194 /** 195 * Removes all the s c licenses where active = ? from the database. 196 * 197 * @param active the active 198 */ 199 public void removeByActive(boolean active); 200 201 /** 202 * Returns the number of s c licenses where active = ?. 203 * 204 * @param active the active 205 * @return the number of matching s c licenses 206 */ 207 public int countByActive(boolean active); 208 209 /** 210 * Returns the number of s c licenses that the user has permission to view where active = ?. 211 * 212 * @param active the active 213 * @return the number of matching s c licenses that the user has permission to view 214 */ 215 public int filterCountByActive(boolean active); 216 217 /** 218 * Returns all the s c licenses where active = ? and recommended = ?. 219 * 220 * @param active the active 221 * @param recommended the recommended 222 * @return the matching s c licenses 223 */ 224 public java.util.List<SCLicense> findByA_R(boolean active, 225 boolean recommended); 226 227 /** 228 * Returns a range of all the s c licenses where active = ? and recommended = ?. 229 * 230 * <p> 231 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 232 * </p> 233 * 234 * @param active the active 235 * @param recommended the recommended 236 * @param start the lower bound of the range of s c licenses 237 * @param end the upper bound of the range of s c licenses (not inclusive) 238 * @return the range of matching s c licenses 239 */ 240 public java.util.List<SCLicense> findByA_R(boolean active, 241 boolean recommended, int start, int end); 242 243 /** 244 * Returns an ordered range of all the s c licenses where active = ? and recommended = ?. 245 * 246 * <p> 247 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 248 * </p> 249 * 250 * @param active the active 251 * @param recommended the recommended 252 * @param start the lower bound of the range of s c licenses 253 * @param end the upper bound of the range of s c licenses (not inclusive) 254 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 255 * @return the ordered range of matching s c licenses 256 */ 257 public java.util.List<SCLicense> findByA_R(boolean active, 258 boolean recommended, int start, int end, 259 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 260 261 /** 262 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 263 * 264 * @param active the active 265 * @param recommended the recommended 266 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 267 * @return the first matching s c license 268 * @throws NoSuchLicenseException if a matching s c license could not be found 269 */ 270 public SCLicense findByA_R_First(boolean active, boolean recommended, 271 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 272 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 273 274 /** 275 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 276 * 277 * @param active the active 278 * @param recommended the recommended 279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 280 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 281 */ 282 public SCLicense fetchByA_R_First(boolean active, boolean recommended, 283 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 284 285 /** 286 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 287 * 288 * @param active the active 289 * @param recommended the recommended 290 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 291 * @return the last matching s c license 292 * @throws NoSuchLicenseException if a matching s c license could not be found 293 */ 294 public SCLicense findByA_R_Last(boolean active, boolean recommended, 295 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 296 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 297 298 /** 299 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 300 * 301 * @param active the active 302 * @param recommended the recommended 303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 304 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 305 */ 306 public SCLicense fetchByA_R_Last(boolean active, boolean recommended, 307 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 308 309 /** 310 * Returns the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 311 * 312 * @param licenseId the primary key of the current s c license 313 * @param active the active 314 * @param recommended the recommended 315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 316 * @return the previous, current, and next s c license 317 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 318 */ 319 public SCLicense[] findByA_R_PrevAndNext(long licenseId, boolean active, 320 boolean recommended, 321 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 322 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 323 324 /** 325 * Returns all the s c licenses that the user has permission to view where active = ? and recommended = ?. 326 * 327 * @param active the active 328 * @param recommended the recommended 329 * @return the matching s c licenses that the user has permission to view 330 */ 331 public java.util.List<SCLicense> filterFindByA_R(boolean active, 332 boolean recommended); 333 334 /** 335 * Returns a range of all the s c licenses that the user has permission to view where active = ? and recommended = ?. 336 * 337 * <p> 338 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 339 * </p> 340 * 341 * @param active the active 342 * @param recommended the recommended 343 * @param start the lower bound of the range of s c licenses 344 * @param end the upper bound of the range of s c licenses (not inclusive) 345 * @return the range of matching s c licenses that the user has permission to view 346 */ 347 public java.util.List<SCLicense> filterFindByA_R(boolean active, 348 boolean recommended, int start, int end); 349 350 /** 351 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ? and recommended = ?. 352 * 353 * <p> 354 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 355 * </p> 356 * 357 * @param active the active 358 * @param recommended the recommended 359 * @param start the lower bound of the range of s c licenses 360 * @param end the upper bound of the range of s c licenses (not inclusive) 361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 362 * @return the ordered range of matching s c licenses that the user has permission to view 363 */ 364 public java.util.List<SCLicense> filterFindByA_R(boolean active, 365 boolean recommended, int start, int end, 366 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 367 368 /** 369 * 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 = ?. 370 * 371 * @param licenseId the primary key of the current s c license 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 previous, current, and next s c license 376 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 377 */ 378 public SCLicense[] filterFindByA_R_PrevAndNext(long licenseId, 379 boolean active, boolean recommended, 380 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator) 381 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 382 383 /** 384 * Removes all the s c licenses where active = ? and recommended = ? from the database. 385 * 386 * @param active the active 387 * @param recommended the recommended 388 */ 389 public void removeByA_R(boolean active, boolean recommended); 390 391 /** 392 * Returns the number of s c licenses where active = ? and recommended = ?. 393 * 394 * @param active the active 395 * @param recommended the recommended 396 * @return the number of matching s c licenses 397 */ 398 public int countByA_R(boolean active, boolean recommended); 399 400 /** 401 * Returns the number of s c licenses that the user has permission to view where active = ? and recommended = ?. 402 * 403 * @param active the active 404 * @param recommended the recommended 405 * @return the number of matching s c licenses that the user has permission to view 406 */ 407 public int filterCountByA_R(boolean active, boolean recommended); 408 409 /** 410 * Caches the s c license in the entity cache if it is enabled. 411 * 412 * @param scLicense the s c license 413 */ 414 public void cacheResult(SCLicense scLicense); 415 416 /** 417 * Caches the s c licenses in the entity cache if it is enabled. 418 * 419 * @param scLicenses the s c licenses 420 */ 421 public void cacheResult(java.util.List<SCLicense> scLicenses); 422 423 /** 424 * Creates a new s c license with the primary key. Does not add the s c license to the database. 425 * 426 * @param licenseId the primary key for the new s c license 427 * @return the new s c license 428 */ 429 public SCLicense create(long licenseId); 430 431 /** 432 * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners. 433 * 434 * @param licenseId the primary key of the s c license 435 * @return the s c license that was removed 436 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 437 */ 438 public SCLicense remove(long licenseId) 439 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 440 441 public SCLicense updateImpl(SCLicense scLicense); 442 443 /** 444 * Returns the s c license with the primary key or throws a {@link NoSuchLicenseException} if it could not be found. 445 * 446 * @param licenseId the primary key of the s c license 447 * @return the s c license 448 * @throws NoSuchLicenseException if a s c license with the primary key could not be found 449 */ 450 public SCLicense findByPrimaryKey(long licenseId) 451 throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 452 453 /** 454 * Returns the s c license with the primary key or returns <code>null</code> if it could not be found. 455 * 456 * @param licenseId the primary key of the s c license 457 * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found 458 */ 459 public SCLicense fetchByPrimaryKey(long licenseId); 460 461 @Override 462 public java.util.Map<java.io.Serializable, SCLicense> fetchByPrimaryKeys( 463 java.util.Set<java.io.Serializable> primaryKeys); 464 465 /** 466 * Returns all the s c licenses. 467 * 468 * @return the s c licenses 469 */ 470 public java.util.List<SCLicense> findAll(); 471 472 /** 473 * Returns a range of all the s c licenses. 474 * 475 * <p> 476 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 477 * </p> 478 * 479 * @param start the lower bound of the range of s c licenses 480 * @param end the upper bound of the range of s c licenses (not inclusive) 481 * @return the range of s c licenses 482 */ 483 public java.util.List<SCLicense> findAll(int start, int end); 484 485 /** 486 * Returns an ordered range of all the s c licenses. 487 * 488 * <p> 489 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 490 * </p> 491 * 492 * @param start the lower bound of the range of s c licenses 493 * @param end the upper bound of the range of s c licenses (not inclusive) 494 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 495 * @return the ordered range of s c licenses 496 */ 497 public java.util.List<SCLicense> findAll(int start, int end, 498 com.liferay.portal.kernel.util.OrderByComparator<SCLicense> orderByComparator); 499 500 /** 501 * Removes all the s c licenses from the database. 502 */ 503 public void removeAll(); 504 505 /** 506 * Returns the number of s c licenses. 507 * 508 * @return the number of s c licenses 509 */ 510 public int countAll(); 511 512 /** 513 * Returns the primaryKeys of s c product entries associated with the s c license. 514 * 515 * @param pk the primary key of the s c license 516 * @return long[] of the primaryKeys of s c product entries associated with the s c license 517 */ 518 public long[] getSCProductEntryPrimaryKeys(long pk); 519 520 /** 521 * Returns all the s c product entries associated with the s c license. 522 * 523 * @param pk the primary key of the s c license 524 * @return the s c product entries associated with the s c license 525 */ 526 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 527 long pk); 528 529 /** 530 * Returns a range of all the s c product entries associated with the s c license. 531 * 532 * <p> 533 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 534 * </p> 535 * 536 * @param pk the primary key of the s c license 537 * @param start the lower bound of the range of s c licenses 538 * @param end the upper bound of the range of s c licenses (not inclusive) 539 * @return the range of s c product entries associated with the s c license 540 */ 541 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 542 long pk, int start, int end); 543 544 /** 545 * Returns an ordered range of all the s c product entries associated with the s c license. 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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 pk the primary key of the s c license 552 * @param start the lower bound of the range of s c licenses 553 * @param end the upper bound of the range of s c licenses (not inclusive) 554 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 555 * @return the ordered range of s c product entries associated with the s c license 556 */ 557 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 558 long pk, int start, int end, 559 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCProductEntry> orderByComparator); 560 561 /** 562 * Returns the number of s c product entries associated with the s c license. 563 * 564 * @param pk the primary key of the s c license 565 * @return the number of s c product entries associated with the s c license 566 */ 567 public int getSCProductEntriesSize(long pk); 568 569 /** 570 * Returns <code>true</code> if the s c product entry is associated with the s c license. 571 * 572 * @param pk the primary key of the s c license 573 * @param scProductEntryPK the primary key of the s c product entry 574 * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise 575 */ 576 public boolean containsSCProductEntry(long pk, long scProductEntryPK); 577 578 /** 579 * Returns <code>true</code> if the s c license has any s c product entries associated with it. 580 * 581 * @param pk the primary key of the s c license to check for associations with s c product entries 582 * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise 583 */ 584 public boolean containsSCProductEntries(long pk); 585 586 /** 587 * 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. 588 * 589 * @param pk the primary key of the s c license 590 * @param scProductEntryPK the primary key of the s c product entry 591 */ 592 public void addSCProductEntry(long pk, long scProductEntryPK); 593 594 /** 595 * 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. 596 * 597 * @param pk the primary key of the s c license 598 * @param scProductEntry the s c product entry 599 */ 600 public void addSCProductEntry(long pk, 601 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry); 602 603 /** 604 * 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. 605 * 606 * @param pk the primary key of the s c license 607 * @param scProductEntryPKs the primary keys of the s c product entries 608 */ 609 public void addSCProductEntries(long pk, long[] scProductEntryPKs); 610 611 /** 612 * 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. 613 * 614 * @param pk the primary key of the s c license 615 * @param scProductEntries the s c product entries 616 */ 617 public void addSCProductEntries(long pk, 618 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries); 619 620 /** 621 * 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. 622 * 623 * @param pk the primary key of the s c license to clear the associated s c product entries from 624 */ 625 public void clearSCProductEntries(long pk); 626 627 /** 628 * 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. 629 * 630 * @param pk the primary key of the s c license 631 * @param scProductEntryPK the primary key of the s c product entry 632 */ 633 public void removeSCProductEntry(long pk, long scProductEntryPK); 634 635 /** 636 * 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. 637 * 638 * @param pk the primary key of the s c license 639 * @param scProductEntry the s c product entry 640 */ 641 public void removeSCProductEntry(long pk, 642 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry); 643 644 /** 645 * 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. 646 * 647 * @param pk the primary key of the s c license 648 * @param scProductEntryPKs the primary keys of the s c product entries 649 */ 650 public void removeSCProductEntries(long pk, long[] scProductEntryPKs); 651 652 /** 653 * 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. 654 * 655 * @param pk the primary key of the s c license 656 * @param scProductEntries the s c product entries 657 */ 658 public void removeSCProductEntries(long pk, 659 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries); 660 661 /** 662 * 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. 663 * 664 * @param pk the primary key of the s c license 665 * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license 666 */ 667 public void setSCProductEntries(long pk, long[] scProductEntryPKs); 668 669 /** 670 * 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. 671 * 672 * @param pk the primary key of the s c license 673 * @param scProductEntries the s c product entries to be associated with the s c license 674 */ 675 public void setSCProductEntries(long pk, 676 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries); 677 }