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